SemaChecking.cpp revision 31f8e32788adb299acad455363eb7fd244642c82
159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner//===--- SemaChecking.cpp - Extra Semantic Checking -----------------------===// 259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// The LLVM Compiler Infrastructure 459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 759907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner//===----------------------------------------------------------------------===// 959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump// This file implements extra semantic analysis beyond what is enforced 1159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// by the C type system. 1259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 1359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner//===----------------------------------------------------------------------===// 1459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 1559907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "Sema.h" 16f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "clang/Analysis/CFG.h" 171309f9a3b225ea846e5822691c39a77423125505Ted Kremenek#include "clang/Analysis/AnalysisContext.h" 18e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek#include "clang/Analysis/Analyses/PrintfFormatString.h" 1959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "clang/AST/ASTContext.h" 20199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck#include "clang/AST/CharUnits.h" 21c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 222324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek#include "clang/AST/ExprCXX.h" 237ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek#include "clang/AST/ExprObjC.h" 24f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "clang/AST/DeclObjC.h" 25f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "clang/AST/StmtCXX.h" 26f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "clang/AST/StmtObjC.h" 27719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner#include "clang/Lex/LiteralSupport.h" 2859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "clang/Lex/Preprocessor.h" 29f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "llvm/ADT/BitVector.h" 30f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include "llvm/ADT/STLExtras.h" 31a1f3dba77b7418575c1ff539ffa74ebaa068280cZhongxing Xu#include <limits> 32f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump#include <queue> 3359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattnerusing namespace clang; 3459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 3560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// getLocationOfStringLiteralByte - Return a source location that points to the 3660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// specified byte of the specified string literal. 3760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// 3860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// Strings are amazingly complex. They can be formed from multiple tokens and 3960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// can have escape sequences in them in addition to the usual trigraph and 4060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// escaped newline business. This routine handles this complexity. 4160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// 4260800081361b0ffc114877b8abbc81cb57b4edf6Chris LattnerSourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL, 4360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner unsigned ByteNo) const { 4460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner assert(!SL->isWide() && "This doesn't work for wide strings yet"); 451eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Loop over all of the tokens in this string until we find the one that 4760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // contains the byte we're looking for. 4860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner unsigned TokNo = 0; 4960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner while (1) { 5060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner assert(TokNo < SL->getNumConcatenated() && "Invalid byte number!"); 5160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation StrTokLoc = SL->getStrTokenLoc(TokNo); 521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Get the spelling of the string so that we can get the data that makes up 5460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // the string literal, not the identifier for the macro it is potentially 5560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // expanded through. 5660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation StrTokSpellingLoc = SourceMgr.getSpellingLoc(StrTokLoc); 5760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 5860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Re-lex the token to get its length and original spelling. 5960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner std::pair<FileID, unsigned> LocInfo = 6060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceMgr.getDecomposedLoc(StrTokSpellingLoc); 6160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner std::pair<const char *,const char *> Buffer = 6260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceMgr.getBufferData(LocInfo.first); 6360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner const char *StrData = Buffer.first+LocInfo.second; 641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Create a langops struct and enable trigraphs. This is sufficient for 6660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // relexing tokens. 6760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner LangOptions LangOpts; 6860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner LangOpts.Trigraphs = true; 691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Create a lexer starting at the beginning of this token. 7160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Lexer TheLexer(StrTokSpellingLoc, LangOpts, Buffer.first, StrData, 7260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Buffer.second); 7360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Token TheTok; 7460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner TheLexer.LexFromRawLexer(TheTok); 751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 76443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner // Use the StringLiteralParser to compute the length of the string in bytes. 77443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner StringLiteralParser SLP(&TheTok, 1, PP); 78443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner unsigned TokNumBytes = SLP.GetStringLength(); 791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 802197c963543397777919cec22b65feb31a9ddf79Chris Lattner // If the byte is in this token, return the location of the byte. 8160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner if (ByteNo < TokNumBytes || 8260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner (ByteNo == TokNumBytes && TokNo == SL->getNumConcatenated())) { 831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned Offset = 84719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner StringLiteralParser::getOffsetOfStringByte(TheTok, ByteNo, PP); 851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 86719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner // Now that we know the offset of the token in the spelling, use the 87719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner // preprocessor to get the offset in the original source. 88719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner return PP.AdvanceToTokenCharacter(StrTokLoc, Offset); 8960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner } 901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 9160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Move to the next string token. 9260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner ++TokNo; 9360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner ByteNo -= TokNumBytes; 9460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner } 9560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner} 9660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 974403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn/// CheckablePrintfAttr - does a function call have a "printf" attribute 984403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn/// and arguments that merit checking? 994403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynnbool Sema::CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall) { 1004403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (Format->getType() == "printf") return true; 1014403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (Format->getType() == "printf0") { 1024403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn // printf0 allows null "format" string; if so don't check format/args 1034403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn unsigned format_idx = Format->getFormatIdx() - 1; 1044a2614e94672c47395abcde60518776fbebec589Sebastian Redl // Does the index refer to the implicit object argument? 1054a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (isa<CXXMemberCallExpr>(TheCall)) { 1064a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (format_idx == 0) 1074a2614e94672c47395abcde60518776fbebec589Sebastian Redl return false; 1084a2614e94672c47395abcde60518776fbebec589Sebastian Redl --format_idx; 1094a2614e94672c47395abcde60518776fbebec589Sebastian Redl } 1104403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (format_idx < TheCall->getNumArgs()) { 1114403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn Expr *Format = TheCall->getArg(format_idx)->IgnoreParenCasts(); 112ce94049b69f75b44c18584fe79cd238978b6b0d5Douglas Gregor if (!Format->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 1134403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn return true; 1144403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn } 1154403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn } 1164403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn return false; 1174403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn} 11860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 1190eb23307222bda7ad95d968eac4e1ab30864b213Sebastian RedlAction::OwningExprResult 120d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders CarlssonSema::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) { 1210eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl OwningExprResult TheCallResult(Owned(TheCall)); 1222def48394f6d48bde0dec2b514193c2b533265b5Douglas Gregor 123d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson switch (BuiltinID) { 12430ce344307f8a8b00054021307015571f83c7364Chris Lattner case Builtin::BI__builtin___CFStringMakeConstantString: 125925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner assert(TheCall->getNumArgs() == 1 && 1261b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner "Wrong # arguments to builtin CFStringMakeConstantString"); 127690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattner if (CheckObjCString(TheCall->getArg(0))) 1280eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 129d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 13049ff7a1c8c67d56e62d3b4627463b705c0d5008cTed Kremenek case Builtin::BI__builtin_stdarg_start: 13130ce344307f8a8b00054021307015571f83c7364Chris Lattner case Builtin::BI__builtin_va_start: 1320eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinVAStart(TheCall)) 1330eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 134d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 1351b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isgreater: 1361b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isgreaterequal: 1371b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isless: 1381b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_islessequal: 1391b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_islessgreater: 1401b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isunordered: 1410eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinUnorderedCompare(TheCall)) 1420eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 143d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 1449ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isfinite: 1459ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isinf: 1469ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isinf_sign: 1479ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isnan: 1489ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman case Builtin::BI__builtin_isnormal: 1499ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (SemaBuiltinUnaryFP(TheCall)) 1509ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return ExprError(); 1519ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman break; 1526cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman case Builtin::BI__builtin_return_address: 1536cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman case Builtin::BI__builtin_frame_address: 1540eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinStackAddress(TheCall)) 1550eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 156d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 15721fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner case Builtin::BI__builtin_eh_return_data_regno: 15821fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner if (SemaBuiltinEHReturnDataRegNo(TheCall)) 15921fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner return ExprError(); 16021fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner break; 161d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman case Builtin::BI__builtin_shufflevector: 1620eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return SemaBuiltinShuffleVector(TheCall); 1630eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl // TheCall will be freed by the smart pointer here, but that's fine, since 1640eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl // SemaBuiltinShuffleVector guts it, but then doesn't release it. 1654493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar case Builtin::BI__builtin_prefetch: 1660eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinPrefetch(TheCall)) 1670eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 168d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 169d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar case Builtin::BI__builtin_object_size: 1700eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinObjectSize(TheCall)) 1710eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 172d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 173d875fed28578835de89cd407e9db4be788596d7cEli Friedman case Builtin::BI__builtin_longjmp: 174d875fed28578835de89cd407e9db4be788596d7cEli Friedman if (SemaBuiltinLongjmp(TheCall)) 175d875fed28578835de89cd407e9db4be788596d7cEli Friedman return ExprError(); 176d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 1775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_add: 1785caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_sub: 1795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_or: 1805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_and: 1815caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_xor: 182eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_fetch_and_nand: 1835caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_add_and_fetch: 1845caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_sub_and_fetch: 1855caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_and_and_fetch: 1865caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_or_and_fetch: 1875caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_xor_and_fetch: 188eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_nand_and_fetch: 1895caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_val_compare_and_swap: 1905caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_bool_compare_and_swap: 1915caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_test_and_set: 1925caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_release: 1935caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (SemaBuiltinAtomicOverloaded(TheCall)) 1945caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return ExprError(); 195d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson break; 19671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 1971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 198d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return move(TheCallResult); 199d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson} 200d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson 201d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson/// CheckFunctionCall - Check a direct function call for various correctness 202d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson/// and safety properties not strictly enforced by the C type system. 203d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlssonbool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall) { 204d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // Get the IdentifierInfo* for the called function. 205d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson IdentifierInfo *FnInfo = FDecl->getIdentifier(); 206de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar 207d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // None of the checks below are needed for functions that don't have 208d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson // simple names (e.g., C++ conversion functions). 209d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (!FnInfo) 210d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 212de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // FIXME: This mechanism should be abstracted to be less fragile and 213de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // more efficient. For example, just map function ids to custom 214de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // handlers. 215de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar 21659907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // Printf checking. 21740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis if (const FormatAttr *Format = FDecl->getAttr<FormatAttr>()) { 2184403a5e1f956fa86d515492dbe7c7a2817d8780dRyan Flynn if (CheckablePrintfAttr(Format, TheCall)) { 2193d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek bool HasVAListArg = Format->getFirstArg() == 0; 2203d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek if (!HasVAListArg) { 2211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const FunctionProtoType *Proto 222183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall = FDecl->getType()->getAs<FunctionProtoType>()) 2234a2614e94672c47395abcde60518776fbebec589Sebastian Redl HasVAListArg = !Proto->isVariadic(); 2243d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek } 2253c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1, 2263d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek HasVAListArg ? 0 : Format->getFirstArg() - 1); 2273c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor } 22859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner } 2291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (const NonNullAttr *NonNull = FDecl->getAttr<NonNullAttr>(); NonNull; 231d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson NonNull = NonNull->getNext<NonNullAttr>()) 232d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson CheckNonNullArguments(NonNull, TheCall); 2330eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl 234d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 23571993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson} 23671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 237d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlssonbool Sema::CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall) { 238725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian // Printf checking. 23940b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis const FormatAttr *Format = NDecl->getAttr<FormatAttr>(); 240725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!Format) 241d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 243725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian const VarDecl *V = dyn_cast<VarDecl>(NDecl); 244725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!V) 245d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 247725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian QualType Ty = V->getType(); 248725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!Ty->isBlockPointerType()) 249d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2501eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 251d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (!CheckablePrintfAttr(Format, TheCall)) 252d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 2531eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 254d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson bool HasVAListArg = Format->getFirstArg() == 0; 255d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (!HasVAListArg) { 2561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const FunctionType *FT = 257183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>(); 258d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) 259d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson HasVAListArg = !Proto->isVariadic(); 260725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian } 261d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1, 262d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson HasVAListArg ? 0 : Format->getFirstArg() - 1); 263d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson 264d406bf0e8c17012110a8476d03c6f9a97b56ecf7Anders Carlsson return false; 265725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian} 266725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian 2675caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// SemaBuiltinAtomicOverloaded - We have a call to a function like 2685caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// __sync_fetch_and_add, which is an overloaded function based on the pointer 2695caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// type of its first argument. The main ActOnCallExpr routines have already 2705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// promoted the types of arguments because all of these calls are prototyped as 2715caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// void(...). 2725caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// 2735caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// This function goes through and does final semantic checking for these 2745caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// builtins, 2755caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattnerbool Sema::SemaBuiltinAtomicOverloaded(CallExpr *TheCall) { 2765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts()); 2775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl()); 2785caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Ensure that we have at least one argument to do type inference from. 2805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (TheCall->getNumArgs() < 1) 2815caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 2825caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << 0 << TheCall->getCallee()->getSourceRange(); 2831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2845caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Inspect the first argument of the atomic builtin. This should always be 2855caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // a pointer type, whose element is an integral scalar or pointer type. 2865caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Because it is a pointer type, we don't have to worry about any implicit 2875caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // casts here. 2885caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *FirstArg = TheCall->getArg(0); 2895caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (!FirstArg->getType()->isPointerType()) 2905caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer) 2915caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 2921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2936217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek QualType ValType = FirstArg->getType()->getAs<PointerType>()->getPointeeType(); 2941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!ValType->isIntegerType() && !ValType->isPointerType() && 2955caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner !ValType->isBlockPointerType()) 2965caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), 2975caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner diag::err_atomic_builtin_must_be_pointer_intptr) 2985caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 2995caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3005caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // We need to figure out which concrete builtin this maps onto. For example, 3015caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // __sync_fetch_and_add with a 2 byte object turns into 3025caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // __sync_fetch_and_add_2. 3035caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner#define BUILTIN_ROW(x) \ 3045caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \ 3055caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Builtin::BI##x##_8, Builtin::BI##x##_16 } 3061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3075caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner static const unsigned BuiltinIndices[][5] = { 3085caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_add), 3095caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_sub), 3105caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_or), 3115caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_and), 3125caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_xor), 313eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BUILTIN_ROW(__sync_fetch_and_nand), 3141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3155caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_add_and_fetch), 3165caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_sub_and_fetch), 3175caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_and_and_fetch), 3185caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_or_and_fetch), 3195caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_xor_and_fetch), 320eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BUILTIN_ROW(__sync_nand_and_fetch), 3211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3225caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_val_compare_and_swap), 3235caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_bool_compare_and_swap), 3245caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_lock_test_and_set), 3255caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_lock_release) 3265caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner }; 3271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump#undef BUILTIN_ROW 3281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3295caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Determine the index of the size. 3305caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned SizeIndex; 331199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck switch (Context.getTypeSizeInChars(ValType).getQuantity()) { 3325caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 1: SizeIndex = 0; break; 3335caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 2: SizeIndex = 1; break; 3345caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 4: SizeIndex = 2; break; 3355caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 8: SizeIndex = 3; break; 3365caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 16: SizeIndex = 4; break; 3375caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner default: 3385caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), diag::err_atomic_builtin_pointer_size) 3395caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 3405caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 3411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3425caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Each of these builtins has one pointer argument, followed by some number of 3435caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // values (0, 1 or 2) followed by a potentially empty varags list of stuff 3445caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // that we ignore. Find out which row of BuiltinIndices to read from as well 3455caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // as the number of fixed args. 3467814e6d6645d587891293d59ecf6576defcfac92Douglas Gregor unsigned BuiltinID = FDecl->getBuiltinID(); 3475caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned BuiltinIndex, NumFixed = 1; 3485caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner switch (BuiltinID) { 3495caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner default: assert(0 && "Unknown overloaded atomic builtin!"); 3505caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_add: BuiltinIndex = 0; break; 3515caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_sub: BuiltinIndex = 1; break; 3525caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_or: BuiltinIndex = 2; break; 3535caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_and: BuiltinIndex = 3; break; 3545caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_xor: BuiltinIndex = 4; break; 355eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_fetch_and_nand:BuiltinIndex = 5; break; 3561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 357eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_add_and_fetch: BuiltinIndex = 6; break; 358eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_sub_and_fetch: BuiltinIndex = 7; break; 359eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_and_and_fetch: BuiltinIndex = 8; break; 360eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_or_and_fetch: BuiltinIndex = 9; break; 361eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_xor_and_fetch: BuiltinIndex =10; break; 362eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_nand_and_fetch:BuiltinIndex =11; break; 3631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3645caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_val_compare_and_swap: 365eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 12; 3665caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 2; 3675caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 3685caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_bool_compare_and_swap: 369eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 13; 3705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 2; 3715caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 372eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_lock_test_and_set: BuiltinIndex = 14; break; 3735caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_release: 374eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 15; 3755caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 0; 3765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 3775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 3781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Now that we know how many fixed arguments we expect, first check that we 3805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // have at least that many. 3815caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (TheCall->getNumArgs() < 1+NumFixed) 3825caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 3835caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << 0 << TheCall->getCallee()->getSourceRange(); 3841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 386e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // Get the decl for the concrete builtin from this, we can tell what the 387e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // concrete integer type we should convert to is. 388e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex]; 389e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner const char *NewBuiltinName = Context.BuiltinInfo.GetName(NewBuiltinID); 390e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner IdentifierInfo *NewBuiltinII = PP.getIdentifierInfo(NewBuiltinName); 3911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump FunctionDecl *NewBuiltinDecl = 392e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner cast<FunctionDecl>(LazilyCreateBuiltin(NewBuiltinII, NewBuiltinID, 393e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner TUScope, false, DRE->getLocStart())); 394e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner const FunctionProtoType *BuiltinFT = 395183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall NewBuiltinDecl->getType()->getAs<FunctionProtoType>(); 3966217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek ValType = BuiltinFT->getArgType(0)->getAs<PointerType>()->getPointeeType(); 3971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 398e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // If the first type needs to be converted (e.g. void** -> int*), do it now. 399e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner if (BuiltinFT->getArgType(0) != FirstArg->getType()) { 40073c39abdbb79927605d740c93dd9629e3e4f9bfeEli Friedman ImpCastExprToType(FirstArg, BuiltinFT->getArgType(0), CastExpr::CK_BitCast); 401e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner TheCall->setArg(0, FirstArg); 402e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner } 4031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4045caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Next, walk the valid ones promoting to the right type. 4055caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner for (unsigned i = 0; i != NumFixed; ++i) { 4065caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *Arg = TheCall->getArg(i+1); 4071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4085caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // If the argument is an implicit cast, then there was a promotion due to 4095caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // "...", just remove it now. 4105caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) { 4115caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Arg = ICE->getSubExpr(); 4125caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner ICE->setSubExpr(0); 4135caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner ICE->Destroy(Context); 4145caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setArg(i+1, Arg); 4155caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 4161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4175caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // GCC does an implicit conversion to the pointer or integer ValType. This 4185caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // can fail in some cases (1i -> int**), check for this error case now. 419cdb61979755c1c0699c1ee25eede9a50bf94d29bAnders Carlsson CastExpr::CastKind Kind = CastExpr::CK_Unknown; 420e9f42087aabfdb6b2afc35c7e38ac65da063b409Fariborz Jahanian CXXMethodDecl *ConversionDecl = 0; 421e9f42087aabfdb6b2afc35c7e38ac65da063b409Fariborz Jahanian if (CheckCastTypes(Arg->getSourceRange(), ValType, Arg, Kind, 422e9f42087aabfdb6b2afc35c7e38ac65da063b409Fariborz Jahanian ConversionDecl)) 4235caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return true; 4241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4255caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Okay, we have something that *can* be converted to the right type. Check 4265caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // to see if there is a potentially weird extension going on here. This can 4275caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // happen when you do an atomic operation on something like an char* and 4285caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // pass in 42. The 42 gets converted to char. This is even more strange 4295caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // for things like 45.123 -> char, etc. 4301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // FIXME: Do this check. 431cdb61979755c1c0699c1ee25eede9a50bf94d29bAnders Carlsson ImpCastExprToType(Arg, ValType, Kind, /*isLvalue=*/false); 4325caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setArg(i+1, Arg); 4335caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 4341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4355caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Switch the DeclRefExpr to refer to the new decl. 4365caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DRE->setDecl(NewBuiltinDecl); 4375caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DRE->setType(NewBuiltinDecl->getType()); 4381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4395caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Set the callee in the CallExpr. 4405caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // FIXME: This leaks the original parens and implicit casts. 4415caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *PromotedCall = DRE; 4425caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner UsualUnaryConversions(PromotedCall); 4435caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setCallee(PromotedCall); 4441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4455caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 4465caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Change the result type of the call to match the result type of the decl. 4475caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setType(NewBuiltinDecl->getResultType()); 4485caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return false; 4495caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner} 4505caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 4515caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 452690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattner/// CheckObjCString - Checks that the argument to the builtin 45371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson/// CFString constructor is correct 454fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// FIXME: GCC currently emits the following warning: 4551eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// "warning: input conversion stopped due to an input byte that does not 456fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// belong to the input codeset UTF-8" 457fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// Note: It might also make sense to do the UTF-16 conversion here (would 458fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// simplify the backend). 459690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattnerbool Sema::CheckObjCString(Expr *Arg) { 46056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Arg = Arg->IgnoreParenCasts(); 46171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson StringLiteral *Literal = dyn_cast<StringLiteral>(Arg); 46271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 46371993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!Literal || Literal->isWide()) { 464fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner Diag(Arg->getLocStart(), diag::err_cfstring_literal_not_string_constant) 465fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << Arg->getSourceRange(); 4669cdc4d3834f203dcde3ff274b8928e4620a914d5Anders Carlsson return true; 46771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 4681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 469f015b034159d40e7033309e50036804eb1971787Daniel Dunbar const char *Data = Literal->getStrData(); 470f015b034159d40e7033309e50036804eb1971787Daniel Dunbar unsigned Length = Literal->getByteLength(); 471f015b034159d40e7033309e50036804eb1971787Daniel Dunbar 472f015b034159d40e7033309e50036804eb1971787Daniel Dunbar for (unsigned i = 0; i < Length; ++i) { 473f015b034159d40e7033309e50036804eb1971787Daniel Dunbar if (!Data[i]) { 474f015b034159d40e7033309e50036804eb1971787Daniel Dunbar Diag(getLocationOfStringLiteralByte(Literal, i), 475f015b034159d40e7033309e50036804eb1971787Daniel Dunbar diag::warn_cfstring_literal_contains_nul_character) 476f015b034159d40e7033309e50036804eb1971787Daniel Dunbar << Arg->getSourceRange(); 477f015b034159d40e7033309e50036804eb1971787Daniel Dunbar break; 478f015b034159d40e7033309e50036804eb1971787Daniel Dunbar } 479f015b034159d40e7033309e50036804eb1971787Daniel Dunbar } 4801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4819cdc4d3834f203dcde3ff274b8928e4620a914d5Anders Carlsson return false; 48259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner} 48359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 484c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner/// SemaBuiltinVAStart - Check the arguments to __builtin_va_start for validity. 485c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner/// Emit an error and return true on failure, return false on success. 486925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattnerbool Sema::SemaBuiltinVAStart(CallExpr *TheCall) { 487925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *Fn = TheCall->getCallee(); 488925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() > 2) { 4892c21a073525cdfa68e4439b7af551385dc2796abChris Lattner Diag(TheCall->getArg(2)->getLocStart(), 490fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_too_many_args) 4912c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ << Fn->getSourceRange() 4921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(2)->getLocStart(), 493fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner (*(TheCall->arg_end()-1))->getLocEnd()); 49430ce344307f8a8b00054021307015571f83c7364Chris Lattner return true; 49530ce344307f8a8b00054021307015571f83c7364Chris Lattner } 49656f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman 49756f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman if (TheCall->getNumArgs() < 2) { 49856f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 49956f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman << 0 /*function call*/; 50056f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } 50156f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman 502c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner // Determine whether the current function is variadic or not. 503c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner bool isVariadic; 504cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff if (CurBlock) 505cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff isVariadic = CurBlock->isVariadic; 506cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff else if (getCurFunctionDecl()) { 50772564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor if (FunctionProtoType* FTP = 50872564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor dyn_cast<FunctionProtoType>(getCurFunctionDecl()->getType())) 50956f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman isVariadic = FTP->isVariadic(); 51056f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman else 51156f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman isVariadic = false; 51256f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } else { 51353d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis isVariadic = getCurMethodDecl()->isVariadic(); 51456f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } 5151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 516c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner if (!isVariadic) { 51730ce344307f8a8b00054021307015571f83c7364Chris Lattner Diag(Fn->getLocStart(), diag::err_va_start_used_in_non_variadic_function); 51830ce344307f8a8b00054021307015571f83c7364Chris Lattner return true; 51930ce344307f8a8b00054021307015571f83c7364Chris Lattner } 5201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52130ce344307f8a8b00054021307015571f83c7364Chris Lattner // Verify that the second argument to the builtin is the last argument of the 52230ce344307f8a8b00054021307015571f83c7364Chris Lattner // current function or method. 52330ce344307f8a8b00054021307015571f83c7364Chris Lattner bool SecondArgIsLastNamedArgument = false; 524e2c14103dec39cbd24dac9d7b3e91277b109c14fAnders Carlsson const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts(); 5251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 52688cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) { 52788cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) { 52830ce344307f8a8b00054021307015571f83c7364Chris Lattner // FIXME: This isn't correct for methods (results in bogus warning). 52930ce344307f8a8b00054021307015571f83c7364Chris Lattner // Get the last formal in the current function. 53088cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson const ParmVarDecl *LastArg; 531cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff if (CurBlock) 532cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff LastArg = *(CurBlock->TheDecl->param_end()-1); 533cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff else if (FunctionDecl *FD = getCurFunctionDecl()) 534371f258e61e1365b951b17931a3c5ac1530fd1a0Chris Lattner LastArg = *(FD->param_end()-1); 53530ce344307f8a8b00054021307015571f83c7364Chris Lattner else 53653d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis LastArg = *(getCurMethodDecl()->param_end()-1); 53730ce344307f8a8b00054021307015571f83c7364Chris Lattner SecondArgIsLastNamedArgument = PV == LastArg; 53830ce344307f8a8b00054021307015571f83c7364Chris Lattner } 53930ce344307f8a8b00054021307015571f83c7364Chris Lattner } 5401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 54130ce344307f8a8b00054021307015571f83c7364Chris Lattner if (!SecondArgIsLastNamedArgument) 5421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(1)->getLocStart(), 54330ce344307f8a8b00054021307015571f83c7364Chris Lattner diag::warn_second_parameter_of_va_start_not_last_named_argument); 54430ce344307f8a8b00054021307015571f83c7364Chris Lattner return false; 5456cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman} 54630ce344307f8a8b00054021307015571f83c7364Chris Lattner 5471b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner/// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isgreater and 5481b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner/// friends. This is declared to take (...), so we have to check everything. 549925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattnerbool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) { 550925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() < 2) 5512c21a073525cdfa68e4439b7af551385dc2796abChris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 5522c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/; 553925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() > 2) 5541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(TheCall->getArg(2)->getLocStart(), 555fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_too_many_args) 5562c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ 557fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(TheCall->getArg(2)->getLocStart(), 558fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner (*(TheCall->arg_end()-1))->getLocEnd()); 5591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 560925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *OrigArg0 = TheCall->getArg(0); 561925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *OrigArg1 = TheCall->getArg(1); 562cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 5631b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // Do standard promotions between the two arguments, returning their common 5641b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // type. 565925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner QualType Res = UsualArithmeticConversions(OrigArg0, OrigArg1, false); 566403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar 567403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // Make sure any conversions are pushed back into the call; this is 568403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // type safe since unordered compare builtins are declared as "_Bool 569403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // foo(...)". 570403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar TheCall->setArg(0, OrigArg0); 571403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar TheCall->setArg(1, OrigArg1); 5721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 573cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (OrigArg0->isTypeDependent() || OrigArg1->isTypeDependent()) 574cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 575cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 5761b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // If the common type isn't a real floating type, then the arguments were 5771b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // invalid for this operation. 5781b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner if (!Res->isRealFloatingType()) 5791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(OrigArg0->getLocStart(), 580fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_invalid_ordered_compare) 581d162584991885ab004a02573a73ce06422b921fcChris Lattner << OrigArg0->getType() << OrigArg1->getType() 582fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(OrigArg0->getLocStart(), OrigArg1->getLocEnd()); 5831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 5841b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner return false; 5851b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner} 5861b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner 5879ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman/// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isnan and 5889ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman/// friends. This is declared to take (...), so we have to check everything. 5899ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedmanbool Sema::SemaBuiltinUnaryFP(CallExpr *TheCall) { 5909ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (TheCall->getNumArgs() < 1) 5919ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 5929ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << 0 /*function call*/; 5939ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (TheCall->getNumArgs() > 1) 5941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(TheCall->getArg(1)->getLocStart(), 5959ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman diag::err_typecheck_call_too_many_args) 5969ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << 0 /*function call*/ 5979ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << SourceRange(TheCall->getArg(1)->getLocStart(), 5989ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman (*(TheCall->arg_end()-1))->getLocEnd()); 5999ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 6009ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman Expr *OrigArg = TheCall->getArg(0); 6011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6029ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (OrigArg->isTypeDependent()) 6039ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return false; 6049ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 6059ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman // This operation requires a floating-point number 6069ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman if (!OrigArg->getType()->isRealFloatingType()) 6071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Diag(OrigArg->getLocStart(), 6089ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman diag::err_typecheck_call_invalid_unary_fp) 6099ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman << OrigArg->getType() << OrigArg->getSourceRange(); 6101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6119ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman return false; 6129ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman} 6139ac6f62a77be5b281a7ddc24a16669b457ac47c2Eli Friedman 6146cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedmanbool Sema::SemaBuiltinStackAddress(CallExpr *TheCall) { 6156cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman // The signature for these builtins is exact; the only thing we need 6166cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman // to check is that the argument is a constant. 6176cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman SourceLocation Loc; 618cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!TheCall->getArg(0)->isTypeDependent() && 619cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(0)->isValueDependent() && 620cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(0)->isIntegerConstantExpr(Context, &Loc)) 621fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(Loc, diag::err_stack_const_level) << TheCall->getSourceRange(); 6221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6236cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman return false; 6246cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman} 6256cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman 626d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman/// SemaBuiltinShuffleVector - Handle __builtin_shufflevector. 627d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// This is declared to take (...), so we have to check everything. 6280eb23307222bda7ad95d968eac4e1ab30864b213Sebastian RedlAction::OwningExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) { 629d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman if (TheCall->getNumArgs() < 3) 6300eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocEnd(), 6310eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl diag::err_typecheck_call_too_few_args) 6320eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << 0 /*function call*/ << TheCall->getSourceRange()); 633d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 634cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor unsigned numElements = std::numeric_limits<unsigned>::max(); 635cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!TheCall->getArg(0)->isTypeDependent() && 636cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(1)->isTypeDependent()) { 637cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor QualType FAType = TheCall->getArg(0)->getType(); 638cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor QualType SAType = TheCall->getArg(1)->getType(); 6391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 640cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!FAType->isVectorType() || !SAType->isVectorType()) { 641cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Diag(TheCall->getLocStart(), diag::err_shufflevector_non_vector) 6421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(0)->getLocStart(), 643cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(1)->getLocEnd()); 644cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(); 645cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 6461eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 647a4923eb7c4b04d360cb2747641a5e92818edf804Douglas Gregor if (!Context.hasSameUnqualifiedType(FAType, SAType)) { 648cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector) 6491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump << SourceRange(TheCall->getArg(0)->getLocStart(), 650cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(1)->getLocEnd()); 651cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(); 652cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 653d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 654183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall numElements = FAType->getAs<VectorType>()->getNumElements(); 655cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getNumArgs() != numElements+2) { 656cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getNumArgs() < numElements+2) 657cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(Diag(TheCall->getLocEnd(), 658cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor diag::err_typecheck_call_too_few_args) 659cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << 0 /*function call*/ << TheCall->getSourceRange()); 6600eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocEnd(), 661cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor diag::err_typecheck_call_too_many_args) 662cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << 0 /*function call*/ << TheCall->getSourceRange()); 663cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 664d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 665d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 666d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman for (unsigned i = 2; i < TheCall->getNumArgs(); i++) { 667cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getArg(i)->isTypeDependent() || 668cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(i)->isValueDependent()) 669cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 670cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 671d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman llvm::APSInt Result(32); 672d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context)) 6730eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocStart(), 674fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_shufflevector_nonconstant_argument) 6750eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << TheCall->getArg(i)->getSourceRange()); 6760eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl 677d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner if (Result.getActiveBits() > 64 || Result.getZExtValue() >= numElements*2) 6780eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocStart(), 679fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_shufflevector_argument_too_large) 6800eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << TheCall->getArg(i)->getSourceRange()); 681d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 682d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 683d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman llvm::SmallVector<Expr*, 32> exprs; 684d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 685d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) { 686d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman exprs.push_back(TheCall->getArg(i)); 687d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman TheCall->setArg(i, 0); 688d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 689d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 690a88dc3079bedf70a5cfc39791727e43a10383006Nate Begeman return Owned(new (Context) ShuffleVectorExpr(Context, exprs.begin(), 691a88dc3079bedf70a5cfc39791727e43a10383006Nate Begeman exprs.size(), exprs[0]->getType(), 6928189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek TheCall->getCallee()->getLocStart(), 6938189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek TheCall->getRParenLoc())); 694d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 69530ce344307f8a8b00054021307015571f83c7364Chris Lattner 6964493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar/// SemaBuiltinPrefetch - Handle __builtin_prefetch. 6974493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar// This is declared to take (const void*, ...) and can take two 6984493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar// optional constant int args. 6994493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbarbool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) { 700fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner unsigned NumArgs = TheCall->getNumArgs(); 7014493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 702fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner if (NumArgs > 3) 703fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_many_args) 7042c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ << TheCall->getSourceRange(); 7054493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 7064493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // Argument 0 is checked for us and the remaining arguments must be 7074493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // constant integers. 708fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner for (unsigned i = 1; i != NumArgs; ++i) { 7094493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar Expr *Arg = TheCall->getArg(i); 710cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent()) 711cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 712cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7139aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman if (!Arg->getType()->isIntegralType()) 7149aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_arg_type) 71521fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << Arg->getSourceRange(); 716cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7179aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman ImpCastExprToType(Arg, Context.IntTy, CastExpr::CK_IntegralCast); 7189aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman TheCall->setArg(i, Arg); 7199aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman 720cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isValueDependent()) 721cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 722cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7239aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman llvm::APSInt Result; 724cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!Arg->isIntegerConstantExpr(Result, Context)) 7259aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_arg_ice) 726cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 7271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7284493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // FIXME: gcc issues a warning and rewrites these to 0. These 7294493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // seems especially odd for the third argument since the default 7304493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // is 3. 731fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner if (i == 1) { 7329aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman if (Result.getLimitedValue() > 1) 733fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 73421fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << "0" << "1" << Arg->getSourceRange(); 7354493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } else { 7369aef7263d84d9224575e113878cfbb06b8343cbfEli Friedman if (Result.getLimitedValue() > 3) 737fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 73821fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << "0" << "3" << Arg->getSourceRange(); 7394493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } 7404493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } 7414493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 742fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return false; 7434493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar} 7444493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 74521fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner/// SemaBuiltinEHReturnDataRegNo - Handle __builtin_eh_return_data_regno, the 74621fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner/// operand must be an integer constant. 74721fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattnerbool Sema::SemaBuiltinEHReturnDataRegNo(CallExpr *TheCall) { 74821fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner llvm::APSInt Result; 74921fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner if (!TheCall->getArg(0)->isIntegerConstantExpr(Result, Context)) 75021fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner return Diag(TheCall->getLocStart(), diag::err_expr_not_ice) 75121fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner << TheCall->getArg(0)->getSourceRange(); 75221fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner 75321fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner return false; 75421fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner} 75521fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner 75621fb98ee003e992b0c4e204d98a19e0ef544cae3Chris Lattner 757d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// SemaBuiltinObjectSize - Handle __builtin_object_size(void *ptr, 758d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// int type). This simply type checks that type is one of the defined 759d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// constants (0-3). 760fee667f35e64751baa7fefe70b4e7bab06c8cd86Eric Christopher// For compatability check 0-3, llvm only handles 0 and 2. 761d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbarbool Sema::SemaBuiltinObjectSize(CallExpr *TheCall) { 762d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar Expr *Arg = TheCall->getArg(1); 763cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent()) 764cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 765cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 7661eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType ArgType = Arg->getType(); 767183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const BuiltinType *BT = ArgType->getAs<BuiltinType>(); 768d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar llvm::APSInt Result(32); 769cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!BT || BT->getKind() != BuiltinType::Int) 770cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument) 771cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 772cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 773cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isValueDependent()) 774cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 775cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 776cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!Arg->isIntegerConstantExpr(Result, Context)) { 777fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument) 778fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 779d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar } 780d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 781d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar if (Result.getSExtValue() < 0 || Result.getSExtValue() > 3) { 782fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 783fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << "0" << "3" << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 784d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar } 785d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 786d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar return false; 787d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar} 788d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 789586d6a81428da2d1ce70bcb98df29d749361cbf3Eli Friedman/// SemaBuiltinLongjmp - Handle __builtin_longjmp(void *env[5], int val). 790d875fed28578835de89cd407e9db4be788596d7cEli Friedman/// This checks that val is a constant 1. 791d875fed28578835de89cd407e9db4be788596d7cEli Friedmanbool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) { 792d875fed28578835de89cd407e9db4be788596d7cEli Friedman Expr *Arg = TheCall->getArg(1); 793cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent() || Arg->isValueDependent()) 794cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 795cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 796d875fed28578835de89cd407e9db4be788596d7cEli Friedman llvm::APSInt Result(32); 797d875fed28578835de89cd407e9db4be788596d7cEli Friedman if (!Arg->isIntegerConstantExpr(Result, Context) || Result != 1) 798d875fed28578835de89cd407e9db4be788596d7cEli Friedman return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val) 799d875fed28578835de89cd407e9db4be788596d7cEli Friedman << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 800d875fed28578835de89cd407e9db4be788596d7cEli Friedman 801d875fed28578835de89cd407e9db4be788596d7cEli Friedman return false; 802d875fed28578835de89cd407e9db4be788596d7cEli Friedman} 803d875fed28578835de89cd407e9db4be788596d7cEli Friedman 804d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek// Handle i > 1 ? "x" : "y", recursivelly 805082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenekbool Sema::SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall, 806082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek bool HasVAListArg, 8073c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor unsigned format_idx, unsigned firstDataArg) { 808cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 809cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 810d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 811d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek switch (E->getStmtClass()) { 812d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ConditionalOperatorClass: { 813082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ConditionalOperator *C = cast<ConditionalOperator>(E); 814813b70d6db54dbf149cfaa14ec7502142121d86fChris Lattner return SemaCheckStringLiteral(C->getTrueExpr(), TheCall, 8153c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor HasVAListArg, format_idx, firstDataArg) 816d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek && SemaCheckStringLiteral(C->getRHS(), TheCall, 8173c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor HasVAListArg, format_idx, firstDataArg); 818d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 819d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 820d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ImplicitCastExprClass: { 821082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ImplicitCastExpr *Expr = cast<ImplicitCastExpr>(E); 822d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg, 8233c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor format_idx, firstDataArg); 824d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 825d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 826d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ParenExprClass: { 827082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ParenExpr *Expr = cast<ParenExpr>(E); 828d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg, 8293c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor format_idx, firstDataArg); 830d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 8311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 832082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::DeclRefExprClass: { 833082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const DeclRefExpr *DR = cast<DeclRefExpr>(E); 8341eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 835082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek // As an exception, do not flag errors for variables binding to 836082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek // const string literals. 837082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) { 838082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek bool isConstant = false; 839082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek QualType T = DR->getType(); 840082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 841082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const ArrayType *AT = Context.getAsArrayType(T)) { 842082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek isConstant = AT->getElementType().isConstant(Context); 843ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else if (const PointerType *PT = T->getAs<PointerType>()) { 8441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump isConstant = T.isConstant(Context) && 845082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek PT->getPointeeType().isConstant(Context); 846082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 8471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 848082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (isConstant) { 849082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const VarDecl *Def = 0; 850082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const Expr *Init = VD->getDefinition(Def)) 851082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return SemaCheckStringLiteral(Init, TheCall, 852082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek HasVAListArg, format_idx, firstDataArg); 853082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 8541eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 855d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // For vprintf* functions (i.e., HasVAListArg==true), we add a 856d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // special check to see if the format string is a function parameter 857d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // of the function calling the printf function. If the function 858d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // has an attribute indicating it is a printf-like function, then we 859d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // should suppress warnings concerning non-literals being used in a call 860d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // to a vprintf function. For example: 861d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 862d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // void 863d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // logmessage(char const *fmt __attribute__ (format (printf, 1, 2)), ...){ 864d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // va_list ap; 865d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // va_start(ap, fmt); 866d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // vprintf(fmt, ap); // Do NOT emit a warning about "fmt". 867d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // ... 868d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 869d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 870d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // FIXME: We don't have full attribute support yet, so just check to see 871d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // if the argument is a DeclRefExpr that references a parameter. We'll 872d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // add proper support for checking the attribute later. 873d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson if (HasVAListArg) 874d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson if (isa<ParmVarDecl>(VD)) 875d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson return true; 876082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 8771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 878082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return false; 879082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 880d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 8818f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson case Stmt::CallExprClass: { 8828f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson const CallExpr *CE = cast<CallExpr>(E); 8831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (const ImplicitCastExpr *ICE 8848f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson = dyn_cast<ImplicitCastExpr>(CE->getCallee())) { 8858f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) { 8868f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) { 88740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis if (const FormatArgAttr *FA = FD->getAttr<FormatArgAttr>()) { 8888f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson unsigned ArgIndex = FA->getFormatIdx(); 8898f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson const Expr *Arg = CE->getArg(ArgIndex - 1); 8901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return SemaCheckStringLiteral(Arg, TheCall, HasVAListArg, 8928f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson format_idx, firstDataArg); 8938f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8948f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8958f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8968f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8971eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8988f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson return false; 8998f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 900082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::ObjCStringLiteralClass: 901082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::StringLiteralClass: { 902082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const StringLiteral *StrE = NULL; 9031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 904082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const ObjCStringLiteral *ObjCFExpr = dyn_cast<ObjCStringLiteral>(E)) 905d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek StrE = ObjCFExpr->getString(); 906d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek else 907082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek StrE = cast<StringLiteral>(E); 9081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 909d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek if (StrE) { 9101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump CheckPrintfString(StrE, E, TheCall, HasVAListArg, format_idx, 9113c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor firstDataArg); 912d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return true; 913d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 9141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 915d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return false; 916d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 9171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 918082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek default: 919082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return false; 920d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 921d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek} 922d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 923e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanianvoid 9241eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::CheckNonNullArguments(const NonNullAttr *NonNull, 9251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump const CallExpr *TheCall) { 926e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian for (NonNullAttr::iterator i = NonNull->begin(), e = NonNull->end(); 927e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian i != e; ++i) { 92812b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner const Expr *ArgExpr = TheCall->getArg(*i); 929ce94049b69f75b44c18584fe79cd238978b6b0d5Douglas Gregor if (ArgExpr->isNullPointerConstant(Context, 930ce94049b69f75b44c18584fe79cd238978b6b0d5Douglas Gregor Expr::NPC_ValueDependentIsNotNull)) 93112b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner Diag(TheCall->getCallee()->getLocStart(), diag::warn_null_arg) 93212b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner << ArgExpr->getSourceRange(); 933e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian } 934e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian} 935d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 93659907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// CheckPrintfArguments - Check calls to printf (and similar functions) for 9371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// correct use of format strings. 93871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 93971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// HasVAListArg - A predicate indicating whether the printf-like 94071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// function is passed an explicit va_arg argument (e.g., vprintf) 94171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 94271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// format_idx - The index into Args for the format string. 94371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 94471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Improper format strings to functions in the printf family can be 94571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// the source of bizarre bugs and very serious security holes. A 94671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// good source of information is available in the following paper 94771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (which includes additional references): 94859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// 94959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// FormatGuard: Automatic Protection From printf Format String 95059907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// Vulnerabilities, Proceedings of the 10th USENIX Security Symposium, 2001. 95171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 95271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Functionality implemented: 95371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 95471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// We can statically check the following properties for string 95571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// literal format strings for non v.*printf functions (where the 95671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// arguments are passed directly): 95771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek// 95871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (1) Are the number of format conversions equal to the number of 95971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// data arguments? 96071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (2) Does each format conversion correctly match the type of the 96271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// corresponding data argument? (TODO) 96371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Moreover, for all printf functions we can: 96571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (3) Check for a missing format string (when not caught by type checking). 96771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 96871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (4) Check for no-operation flags; e.g. using "#" with format 96971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// conversion 'c' (TODO) 97071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 97171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (5) Check the use of '%n', a major source of security holes. 97271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 97371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (6) Check for malformed format conversions that don't specify anything. 97471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 97571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (7) Check for empty format strings. e.g: printf(""); 97671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 97771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (8) Check that the format string is a wide literal. 97871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 97971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// All of these checks can be done by parsing the format string. 98071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 98171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// For now, we ONLY do (1), (3), (5), (6), (7), and (8). 98259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattnervoid 9831eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpSema::CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg, 9843c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor unsigned format_idx, unsigned firstDataArg) { 985082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *Fn = TheCall->getCallee(); 986925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner 9874a2614e94672c47395abcde60518776fbebec589Sebastian Redl // The way the format attribute works in GCC, the implicit this argument 9884a2614e94672c47395abcde60518776fbebec589Sebastian Redl // of member functions is counted. However, it doesn't appear in our own 9894a2614e94672c47395abcde60518776fbebec589Sebastian Redl // lists, so decrement format_idx in that case. 9904a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (isa<CXXMemberCallExpr>(TheCall)) { 9914a2614e94672c47395abcde60518776fbebec589Sebastian Redl // Catch a format attribute mistakenly referring to the object argument. 9924a2614e94672c47395abcde60518776fbebec589Sebastian Redl if (format_idx == 0) 9934a2614e94672c47395abcde60518776fbebec589Sebastian Redl return; 9944a2614e94672c47395abcde60518776fbebec589Sebastian Redl --format_idx; 9954a2614e94672c47395abcde60518776fbebec589Sebastian Redl if(firstDataArg != 0) 9964a2614e94672c47395abcde60518776fbebec589Sebastian Redl --firstDataArg; 9974a2614e94672c47395abcde60518776fbebec589Sebastian Redl } 9984a2614e94672c47395abcde60518776fbebec589Sebastian Redl 9991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // CHECK: printf-like function is called with no format string. 1000925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (format_idx >= TheCall->getNumArgs()) { 1001dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(TheCall->getRParenLoc(), diag::warn_printf_missing_format_string) 1002dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << Fn->getSourceRange(); 100371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 100471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 10051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1006082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *OrigFormatExpr = TheCall->getArg(format_idx)->IgnoreParenCasts(); 10071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 100859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // CHECK: format string is not a string literal. 10091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // 101071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Dynamically generated format strings are difficult to 101171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // automatically vet at compile time. Requiring that format strings 101271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // are string literals: (1) permits the checking of format strings by 101371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // the compiler and thereby (2) can practically remove the source of 101471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // many format string exploits. 10157ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek 10161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // Format string can be either ObjC string (e.g. @"%d") or 10177ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // C string (e.g. "%d") 10181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // ObjC string uses the same format specifiers as C string, so we can use 10197ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // the same format string checking logic for both ObjC and C strings. 10201cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner if (SemaCheckStringLiteral(OrigFormatExpr, TheCall, HasVAListArg, format_idx, 10211cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner firstDataArg)) 10221cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner return; // Literal format string found, check done! 10231cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner 1024655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner // If there are no arguments specified, warn with -Wformat-security, otherwise 1025655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner // warn only with -Wformat-nonliteral. 1026655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner if (TheCall->getNumArgs() == format_idx+1) 10271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(format_idx)->getLocStart(), 1028655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner diag::warn_printf_nonliteral_noargs) 1029655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner << OrigFormatExpr->getSourceRange(); 1030655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner else 10311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(TheCall->getArg(format_idx)->getLocStart(), 1032655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner diag::warn_printf_nonliteral) 1033655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner << OrigFormatExpr->getSourceRange(); 1034d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek} 1035d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 1036e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremeneknamespace { 1037808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenekclass CheckPrintfHandler : public FormatStringHandler { 1038e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek Sema &S; 1039e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const StringLiteral *FExpr; 1040e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const Expr *OrigFormatExpr; 1041e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek unsigned NumConversions; 1042e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const unsigned NumDataArgs; 1043e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const bool IsObjCLiteral; 1044e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const char *Beg; // Start of format string. 10450d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const bool HasVAListArg; 10460d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const CallExpr *TheCall; 10470d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek unsigned FormatIdx; 1048e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenekpublic: 1049e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek CheckPrintfHandler(Sema &s, const StringLiteral *fexpr, 1050e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const Expr *origFormatExpr, 1051e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek unsigned numDataArgs, bool isObjCLiteral, 10520d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const char *beg, bool hasVAListArg, 10530d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const CallExpr *theCall, unsigned formatIdx) 1054e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek : S(s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), 1055e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek NumConversions(0), NumDataArgs(numDataArgs), 10560d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek IsObjCLiteral(isObjCLiteral), Beg(beg), 10570d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek HasVAListArg(hasVAListArg), 10580d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek TheCall(theCall), FormatIdx(formatIdx) {} 105907d161f38e708a91486bf1c031d525faebbb249dTed Kremenek 106007d161f38e708a91486bf1c031d525faebbb249dTed Kremenek void DoneProcessing(); 1061808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek 1062808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek void HandleIncompleteFormatSpecifier(const char *startSpecifier, 1063808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek unsigned specifierLen); 106426ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek 106526ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek void HandleInvalidConversionSpecifier(const analyze_printf::FormatSpecifier &FS, 106626ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek const char *startSpecifier, 106726ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek unsigned specifierLen); 106826ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek 1069e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek void HandleNullChar(const char *nullCharacter); 1070e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1071e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek bool HandleFormatSpecifier(const analyze_printf::FormatSpecifier &FS, 1072e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const char *startSpecifier, 1073e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek unsigned specifierLen); 1074e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenekprivate: 1075f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek SourceRange getFormatStringRange(); 1076f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek SourceRange getFormatSpecifierRange(const char *startSpecifier, 1077f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek unsigned specifierLen); 1078e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek SourceLocation getLocationOfByte(const char *x); 10790d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 10800d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek bool HandleAmount(const analyze_printf::OptionalAmount &Amt, 1081f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek unsigned MissingArgDiag, unsigned BadTypeDiag, 1082f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek const char *startSpecifier, unsigned specifierLen); 10830d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 10840d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const Expr *getDataArg(unsigned i) const; 1085e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek}; 1086e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1087e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1088f88c8e02da48afea6a04091f675af5c4facd99f1Ted KremenekSourceRange CheckPrintfHandler::getFormatStringRange() { 1089e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return OrigFormatExpr->getSourceRange(); 1090e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1091e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1092f88c8e02da48afea6a04091f675af5c4facd99f1Ted KremenekSourceRange CheckPrintfHandler:: 1093f88c8e02da48afea6a04091f675af5c4facd99f1Ted KremenekgetFormatSpecifierRange(const char *startSpecifier, unsigned specifierLen) { 1094f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek return SourceRange(getLocationOfByte(startSpecifier), 1095f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek getLocationOfByte(startSpecifier+specifierLen-1)); 1096f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek} 1097f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek 1098e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted KremenekSourceLocation CheckPrintfHandler::getLocationOfByte(const char *x) { 1099e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return S.getLocationOfStringLiteralByte(FExpr, x - Beg); 1100e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1101e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 110226ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenekvoid CheckPrintfHandler:: 1103808015a18bd97781ce437831a95a92fdfc8d5136Ted KremenekHandleIncompleteFormatSpecifier(const char *startSpecifier, 1104808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek unsigned specifierLen) { 1105808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek SourceLocation Loc = getLocationOfByte(startSpecifier); 1106808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek S.Diag(Loc, diag::warn_printf_incomplete_specifier) 1107f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << getFormatSpecifierRange(startSpecifier, specifierLen); 1108808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek} 1109808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek 1110808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenekvoid CheckPrintfHandler:: 111126ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted KremenekHandleInvalidConversionSpecifier(const analyze_printf::FormatSpecifier &FS, 111226ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek const char *startSpecifier, 111326ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek unsigned specifierLen) { 111426ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek 111526ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek ++NumConversions; 1116808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek const analyze_printf::ConversionSpecifier &CS = 1117808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek FS.getConversionSpecifier(); 1118808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek SourceLocation Loc = getLocationOfByte(CS.getStart()); 111926ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek S.Diag(Loc, diag::warn_printf_invalid_conversion) 1120808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek << llvm::StringRef(CS.getStart(), CS.getLength()) 1121f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << getFormatSpecifierRange(startSpecifier, specifierLen); 112226ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek} 112326ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek 1124e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenekvoid CheckPrintfHandler::HandleNullChar(const char *nullCharacter) { 1125e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // The presence of a null character is likely an error. 1126e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek S.Diag(getLocationOfByte(nullCharacter), 1127e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek diag::warn_printf_format_string_contains_null_char) 1128f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << getFormatStringRange(); 1129e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1130e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 11310d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenekconst Expr *CheckPrintfHandler::getDataArg(unsigned i) const { 11320d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return TheCall->getArg(FormatIdx + i); 11330d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek} 11340d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 11350d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenekbool 11360d27735c51f5bd392e673cf39a675e14e9442387Ted KremenekCheckPrintfHandler::HandleAmount(const analyze_printf::OptionalAmount &Amt, 11370d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek unsigned MissingArgDiag, 1138f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek unsigned BadTypeDiag, 1139f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek const char *startSpecifier, 1140f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek unsigned specifierLen) { 11410d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 11420d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek if (Amt.hasDataArgument()) { 11430d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek ++NumConversions; 11440d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek if (!HasVAListArg) { 11450d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek if (NumConversions > NumDataArgs) { 11460d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek S.Diag(getLocationOfByte(Amt.getStart()), MissingArgDiag) 1147f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << getFormatSpecifierRange(startSpecifier, specifierLen); 11480d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // Don't do any more checking. We will just emit 11490d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // spurious errors. 11500d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return false; 11510d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 11520d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 11530d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // Type check the data argument. It should be an 'int'. 115431f8e32788adb299acad455363eb7fd244642c82Ted Kremenek // Although not in conformance with C99, we also allow the argument to be 115531f8e32788adb299acad455363eb7fd244642c82Ted Kremenek // an 'unsigned int' as that is a reasonably safe case. GCC also 115631f8e32788adb299acad455363eb7fd244642c82Ted Kremenek // doesn't emit a warning for that case. 11570d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek const Expr *Arg = getDataArg(NumConversions); 11580d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek QualType T = Arg->getType(); 115931f8e32788adb299acad455363eb7fd244642c82Ted Kremenek const BuiltinType *BT = T->getAs<BuiltinType>(); 116031f8e32788adb299acad455363eb7fd244642c82Ted Kremenek if (!BT || (BT->getKind() != BuiltinType::Int && 116131f8e32788adb299acad455363eb7fd244642c82Ted Kremenek BT->getKind() != BuiltinType::UInt)) { 11620d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek S.Diag(getLocationOfByte(Amt.getStart()), BadTypeDiag) 1163f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << T 1164f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << getFormatSpecifierRange(startSpecifier, specifierLen) 1165f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << Arg->getSourceRange(); 11660d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // Don't do any more checking. We will just emit 11670d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // spurious errors. 11680d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return false; 11690d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 11700d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 11710d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 11720d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return true; 11730d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek} 11740d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 1175e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenekbool 1176e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted KremenekCheckPrintfHandler::HandleFormatSpecifier(const analyze_printf::FormatSpecifier &FS, 1177e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const char *startSpecifier, 1178e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek unsigned specifierLen) { 1179e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1180e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek using namespace analyze_printf; 1181e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const ConversionSpecifier &CS = FS.getConversionSpecifier(); 1182e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 11830d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // First check if the field width, precision, and conversion specifier 11840d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek // have matching data arguments. 11850d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek if (!HandleAmount(FS.getFieldWidth(), 11860d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek diag::warn_printf_asterisk_width_missing_arg, 1187f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek diag::warn_printf_asterisk_width_wrong_type, 1188f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek startSpecifier, specifierLen)) { 11890d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return false; 11900d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 11910d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 11920d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek if (!HandleAmount(FS.getPrecision(), 11930d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek diag::warn_printf_asterisk_precision_missing_arg, 1194f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek diag::warn_printf_asterisk_precision_wrong_type, 1195f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek startSpecifier, specifierLen)) { 11960d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek return false; 11970d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek } 11980d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek 1199e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // Check for using an Objective-C specific conversion specifier 1200e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // in a non-ObjC literal. 1201e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek if (!IsObjCLiteral && CS.isObjCArg()) { 120226ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek HandleInvalidConversionSpecifier(FS, startSpecifier, specifierLen); 1203e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1204e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // Continue checking the other format specifiers. 1205e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return true; 1206e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek } 1207f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek 1208f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek if (!CS.consumesDataArgument()) { 1209f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek // FIXME: Technically specifying a precision or field width here 1210f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek // makes no sense. Worth issuing a warning at some point. 1211f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek return true; 1212f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek } 1213e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek 121426ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek ++NumConversions; 121526ac2e07b46bfb4d4f00752c96481c0a98c79c69Ted Kremenek 1216e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek // Are we using '%n'? Issue a warning about this being 1217e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek // a possible security issue. 1218e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek if (CS.getKind() == ConversionSpecifier::OutIntPtrArg) { 1219e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek S.Diag(getLocationOfByte(CS.getStart()), diag::warn_printf_write_back) 1220f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << getFormatSpecifierRange(startSpecifier, specifierLen); 1221e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek // Continue checking the other format specifiers. 1222e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek return true; 1223e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek } 1224e82d804ee761006250543d6fe6e98ee7896cd756Ted Kremenek 1225da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek 1226da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek // The remaining checks depend on the data arguments. 1227da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek if (HasVAListArg) 1228da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek return true; 1229da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek 1230da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek if (NumConversions > NumDataArgs) { 1231da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek S.Diag(getLocationOfByte(CS.getStart()), 1232da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek diag::warn_printf_insufficient_data_args) 1233f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << getFormatSpecifierRange(startSpecifier, specifierLen); 1234da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek // Don't do any more checking. 1235da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek return false; 1236da51f0d136df131a0137c0ec1069fb586d8a296aTed Kremenek } 1237e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1238e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return true; 1239e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek} 1240e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 124107d161f38e708a91486bf1c031d525faebbb249dTed Kremenekvoid CheckPrintfHandler::DoneProcessing() { 124207d161f38e708a91486bf1c031d525faebbb249dTed Kremenek // Does the number of data arguments exceed the number of 124307d161f38e708a91486bf1c031d525faebbb249dTed Kremenek // format conversions in the format string? 124407d161f38e708a91486bf1c031d525faebbb249dTed Kremenek if (!HasVAListArg && NumConversions < NumDataArgs) 124507d161f38e708a91486bf1c031d525faebbb249dTed Kremenek S.Diag(getDataArg(NumConversions+1)->getLocStart(), 124607d161f38e708a91486bf1c031d525faebbb249dTed Kremenek diag::warn_printf_too_many_data_args) 1247f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek << getFormatStringRange(); 124807d161f38e708a91486bf1c031d525faebbb249dTed Kremenek} 1249e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1250f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenekvoid Sema::CheckPrintfString(const StringLiteral *FExpr, 1251f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek const Expr *OrigFormatExpr, 1252f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek const CallExpr *TheCall, bool HasVAListArg, 1253f88c8e02da48afea6a04091f675af5c4facd99f1Ted Kremenek unsigned format_idx, unsigned firstDataArg) { 1254ce7024e8a3793b05861a4904ecdb1272924ada14Ted Kremenek 1255e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // CHECK: is the format string a wide literal? 1256e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek if (FExpr->isWide()) { 1257e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek Diag(FExpr->getLocStart(), 1258e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek diag::warn_printf_format_string_is_wide_literal) 1259e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek << OrigFormatExpr->getSourceRange(); 1260e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return; 1261e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek } 1262e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1263e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // Str - The format string. NOTE: this is NOT null-terminated! 1264e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek const char *Str = FExpr->getStrData(); 1265ce7024e8a3793b05861a4904ecdb1272924ada14Ted Kremenek 1266e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek // CHECK: empty format string? 1267e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek unsigned StrLen = FExpr->getByteLength(); 1268e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1269e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek if (StrLen == 0) { 1270e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek Diag(FExpr->getLocStart(), diag::warn_printf_empty_format_string) 1271e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek << OrigFormatExpr->getSourceRange(); 1272e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek return; 1273e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek } 1274e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1275e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek CheckPrintfHandler H(*this, FExpr, OrigFormatExpr, 1276e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek TheCall->getNumArgs() - firstDataArg, 12770d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek isa<ObjCStringLiteral>(OrigFormatExpr), Str, 12780d27735c51f5bd392e673cf39a675e14e9442387Ted Kremenek HasVAListArg, TheCall, format_idx); 1279e0e5313c25f3870d0d18fc67e1b3a3a0e1ef8e07Ted Kremenek 1280808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek if (!ParseFormatString(H, Str, Str + StrLen)) 1281808015a18bd97781ce437831a95a92fdfc8d5136Ted Kremenek H.DoneProcessing(); 1282ce7024e8a3793b05861a4904ecdb1272924ada14Ted Kremenek} 1283ce7024e8a3793b05861a4904ecdb1272924ada14Ted Kremenek 128406de276fff91264437fa75111ed76de43097e089Ted Kremenek//===--- CHECK: Return Address of Stack Variable --------------------------===// 128506de276fff91264437fa75111ed76de43097e089Ted Kremenek 128606de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalVal(Expr *E); 128706de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalAddr(Expr* E); 128806de276fff91264437fa75111ed76de43097e089Ted Kremenek 128906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// CheckReturnStackAddr - Check if a return statement returns the address 129006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// of a stack variable. 129106de276fff91264437fa75111ed76de43097e089Ted Kremenekvoid 129206de276fff91264437fa75111ed76de43097e089Ted KremenekSema::CheckReturnStackAddr(Expr *RetValExp, QualType lhsType, 129306de276fff91264437fa75111ed76de43097e089Ted Kremenek SourceLocation ReturnLoc) { 12941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 129506de276fff91264437fa75111ed76de43097e089Ted Kremenek // Perform checking for returned stack addresses. 1296dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (lhsType->isPointerType() || lhsType->isBlockPointerType()) { 129706de276fff91264437fa75111ed76de43097e089Ted Kremenek if (DeclRefExpr *DR = EvalAddr(RetValExp)) 12983c73c41cefcfe76f36b7bed72c9f1ec195490951Chris Lattner Diag(DR->getLocStart(), diag::warn_ret_stack_addr) 129908631c5fa053867146b5ee8be658c229f6bf127cChris Lattner << DR->getDecl()->getDeclName() << RetValExp->getSourceRange(); 13001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1301c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff // Skip over implicit cast expressions when checking for block expressions. 13024ca606e898293ae58f1793f988500e2218c7a9beChris Lattner RetValExp = RetValExp->IgnoreParenCasts(); 1303c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff 13049e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner if (BlockExpr *C = dyn_cast<BlockExpr>(RetValExp)) 1305397195bf3077fb42789b326f69f7d417227a0588Mike Stump if (C->hasBlockDeclRefExprs()) 1306397195bf3077fb42789b326f69f7d417227a0588Mike Stump Diag(C->getLocStart(), diag::err_ret_local_block) 1307397195bf3077fb42789b326f69f7d417227a0588Mike Stump << C->getSourceRange(); 13089e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner 13099e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner if (AddrLabelExpr *ALE = dyn_cast<AddrLabelExpr>(RetValExp)) 13109e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner Diag(ALE->getLocStart(), diag::warn_ret_addr_label) 13119e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner << ALE->getSourceRange(); 13129e6b37a9f1d499e7ca0950edacd0b6569e491d7fChris Lattner 1313ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else if (lhsType->isReferenceType()) { 1314ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump // Perform checking for stack values returned by reference. 131549badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // Check for a reference to the stack 131649badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor if (DeclRefExpr *DR = EvalVal(RetValExp)) 1317dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(DR->getLocStart(), diag::warn_ret_stack_ref) 131808631c5fa053867146b5ee8be658c229f6bf127cChris Lattner << DR->getDecl()->getDeclName() << RetValExp->getSourceRange(); 131906de276fff91264437fa75111ed76de43097e089Ted Kremenek } 132006de276fff91264437fa75111ed76de43097e089Ted Kremenek} 132106de276fff91264437fa75111ed76de43097e089Ted Kremenek 132206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// EvalAddr - EvalAddr and EvalVal are mutually recursive functions that 132306de276fff91264437fa75111ed76de43097e089Ted Kremenek/// check if the expression in a return statement evaluates to an address 132406de276fff91264437fa75111ed76de43097e089Ted Kremenek/// to a location on the stack. The recursion is used to traverse the 132506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// AST of the return expression, with recursion backtracking when we 132606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// encounter a subexpression that (1) clearly does not lead to the address 132706de276fff91264437fa75111ed76de43097e089Ted Kremenek/// of a stack variable or (2) is something we cannot determine leads to 132806de276fff91264437fa75111ed76de43097e089Ted Kremenek/// the address of a stack variable based on such local checking. 132906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 1330e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek/// EvalAddr processes expressions that are pointers that are used as 1331e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek/// references (and not L-values). EvalVal handles all other values. 13321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// At the base case of the recursion is a check for a DeclRefExpr* in 133306de276fff91264437fa75111ed76de43097e089Ted Kremenek/// the refers to a stack variable. 133406de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 133506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// This implementation handles: 133606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 133706de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * pointer-to-pointer casts 133806de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * implicit conversions from array references to pointers 133906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * taking the address of fields 134006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * arbitrary interplay between "&" and "*" operators 134106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * pointer arithmetic from an address of a stack variable 134206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * taking the address of an array element where the array is on the stack 134306de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalAddr(Expr *E) { 134406de276fff91264437fa75111ed76de43097e089Ted Kremenek // We should only be called for evaluating pointer expressions. 13450f436560640a1cff5b6d96f80f540770f139453fDavid Chisnall assert((E->getType()->isAnyPointerType() || 1346dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff E->getType()->isBlockPointerType() || 1347a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek E->getType()->isObjCQualifiedIdType()) && 1348fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner "EvalAddr only works on pointers"); 13491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 135006de276fff91264437fa75111ed76de43097e089Ted Kremenek // Our "symbolic interpreter" is just a dispatch off the currently 135106de276fff91264437fa75111ed76de43097e089Ted Kremenek // viewed AST node. We then recursively traverse the AST by calling 135206de276fff91264437fa75111ed76de43097e089Ted Kremenek // EvalAddr and EvalVal appropriately. 135306de276fff91264437fa75111ed76de43097e089Ted Kremenek switch (E->getStmtClass()) { 1354fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::ParenExprClass: 1355fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Ignore parentheses. 1356fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(cast<ParenExpr>(E)->getSubExpr()); 135706de276fff91264437fa75111ed76de43097e089Ted Kremenek 1358fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::UnaryOperatorClass: { 1359fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // The only unary operator that make sense to handle here 1360fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // is AddrOf. All others don't make sense as pointers. 1361fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner UnaryOperator *U = cast<UnaryOperator>(E); 13621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1363fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (U->getOpcode() == UnaryOperator::AddrOf) 1364fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalVal(U->getSubExpr()); 1365fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else 1366fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 1367fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 13681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1369fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::BinaryOperatorClass: { 1370fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle pointer arithmetic. All other binary operators are not valid 1371fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // in this context. 1372fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner BinaryOperator *B = cast<BinaryOperator>(E); 1373fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner BinaryOperator::Opcode op = B->getOpcode(); 13741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1375fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (op != BinaryOperator::Add && op != BinaryOperator::Sub) 1376fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 13771eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1378fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner Expr *Base = B->getLHS(); 13793907323dd6665c0c4e383435cb145233f4533406Anders Carlsson 1380fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Determine which argument is the real pointer base. It could be 1381fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // the RHS argument instead of the LHS. 1382fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (!Base->getType()->isPointerType()) Base = B->getRHS(); 13831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1384fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner assert (Base->getType()->isPointerType()); 1385fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(Base); 1386fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 138761f40a2b67fc2046768e14f66b617e564cbcc3d8Steve Naroff 1388fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // For conditional operators we need to see if either the LHS or RHS are 1389fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // valid DeclRefExpr*s. If one of them is valid, we return it. 1390fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::ConditionalOperatorClass: { 1391fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ConditionalOperator *C = cast<ConditionalOperator>(E); 13921eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1393fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle the GNU extension for missing LHS. 1394fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (Expr *lhsExpr = C->getLHS()) 1395fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (DeclRefExpr* LHS = EvalAddr(lhsExpr)) 1396fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return LHS; 139706de276fff91264437fa75111ed76de43097e089Ted Kremenek 1398fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(C->getRHS()); 1399fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 14001eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 140154b5274f2c190331438375ad114dad12ae098b57Ted Kremenek // For casts, we need to handle conversions from arrays to 140254b5274f2c190331438375ad114dad12ae098b57Ted Kremenek // pointer values, and pointer-to-pointer conversions. 140349badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::ImplicitCastExprClass: 14046eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case Stmt::CStyleCastExprClass: 140549badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXFunctionalCastExprClass: { 14060835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis Expr* SubExpr = cast<CastExpr>(E)->getSubExpr(); 140754b5274f2c190331438375ad114dad12ae098b57Ted Kremenek QualType T = SubExpr->getType(); 14081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1409dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (SubExpr->getType()->isPointerType() || 1410dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff SubExpr->getType()->isBlockPointerType() || 1411dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff SubExpr->getType()->isObjCQualifiedIdType()) 1412fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(SubExpr); 141354b5274f2c190331438375ad114dad12ae098b57Ted Kremenek else if (T->isArrayType()) 141454b5274f2c190331438375ad114dad12ae098b57Ted Kremenek return EvalVal(SubExpr); 1415fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else 141654b5274f2c190331438375ad114dad12ae098b57Ted Kremenek return 0; 1417fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 14181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1419fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // C++ casts. For dynamic casts, static casts, and const casts, we 1420fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // are always converting from a pointer-to-pointer, so we just blow 142149badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // through the cast. In the case the dynamic cast doesn't fail (and 142249badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // return NULL), we take the conservative route and report cases 1423fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // where we return the address of a stack variable. For Reinterpre 142449badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // FIXME: The comment about is wrong; we're not always converting 142549badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // from pointer to pointer. I'm guessing that this code should also 14261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // handle references to objects. 14271eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case Stmt::CXXStaticCastExprClass: 14281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump case Stmt::CXXDynamicCastExprClass: 142949badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXConstCastExprClass: 143049badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXReinterpretCastExprClass: { 143149badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor Expr *S = cast<CXXNamedCastExpr>(E)->getSubExpr(); 1432dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (S->getType()->isPointerType() || S->getType()->isBlockPointerType()) 1433fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(S); 143406de276fff91264437fa75111ed76de43097e089Ted Kremenek else 143506de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 1436fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 14371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1438fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Everything else: we simply don't reason about them. 1439fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner default: 1440fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 144106de276fff91264437fa75111ed76de43097e089Ted Kremenek } 144206de276fff91264437fa75111ed76de43097e089Ted Kremenek} 14431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 144406de276fff91264437fa75111ed76de43097e089Ted Kremenek 144506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// EvalVal - This function is complements EvalAddr in the mutual recursion. 144606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// See the comments for EvalAddr for more details. 144706de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalVal(Expr *E) { 14481eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1449e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // We should only be called for evaluating non-pointer expressions, or 1450e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // expressions with a pointer type that are not used as references but instead 1451e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // are l-values (e.g., DeclRefExpr with a pointer type). 14521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 145306de276fff91264437fa75111ed76de43097e089Ted Kremenek // Our "symbolic interpreter" is just a dispatch off the currently 145406de276fff91264437fa75111ed76de43097e089Ted Kremenek // viewed AST node. We then recursively traverse the AST by calling 145506de276fff91264437fa75111ed76de43097e089Ted Kremenek // EvalAddr and EvalVal appropriately. 145606de276fff91264437fa75111ed76de43097e089Ted Kremenek switch (E->getStmtClass()) { 1457a2813cec2605ce7878d1b13471d685f689b251afDouglas Gregor case Stmt::DeclRefExprClass: { 145806de276fff91264437fa75111ed76de43097e089Ted Kremenek // DeclRefExpr: the base case. When we hit a DeclRefExpr we are looking 145906de276fff91264437fa75111ed76de43097e089Ted Kremenek // at code that refers to a variable's name. We check if it has local 146006de276fff91264437fa75111ed76de43097e089Ted Kremenek // storage within the function, and if so, return the expression. 146106de276fff91264437fa75111ed76de43097e089Ted Kremenek DeclRefExpr *DR = cast<DeclRefExpr>(E); 14621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 146306de276fff91264437fa75111ed76de43097e089Ted Kremenek if (VarDecl *V = dyn_cast<VarDecl>(DR->getDecl())) 14641eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (V->hasLocalStorage() && !V->getType()->isReferenceType()) return DR; 14651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 146606de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 146706de276fff91264437fa75111ed76de43097e089Ted Kremenek } 14681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 146906de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ParenExprClass: 147006de276fff91264437fa75111ed76de43097e089Ted Kremenek // Ignore parentheses. 147106de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalVal(cast<ParenExpr>(E)->getSubExpr()); 14721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 147306de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::UnaryOperatorClass: { 147406de276fff91264437fa75111ed76de43097e089Ted Kremenek // The only unary operator that make sense to handle here 147506de276fff91264437fa75111ed76de43097e089Ted Kremenek // is Deref. All others don't resolve to a "name." This includes 147606de276fff91264437fa75111ed76de43097e089Ted Kremenek // handling all sorts of rvalues passed to a unary operator. 147706de276fff91264437fa75111ed76de43097e089Ted Kremenek UnaryOperator *U = cast<UnaryOperator>(E); 14781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 147906de276fff91264437fa75111ed76de43097e089Ted Kremenek if (U->getOpcode() == UnaryOperator::Deref) 148006de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalAddr(U->getSubExpr()); 148106de276fff91264437fa75111ed76de43097e089Ted Kremenek 148206de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 148306de276fff91264437fa75111ed76de43097e089Ted Kremenek } 14841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 148506de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ArraySubscriptExprClass: { 148606de276fff91264437fa75111ed76de43097e089Ted Kremenek // Array subscripts are potential references to data on the stack. We 148706de276fff91264437fa75111ed76de43097e089Ted Kremenek // retrieve the DeclRefExpr* for the array variable if it indeed 148806de276fff91264437fa75111ed76de43097e089Ted Kremenek // has local storage. 14892324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek return EvalAddr(cast<ArraySubscriptExpr>(E)->getBase()); 149006de276fff91264437fa75111ed76de43097e089Ted Kremenek } 14911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 149206de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ConditionalOperatorClass: { 149306de276fff91264437fa75111ed76de43097e089Ted Kremenek // For conditional operators we need to see if either the LHS or RHS are 149406de276fff91264437fa75111ed76de43097e089Ted Kremenek // non-NULL DeclRefExpr's. If one is non-NULL, we return it. 149506de276fff91264437fa75111ed76de43097e089Ted Kremenek ConditionalOperator *C = cast<ConditionalOperator>(E); 149606de276fff91264437fa75111ed76de43097e089Ted Kremenek 14973907323dd6665c0c4e383435cb145233f4533406Anders Carlsson // Handle the GNU extension for missing LHS. 14983907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (Expr *lhsExpr = C->getLHS()) 14993907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (DeclRefExpr *LHS = EvalVal(lhsExpr)) 15003907323dd6665c0c4e383435cb145233f4533406Anders Carlsson return LHS; 15013907323dd6665c0c4e383435cb145233f4533406Anders Carlsson 15023907323dd6665c0c4e383435cb145233f4533406Anders Carlsson return EvalVal(C->getRHS()); 150306de276fff91264437fa75111ed76de43097e089Ted Kremenek } 15041eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 150506de276fff91264437fa75111ed76de43097e089Ted Kremenek // Accesses to members are potential references to data on the stack. 150683f6faf37d9bf58986bedc9bc0ea897a56b4dbadDouglas Gregor case Stmt::MemberExprClass: { 150706de276fff91264437fa75111ed76de43097e089Ted Kremenek MemberExpr *M = cast<MemberExpr>(E); 15081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 150906de276fff91264437fa75111ed76de43097e089Ted Kremenek // Check for indirect access. We only want direct field accesses. 151006de276fff91264437fa75111ed76de43097e089Ted Kremenek if (!M->isArrow()) 151106de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalVal(M->getBase()); 151206de276fff91264437fa75111ed76de43097e089Ted Kremenek else 151306de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 151406de276fff91264437fa75111ed76de43097e089Ted Kremenek } 15151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 151606de276fff91264437fa75111ed76de43097e089Ted Kremenek // Everything else: we simply don't reason about them. 151706de276fff91264437fa75111ed76de43097e089Ted Kremenek default: 151806de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 151906de276fff91264437fa75111ed76de43097e089Ted Kremenek } 152006de276fff91264437fa75111ed76de43097e089Ted Kremenek} 1521588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1522588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek//===--- CHECK: Floating-Point comparisons (-Wfloat-equal) ---------------===// 1523588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1524588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// Check for comparisons of floating point operands using != and ==. 1525588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// Issue a warning if these are no self-comparisons, as they are not likely 1526588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// to do what the programmer intended. 1527588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenekvoid Sema::CheckFloatComparison(SourceLocation loc, Expr* lex, Expr *rex) { 1528588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek bool EmitWarning = true; 15291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15304e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* LeftExprSansParen = lex->IgnoreParens(); 153132e97b66bbce16c9e81c877794fb7a0aeeb66ccbTed Kremenek Expr* RightExprSansParen = rex->IgnoreParens(); 1532588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1533588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Special case: check for x == x (which is OK). 1534588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Do not emit warnings for such cases. 1535588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen)) 1536588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RightExprSansParen)) 1537588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DRL->getDecl() == DRR->getDecl()) 1538588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 15391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15411b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // Special case: check for comparisons against literals that can be exactly 15421b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // represented by APFloat. In such cases, do not emit a warning. This 15431b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // is a heuristic: often comparison against such literals are used to 15441b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // detect if a value in a variable has not changed. This clearly can 15451b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // lead to false negatives. 15461b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (EmitWarning) { 15471b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) { 15481b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FLL->isExact()) 15491b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek EmitWarning = false; 1550ac5fc7c6bcb494b60fee7ce615ac931c5db6135eMike Stump } else 15511b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen)){ 15521b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FLR->isExact()) 15531b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek EmitWarning = false; 15541b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 15551b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 15561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1557588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Check for comparisons with builtin types. 15580eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (EmitWarning) 1559588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen)) 15603c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CL->isBuiltinCall(Context)) 1561588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 15621eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 15630eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (EmitWarning) 1564588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen)) 15653c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CR->isBuiltinCall(Context)) 1566588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 15671eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1568588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Emit the diagnostic. 1569588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (EmitWarning) 1570fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner Diag(loc, diag::warn_floatingpoint_eq) 1571fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << lex->getSourceRange() << rex->getSourceRange(); 1572588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek} 1573ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1574f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall//===--- CHECK: Integer mixed-sign comparisons (-Wsign-compare) --------===// 1575f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall//===--- CHECK: Lossy implicit conversions (-Wconversion) --------------===// 1576ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1577f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallnamespace { 1578ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1579f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Structure recording the 'active' range of an integer-valued 1580f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// expression. 1581f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallstruct IntRange { 1582f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall /// The number of bits active in the int. 1583f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned Width; 1584ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1585f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall /// True if the int is known not to have negative values. 1586f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool NonNegative; 158751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1588f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange() {} 1589f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange(unsigned Width, bool NonNegative) 1590f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall : Width(Width), NonNegative(NonNegative) 1591f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall {} 159251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1593f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Returns the range of the bool type. 1594f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange forBoolType() { 1595f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(1, true); 1596f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 159751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1598f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Returns the range of an integral type. 1599f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange forType(ASTContext &C, QualType T) { 1600f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return forCanonicalType(C, T->getCanonicalTypeInternal().getTypePtr()); 160151313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 160251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1603f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Returns the range of an integeral type based on its canonical 1604f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // representation. 1605f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange forCanonicalType(ASTContext &C, const Type *T) { 1606f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(T->isCanonicalUnqualified()); 160751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1608f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (const VectorType *VT = dyn_cast<VectorType>(T)) 1609f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall T = VT->getElementType().getTypePtr(); 1610f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (const ComplexType *CT = dyn_cast<ComplexType>(T)) 1611f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall T = CT->getElementType().getTypePtr(); 1612f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (const EnumType *ET = dyn_cast<EnumType>(T)) 1613f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall T = ET->getDecl()->getIntegerType().getTypePtr(); 161451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1615f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const BuiltinType *BT = cast<BuiltinType>(T); 1616f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(BT->isInteger()); 161751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1618f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger()); 161951313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 162051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1621f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Returns the supremum of two ranges: i.e. their conservative merge. 1622f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall static IntRange join(const IntRange &L, const IntRange &R) { 1623f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(std::max(L.Width, R.Width), 162460fad45739b764886f707bd204eae9ecce6db1f2John McCall L.NonNegative && R.NonNegative); 162560fad45739b764886f707bd204eae9ecce6db1f2John McCall } 162660fad45739b764886f707bd204eae9ecce6db1f2John McCall 162760fad45739b764886f707bd204eae9ecce6db1f2John McCall // Returns the infinum of two ranges: i.e. their aggressive merge. 162860fad45739b764886f707bd204eae9ecce6db1f2John McCall static IntRange meet(const IntRange &L, const IntRange &R) { 162960fad45739b764886f707bd204eae9ecce6db1f2John McCall return IntRange(std::min(L.Width, R.Width), 163060fad45739b764886f707bd204eae9ecce6db1f2John McCall L.NonNegative || R.NonNegative); 163151313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 1632f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall}; 163351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1634f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallIntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth) { 1635f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isSigned() && value.isNegative()) 1636f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(value.getMinSignedBits(), false); 163751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1638f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.getBitWidth() > MaxWidth) 1639f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall value.trunc(MaxWidth); 164051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1641f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // isNonNegative() just checks the sign bit without considering 1642f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // signedness. 1643f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(value.getActiveBits(), true); 164451313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 164551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 16460acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCallIntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty, 1647f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned MaxWidth) { 1648f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isInt()) 1649f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetValueRange(C, result.getInt(), MaxWidth); 165051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1651f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isVector()) { 16520acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall IntRange R = GetValueRange(C, result.getVectorElt(0), Ty, MaxWidth); 16530acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall for (unsigned i = 1, e = result.getVectorLength(); i != e; ++i) { 16540acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall IntRange El = GetValueRange(C, result.getVectorElt(i), Ty, MaxWidth); 16550acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall R = IntRange::join(R, El); 16560acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall } 1657f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return R; 165851313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 165951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1660f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (result.isComplexInt()) { 1661f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth); 1662f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth); 1663f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(R, I); 1664f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1665f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1666f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // This can happen with lossless casts to intptr_t of "based" lvalues. 1667f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Assume it might use arbitrary bits. 16680acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall // FIXME: The only reason we need to pass the type in here is to get 16690acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall // the sign right on this one case. It would be nice if APValue 16700acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall // preserved this. 1671f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(result.isLValue()); 16720acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall return IntRange(MaxWidth, Ty->isUnsignedIntegerType()); 167351313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 167451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1675f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Pseudo-evaluate the given integer expression, estimating the 1676f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// range of values it might take. 1677f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// 1678f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// \param MaxWidth - the width to which the value will be truncated 1679f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallIntRange GetExprRange(ASTContext &C, Expr *E, unsigned MaxWidth) { 168051313c39c84407dd6a323be99a8c322bf8d052a9John McCall E = E->IgnoreParens(); 168151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1682f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Try a full evaluation first. 1683f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall Expr::EvalResult result; 1684f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (E->Evaluate(result, C)) 16850acc311bf73c85fd34ce6f89a4e786b7ecd214aaJohn McCall return GetValueRange(C, result.Val, E->getType(), MaxWidth); 168651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1687f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // I think we only want to look through implicit casts here; if the 1688f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // user has an explicit widening cast, we should treat the value as 1689f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // being of the new, wider type. 1690f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) { 1691f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (CE->getCastKind() == CastExpr::CK_NoOp) 1692f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, CE->getSubExpr(), MaxWidth); 169351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1694f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange OutputTypeRange = IntRange::forType(C, CE->getType()); 169551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 169660fad45739b764886f707bd204eae9ecce6db1f2John McCall bool isIntegerCast = (CE->getCastKind() == CastExpr::CK_IntegralCast); 169760fad45739b764886f707bd204eae9ecce6db1f2John McCall if (!isIntegerCast && CE->getCastKind() == CastExpr::CK_Unknown) 169860fad45739b764886f707bd204eae9ecce6db1f2John McCall isIntegerCast = CE->getSubExpr()->getType()->isIntegerType(); 169960fad45739b764886f707bd204eae9ecce6db1f2John McCall 1700f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Assume that non-integer casts can span the full range of the type. 170160fad45739b764886f707bd204eae9ecce6db1f2John McCall if (!isIntegerCast) 1702f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return OutputTypeRange; 170351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1704f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange SubRange 1705f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall = GetExprRange(C, CE->getSubExpr(), 1706f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall std::min(MaxWidth, OutputTypeRange.Width)); 170751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1708f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Bail out if the subexpr's range is as wide as the cast type. 1709f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SubRange.Width >= OutputTypeRange.Width) 1710f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return OutputTypeRange; 171151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1712f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Otherwise, we take the smaller width, and we're non-negative if 1713f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // either the output type or the subexpr is. 1714f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(SubRange.Width, 1715f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall SubRange.NonNegative || OutputTypeRange.NonNegative); 1716f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1717f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1718f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) { 1719f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // If we can fold the condition, just take that operand. 1720f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool CondResult; 1721f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (CO->getCond()->EvaluateAsBooleanCondition(CondResult, C)) 1722f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, CondResult ? CO->getTrueExpr() 1723f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall : CO->getFalseExpr(), 1724f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall MaxWidth); 1725f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1726f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Otherwise, conservatively merge. 1727f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange L = GetExprRange(C, CO->getTrueExpr(), MaxWidth); 1728f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetExprRange(C, CO->getFalseExpr(), MaxWidth); 1729f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(L, R); 173051313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 173151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 173251313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 173351313c39c84407dd6a323be99a8c322bf8d052a9John McCall switch (BO->getOpcode()) { 173451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1735f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Boolean-valued operations are single-bit and positive. 173651313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::LAnd: 173751313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::LOr: 173851313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::LT: 173951313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::GT: 174051313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::LE: 174151313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::GE: 174251313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::EQ: 174351313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::NE: 1744f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forBoolType(); 174551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 174651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Operations with opaque sources are black-listed. 174751313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::PtrMemD: 174851313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::PtrMemI: 1749f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 175051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 175160fad45739b764886f707bd204eae9ecce6db1f2John McCall // Bitwise-and uses the *infinum* of the two source ranges. 175260fad45739b764886f707bd204eae9ecce6db1f2John McCall case BinaryOperator::And: 175360fad45739b764886f707bd204eae9ecce6db1f2John McCall return IntRange::meet(GetExprRange(C, BO->getLHS(), MaxWidth), 175460fad45739b764886f707bd204eae9ecce6db1f2John McCall GetExprRange(C, BO->getRHS(), MaxWidth)); 175560fad45739b764886f707bd204eae9ecce6db1f2John McCall 175651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Left shift gets black-listed based on a judgement call. 175751313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::Shl: 1758f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 175951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 176060fad45739b764886f707bd204eae9ecce6db1f2John McCall // Right shift by a constant can narrow its left argument. 176160fad45739b764886f707bd204eae9ecce6db1f2John McCall case BinaryOperator::Shr: { 176260fad45739b764886f707bd204eae9ecce6db1f2John McCall IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth); 176360fad45739b764886f707bd204eae9ecce6db1f2John McCall 176460fad45739b764886f707bd204eae9ecce6db1f2John McCall // If the shift amount is a positive constant, drop the width by 176560fad45739b764886f707bd204eae9ecce6db1f2John McCall // that much. 176660fad45739b764886f707bd204eae9ecce6db1f2John McCall llvm::APSInt shift; 176760fad45739b764886f707bd204eae9ecce6db1f2John McCall if (BO->getRHS()->isIntegerConstantExpr(shift, C) && 176860fad45739b764886f707bd204eae9ecce6db1f2John McCall shift.isNonNegative()) { 176960fad45739b764886f707bd204eae9ecce6db1f2John McCall unsigned zext = shift.getZExtValue(); 177060fad45739b764886f707bd204eae9ecce6db1f2John McCall if (zext >= L.Width) 177160fad45739b764886f707bd204eae9ecce6db1f2John McCall L.Width = (L.NonNegative ? 0 : 1); 177260fad45739b764886f707bd204eae9ecce6db1f2John McCall else 177360fad45739b764886f707bd204eae9ecce6db1f2John McCall L.Width -= zext; 177460fad45739b764886f707bd204eae9ecce6db1f2John McCall } 177560fad45739b764886f707bd204eae9ecce6db1f2John McCall 177660fad45739b764886f707bd204eae9ecce6db1f2John McCall return L; 177760fad45739b764886f707bd204eae9ecce6db1f2John McCall } 177860fad45739b764886f707bd204eae9ecce6db1f2John McCall 177960fad45739b764886f707bd204eae9ecce6db1f2John McCall // Comma acts as its right operand. 178051313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::Comma: 1781f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, BO->getRHS(), MaxWidth); 1782f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 178360fad45739b764886f707bd204eae9ecce6db1f2John McCall // Black-list pointer subtractions. 178451313c39c84407dd6a323be99a8c322bf8d052a9John McCall case BinaryOperator::Sub: 178551313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (BO->getLHS()->getType()->isPointerType()) 1786f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 178751313c39c84407dd6a323be99a8c322bf8d052a9John McCall // fallthrough 178851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 178951313c39c84407dd6a323be99a8c322bf8d052a9John McCall default: 1790f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall break; 179151313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 1792f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1793f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Treat every other operator as if it were closed on the 1794f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // narrowest type that encompasses both operands. 1795f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth); 1796f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange R = GetExprRange(C, BO->getRHS(), MaxWidth); 1797f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::join(L, R); 179851313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 179951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 180051313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 180151313c39c84407dd6a323be99a8c322bf8d052a9John McCall switch (UO->getOpcode()) { 180251313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Boolean-valued operations are white-listed. 180351313c39c84407dd6a323be99a8c322bf8d052a9John McCall case UnaryOperator::LNot: 1804f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forBoolType(); 180551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 180651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Operations with opaque sources are black-listed. 180751313c39c84407dd6a323be99a8c322bf8d052a9John McCall case UnaryOperator::Deref: 180851313c39c84407dd6a323be99a8c322bf8d052a9John McCall case UnaryOperator::AddrOf: // should be impossible 180951313c39c84407dd6a323be99a8c322bf8d052a9John McCall case UnaryOperator::OffsetOf: 1810f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 181151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 181251313c39c84407dd6a323be99a8c322bf8d052a9John McCall default: 1813f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return GetExprRange(C, UO->getSubExpr(), MaxWidth); 181451313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 181551313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 181651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1817f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall FieldDecl *BitField = E->getBitField(); 1818f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (BitField) { 1819f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall llvm::APSInt BitWidthAP = BitField->getBitWidth()->EvaluateAsInt(C); 1820f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned BitWidth = BitWidthAP.getZExtValue(); 182151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1822f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange(BitWidth, BitField->getType()->isUnsignedIntegerType()); 1823f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1824f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1825f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IntRange::forType(C, E->getType()); 1826f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall} 1827f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1828f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Checks whether the given value, which currently has the given 1829f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// source semantics, has the same value when coerced through the 1830f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// target semantics. 1831f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallbool IsSameFloatAfterCast(const llvm::APFloat &value, 1832f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Src, 1833f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Tgt) { 1834f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall llvm::APFloat truncated = value; 1835f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1836f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall bool ignored; 1837f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored); 1838f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored); 1839f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1840f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return truncated.bitwiseIsEqual(value); 184151313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 184251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 1843f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// Checks whether the given value, which currently has the given 1844f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// source semantics, has the same value when coerced through the 1845f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// target semantics. 1846f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// 1847f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall/// The value might be a vector of floats (or a complex number). 1848f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCallbool IsSameFloatAfterCast(const APValue &value, 1849f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Src, 1850f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall const llvm::fltSemantics &Tgt) { 1851f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isFloat()) 1852f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return IsSameFloatAfterCast(value.getFloat(), Src, Tgt); 1853f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1854f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (value.isVector()) { 1855f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i) 1856f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!IsSameFloatAfterCast(value.getVectorElt(i), Src, Tgt)) 1857f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return false; 1858f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return true; 1859f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1860f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1861f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(value.isComplexFloat()); 1862f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return (IsSameFloatAfterCast(value.getComplexFloatReal(), Src, Tgt) && 1863f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IsSameFloatAfterCast(value.getComplexFloatImag(), Src, Tgt)); 1864f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall} 1865f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1866f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall} // end anonymous namespace 1867f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1868ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \brief Implements -Wsign-compare. 1869ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// 1870ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param lex the left-hand expression 1871ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param rex the right-hand expression 1872ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param OpLoc the location of the joining operator 1873ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// \param Equality whether this is an "equality-like" join, which 1874ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall/// suppresses the warning in some cases 1875ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCallvoid Sema::CheckSignCompare(Expr *lex, Expr *rex, SourceLocation OpLoc, 1876ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall const PartialDiagnostic &PD, bool Equality) { 1877ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // Don't warn if we're in an unevaluated context. 1878ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (ExprEvalContexts.back().Context == Unevaluated) 1879ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1880ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1881f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // If either expression is value-dependent, don't warn. We'll get another 1882f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // chance at instantiation time. 1883f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (lex->isValueDependent() || rex->isValueDependent()) 1884f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall return; 1885f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1886ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall QualType lt = lex->getType(), rt = rex->getType(); 1887ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1888ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // Only warn if both operands are integral. 1889ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (!lt->isIntegerType() || !rt->isIntegerType()) 1890ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1891ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1892f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // In C, the width of a bitfield determines its type, and the 1893f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // declared type only contributes the signedness. This duplicates 1894f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // the work that will later be done by UsualUnaryConversions. 1895f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Eventually, this check will be reorganized in a way that avoids 1896f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // this duplication. 1897f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!getLangOptions().CPlusPlus) { 1898f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall QualType tmp; 1899f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall tmp = Context.isPromotableBitField(lex); 1900f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!tmp.isNull()) lt = tmp; 1901f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall tmp = Context.isPromotableBitField(rex); 1902f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!tmp.isNull()) rt = tmp; 1903f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall } 1904ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1905ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // The rule is that the signed operand becomes unsigned, so isolate the 1906ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // signed operand. 1907f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall Expr *signedOperand = lex, *unsignedOperand = rex; 1908f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall QualType signedType = lt, unsignedType = rt; 1909ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (lt->isSignedIntegerType()) { 1910ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (rt->isSignedIntegerType()) return; 1911ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall } else { 1912ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall if (!rt->isSignedIntegerType()) return; 1913f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall std::swap(signedOperand, unsignedOperand); 1914f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall std::swap(signedType, unsignedType); 1915ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall } 1916ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1917f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned unsignedWidth = Context.getIntWidth(unsignedType); 1918f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall unsigned signedWidth = Context.getIntWidth(signedType); 1919f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1920ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // If the unsigned type is strictly smaller than the signed type, 1921ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // then (1) the result type will be signed and (2) the unsigned 1922ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // value will fit fully within the signed type, and thus the result 1923ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // of the comparison will be exact. 1924f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (signedWidth > unsignedWidth) 1925ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1926ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1927f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // Otherwise, calculate the effective ranges. 1928f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange signedRange = GetExprRange(Context, signedOperand, signedWidth); 1929f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange unsignedRange = GetExprRange(Context, unsignedOperand, unsignedWidth); 1930f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1931f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // We should never be unable to prove that the unsigned operand is 1932f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // non-negative. 1933f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall assert(unsignedRange.NonNegative && "unsigned range includes negative?"); 1934f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 1935f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // If the signed operand is non-negative, then the signed->unsigned 1936f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // conversion won't change it. 1937f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (signedRange.NonNegative) 1938ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1939ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1940ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // For (in)equality comparisons, if the unsigned operand is a 1941ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // constant which cannot collide with a overflowed signed operand, 1942ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // then reinterpreting the signed operand as unsigned will not 1943ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall // change the result of the comparison. 1944f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (Equality && unsignedRange.Width < unsignedWidth) 1945ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall return; 1946ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 1947ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall Diag(OpLoc, PD) 1948f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall << lt << rt << lex->getSourceRange() << rex->getSourceRange(); 1949ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall} 1950ba26e58c64b4f6233dfc4bcd3ef6ce83aab47ffcJohn McCall 195151313c39c84407dd6a323be99a8c322bf8d052a9John McCall/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion. 195251313c39c84407dd6a323be99a8c322bf8d052a9John McCallstatic void DiagnoseImpCast(Sema &S, Expr *E, QualType T, unsigned diag) { 195351313c39c84407dd6a323be99a8c322bf8d052a9John McCall S.Diag(E->getExprLoc(), diag) << E->getType() << T << E->getSourceRange(); 195451313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 195551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 195651313c39c84407dd6a323be99a8c322bf8d052a9John McCall/// Implements -Wconversion. 195751313c39c84407dd6a323be99a8c322bf8d052a9John McCallvoid Sema::CheckImplicitConversion(Expr *E, QualType T) { 195851313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Don't diagnose in unevaluated contexts. 195951313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (ExprEvalContexts.back().Context == Sema::Unevaluated) 196051313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 196151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 196251313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Don't diagnose for value-dependent expressions. 196351313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (E->isValueDependent()) 196451313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 196551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 196651313c39c84407dd6a323be99a8c322bf8d052a9John McCall const Type *Source = Context.getCanonicalType(E->getType()).getTypePtr(); 196751313c39c84407dd6a323be99a8c322bf8d052a9John McCall const Type *Target = Context.getCanonicalType(T).getTypePtr(); 196851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 196951313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Never diagnose implicit casts to bool. 197051313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (Target->isSpecificBuiltinType(BuiltinType::Bool)) 197151313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 197251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 197351313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Strip vector types. 197451313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (isa<VectorType>(Source)) { 197551313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (!isa<VectorType>(Target)) 197651313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_vector_scalar); 197751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 197851313c39c84407dd6a323be99a8c322bf8d052a9John McCall Source = cast<VectorType>(Source)->getElementType().getTypePtr(); 197951313c39c84407dd6a323be99a8c322bf8d052a9John McCall Target = cast<VectorType>(Target)->getElementType().getTypePtr(); 198051313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 198151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 198251313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Strip complex types. 198351313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (isa<ComplexType>(Source)) { 198451313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (!isa<ComplexType>(Target)) 198551313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_complex_scalar); 198651313c39c84407dd6a323be99a8c322bf8d052a9John McCall 198751313c39c84407dd6a323be99a8c322bf8d052a9John McCall Source = cast<ComplexType>(Source)->getElementType().getTypePtr(); 198851313c39c84407dd6a323be99a8c322bf8d052a9John McCall Target = cast<ComplexType>(Target)->getElementType().getTypePtr(); 198951313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 199051313c39c84407dd6a323be99a8c322bf8d052a9John McCall 199151313c39c84407dd6a323be99a8c322bf8d052a9John McCall const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source); 199251313c39c84407dd6a323be99a8c322bf8d052a9John McCall const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target); 199351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 199451313c39c84407dd6a323be99a8c322bf8d052a9John McCall // If the source is floating point... 199551313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (SourceBT && SourceBT->isFloatingPoint()) { 199651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // ...and the target is floating point... 199751313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (TargetBT && TargetBT->isFloatingPoint()) { 199851313c39c84407dd6a323be99a8c322bf8d052a9John McCall // ...then warn if we're dropping FP rank. 199951313c39c84407dd6a323be99a8c322bf8d052a9John McCall 200051313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Builtin FP kinds are ordered by increasing FP rank. 200151313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (SourceBT->getKind() > TargetBT->getKind()) { 200251313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Don't warn about float constants that are precisely 200351313c39c84407dd6a323be99a8c322bf8d052a9John McCall // representable in the target type. 200451313c39c84407dd6a323be99a8c322bf8d052a9John McCall Expr::EvalResult result; 200551313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (E->Evaluate(result, Context)) { 200651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // Value might be a float, a float vector, or a float complex. 200751313c39c84407dd6a323be99a8c322bf8d052a9John McCall if (IsSameFloatAfterCast(result.Val, 200851313c39c84407dd6a323be99a8c322bf8d052a9John McCall Context.getFloatTypeSemantics(QualType(TargetBT, 0)), 200951313c39c84407dd6a323be99a8c322bf8d052a9John McCall Context.getFloatTypeSemantics(QualType(SourceBT, 0)))) 201051313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 201151313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 201251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 201351313c39c84407dd6a323be99a8c322bf8d052a9John McCall DiagnoseImpCast(*this, E, T, diag::warn_impcast_float_precision); 201451313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 201551313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 201651313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 201751313c39c84407dd6a323be99a8c322bf8d052a9John McCall 201851313c39c84407dd6a323be99a8c322bf8d052a9John McCall // If the target is integral, always warn. 201951313c39c84407dd6a323be99a8c322bf8d052a9John McCall if ((TargetBT && TargetBT->isInteger())) 202051313c39c84407dd6a323be99a8c322bf8d052a9John McCall // TODO: don't warn for integer values? 202151313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_float_integer); 202251313c39c84407dd6a323be99a8c322bf8d052a9John McCall 202351313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 202451313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 202551313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2026f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (!Source->isIntegerType() || !Target->isIntegerType()) 202751313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 202851313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2029f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange SourceRange = GetExprRange(Context, E, Context.getIntWidth(E->getType())); 2030f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall IntRange TargetRange = IntRange::forCanonicalType(Context, Target); 2031f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall 2032f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall // FIXME: also signed<->unsigned? 203351313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2034f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SourceRange.Width > TargetRange.Width) { 203551313c39c84407dd6a323be99a8c322bf8d052a9John McCall // People want to build with -Wshorten-64-to-32 and not -Wconversion 203651313c39c84407dd6a323be99a8c322bf8d052a9John McCall // and by god we'll let them. 2037f2370c9b4aade940e2253b5b33262ba507d1d71fJohn McCall if (SourceRange.Width == 64 && TargetRange.Width == 32) 203851313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_integer_64_32); 203951313c39c84407dd6a323be99a8c322bf8d052a9John McCall return DiagnoseImpCast(*this, E, T, diag::warn_impcast_integer_precision); 204051313c39c84407dd6a323be99a8c322bf8d052a9John McCall } 204151313c39c84407dd6a323be99a8c322bf8d052a9John McCall 204251313c39c84407dd6a323be99a8c322bf8d052a9John McCall return; 204351313c39c84407dd6a323be99a8c322bf8d052a9John McCall} 204451313c39c84407dd6a323be99a8c322bf8d052a9John McCall 2045f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump// MarkLive - Mark all the blocks reachable from e as live. Returns the total 2046f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump// number of blocks just marked live. 2047f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stumpstatic unsigned MarkLive(CFGBlock *e, llvm::BitVector &live) { 2048f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump unsigned count = 0; 2049f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump std::queue<CFGBlock*> workq; 2050f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Prep work queue 2051f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump live.set(e->getBlockID()); 2052f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ++count; 2053f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump workq.push(e); 2054f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Solve 2055f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump while (!workq.empty()) { 2056f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump CFGBlock *item = workq.front(); 2057f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump workq.pop(); 2058f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump for (CFGBlock::succ_iterator I=item->succ_begin(), 2059f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump E=item->succ_end(); 2060f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump I != E; 2061f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ++I) { 2062f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if ((*I) && !live[(*I)->getBlockID()]) { 2063f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump live.set((*I)->getBlockID()); 2064f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ++count; 2065f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump workq.push(*I); 2066f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2067f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2068f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2069f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return count; 2070f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2071f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 207255f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stumpstatic SourceLocation GetUnreachableLoc(CFGBlock &b, SourceRange &R1, 207355f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump SourceRange &R2) { 2074f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Stmt *S; 2075e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump unsigned sn = 0; 2076e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump R1 = R2 = SourceRange(); 2077e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump 2078e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump top: 2079e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump if (sn < b.size()) 2080e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump S = b[sn].getStmt(); 2081f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump else if (b.getTerminator()) 2082f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump S = b.getTerminator(); 2083f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump else 2084f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return SourceLocation(); 2085f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2086f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump switch (S->getStmtClass()) { 2087f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case Expr::BinaryOperatorClass: { 208855f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump BinaryOperator *BO = cast<BinaryOperator>(S); 208955f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump if (BO->getOpcode() == BinaryOperator::Comma) { 2090e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump if (sn+1 < b.size()) 2091e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump return b[sn+1].getStmt()->getLocStart(); 2092f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump CFGBlock *n = &b; 2093f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump while (1) { 2094f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (n->getTerminator()) 2095f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return n->getTerminator()->getLocStart(); 2096f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (n->succ_size() != 1) 2097f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return SourceLocation(); 2098f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump n = n[0].succ_begin()[0]; 2099f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (n->pred_size() != 1) 2100f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return SourceLocation(); 2101f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (!n->empty()) 2102f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return n[0][0].getStmt()->getLocStart(); 2103f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2104f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 210555f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump R1 = BO->getLHS()->getSourceRange(); 210655f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump R2 = BO->getRHS()->getSourceRange(); 210755f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump return BO->getOperatorLoc(); 210855f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump } 210955f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump case Expr::UnaryOperatorClass: { 211055f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump const UnaryOperator *UO = cast<UnaryOperator>(S); 211155f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump R1 = UO->getSubExpr()->getSourceRange(); 211255f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump return UO->getOperatorLoc(); 2113f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 211445db90de59f6effb7bd9a55660ca97aa3feadc6cMike Stump case Expr::CompoundAssignOperatorClass: { 211545db90de59f6effb7bd9a55660ca97aa3feadc6cMike Stump const CompoundAssignOperator *CAO = cast<CompoundAssignOperator>(S); 211645db90de59f6effb7bd9a55660ca97aa3feadc6cMike Stump R1 = CAO->getLHS()->getSourceRange(); 211745db90de59f6effb7bd9a55660ca97aa3feadc6cMike Stump R2 = CAO->getRHS()->getSourceRange(); 211845db90de59f6effb7bd9a55660ca97aa3feadc6cMike Stump return CAO->getOperatorLoc(); 211945db90de59f6effb7bd9a55660ca97aa3feadc6cMike Stump } 2120e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump case Expr::ConditionalOperatorClass: { 2121e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump const ConditionalOperator *CO = cast<ConditionalOperator>(S); 2122e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump return CO->getQuestionLoc(); 2123e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump } 2124b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump case Expr::MemberExprClass: { 2125b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump const MemberExpr *ME = cast<MemberExpr>(S); 2126b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump R1 = ME->getSourceRange(); 2127b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump return ME->getMemberLoc(); 2128b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump } 2129b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump case Expr::ArraySubscriptExprClass: { 2130b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(S); 2131b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump R1 = ASE->getLHS()->getSourceRange(); 2132b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump R2 = ASE->getRHS()->getSourceRange(); 2133b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump return ASE->getRBracketLoc(); 2134b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump } 213544582300b63ac128989643adcd12b6349b67abe4Mike Stump case Expr::CStyleCastExprClass: { 213644582300b63ac128989643adcd12b6349b67abe4Mike Stump const CStyleCastExpr *CSC = cast<CStyleCastExpr>(S); 213744582300b63ac128989643adcd12b6349b67abe4Mike Stump R1 = CSC->getSubExpr()->getSourceRange(); 213844582300b63ac128989643adcd12b6349b67abe4Mike Stump return CSC->getLParenLoc(); 213944582300b63ac128989643adcd12b6349b67abe4Mike Stump } 21402d6ceab0ad062989ecb7b8666c85e58a2fcd95ceMike Stump case Expr::CXXFunctionalCastExprClass: { 21412d6ceab0ad062989ecb7b8666c85e58a2fcd95ceMike Stump const CXXFunctionalCastExpr *CE = cast <CXXFunctionalCastExpr>(S); 21422d6ceab0ad062989ecb7b8666c85e58a2fcd95ceMike Stump R1 = CE->getSubExpr()->getSourceRange(); 21432d6ceab0ad062989ecb7b8666c85e58a2fcd95ceMike Stump return CE->getTypeBeginLoc(); 21442d6ceab0ad062989ecb7b8666c85e58a2fcd95ceMike Stump } 2145e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump case Expr::ImplicitCastExprClass: 2146e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump ++sn; 2147e5fba7058ce34cc3d75e16e777ec6fc8096183f8Mike Stump goto top; 21484c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump case Stmt::CXXTryStmtClass: { 21494c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump return cast<CXXTryStmt>(S)->getHandler(0)->getCatchLoc(); 21504c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump } 2151f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump default: ; 2152f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2153b5c775575b496c03d862ea03587a9f1d74193c9fMike Stump R1 = S->getSourceRange(); 2154f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return S->getLocStart(); 2155f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2156f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2157f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stumpstatic SourceLocation MarkLiveTop(CFGBlock *e, llvm::BitVector &live, 2158f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump SourceManager &SM) { 2159f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump std::queue<CFGBlock*> workq; 2160f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Prep work queue 2161f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump workq.push(e); 216255f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump SourceRange R1, R2; 216355f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump SourceLocation top = GetUnreachableLoc(*e, R1, R2); 2164f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool FromMainFile = false; 2165f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool FromSystemHeader = false; 2166f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool TopValid = false; 2167f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (top.isValid()) { 2168f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump FromMainFile = SM.isFromMainFile(top); 2169f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump FromSystemHeader = SM.isInSystemHeader(top); 2170f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump TopValid = true; 2171f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2172f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Solve 2173f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump while (!workq.empty()) { 2174f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump CFGBlock *item = workq.front(); 2175f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump workq.pop(); 217655f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump SourceLocation c = GetUnreachableLoc(*item, R1, R2); 2177f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (c.isValid() 2178f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump && (!TopValid 2179f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump || (SM.isFromMainFile(c) && !FromMainFile) 2180f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump || (FromSystemHeader && !SM.isInSystemHeader(c)) 2181f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump || SM.isBeforeInTranslationUnit(c, top))) { 2182f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump top = c; 2183f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump FromMainFile = SM.isFromMainFile(top); 2184f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump FromSystemHeader = SM.isInSystemHeader(top); 2185f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2186f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump live.set(item->getBlockID()); 2187f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump for (CFGBlock::succ_iterator I=item->succ_begin(), 2188f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump E=item->succ_end(); 2189f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump I != E; 2190f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ++I) { 2191f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if ((*I) && !live[(*I)->getBlockID()]) { 2192f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump live.set((*I)->getBlockID()); 2193f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump workq.push(*I); 2194f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2195f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2196f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2197f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return top; 2198f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2199f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2200f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stumpstatic int LineCmp(const void *p1, const void *p2) { 2201f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump SourceLocation *Line1 = (SourceLocation *)p1; 2202f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump SourceLocation *Line2 = (SourceLocation *)p2; 2203f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return !(*Line1 < *Line2); 2204f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2205f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 22064a415670481424a210df419a9f96e29db9939106Mike Stumpnamespace { 22074a415670481424a210df419a9f96e29db9939106Mike Stump struct ErrLoc { 22084a415670481424a210df419a9f96e29db9939106Mike Stump SourceLocation Loc; 22094a415670481424a210df419a9f96e29db9939106Mike Stump SourceRange R1; 22104a415670481424a210df419a9f96e29db9939106Mike Stump SourceRange R2; 22114a415670481424a210df419a9f96e29db9939106Mike Stump ErrLoc(SourceLocation l, SourceRange r1, SourceRange r2) 22124a415670481424a210df419a9f96e29db9939106Mike Stump : Loc(l), R1(r1), R2(r2) { } 22134a415670481424a210df419a9f96e29db9939106Mike Stump }; 22144a415670481424a210df419a9f96e29db9939106Mike Stump} 22154a415670481424a210df419a9f96e29db9939106Mike Stump 2216f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// CheckUnreachable - Check for unreachable code. 2217f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stumpvoid Sema::CheckUnreachable(AnalysisContext &AC) { 2218f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump unsigned count; 2219f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // We avoid checking when there are errors, as the CFG won't faithfully match 2220f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // the user's code. 2221f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (getDiagnostics().hasErrorOccurred()) 2222f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2223f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (Diags.getDiagnosticLevel(diag::warn_unreachable) == Diagnostic::Ignored) 2224f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2225f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2226f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump CFG *cfg = AC.getCFG(); 2227f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (cfg == 0) 2228f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2229f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2230f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump llvm::BitVector live(cfg->getNumBlockIDs()); 2231f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Mark all live things first. 2232f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump count = MarkLive(&cfg->getEntry(), live); 2233f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2234f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (count == cfg->getNumBlockIDs()) 2235f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // If there are no dead blocks, we're done. 2236f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2237f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 223855f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump SourceRange R1, R2; 223955f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump 22404a415670481424a210df419a9f96e29db9939106Mike Stump llvm::SmallVector<ErrLoc, 24> lines; 22414c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump bool AddEHEdges = AC.getAddEHEdges(); 2242f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // First, give warnings for blocks with no predecessors, as they 2243f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // can't be part of a loop. 2244f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump for (CFG::iterator I = cfg->begin(), E = cfg->end(); I != E; ++I) { 2245f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump CFGBlock &b = **I; 2246f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (!live[b.getBlockID()]) { 2247f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (b.pred_begin() == b.pred_end()) { 22484c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump if (!AddEHEdges && b.getTerminator() 22494c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump && isa<CXXTryStmt>(b.getTerminator())) { 22504c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump // When not adding EH edges from calls, catch clauses 22514c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump // can otherwise seem dead. Avoid noting them as dead. 22524c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump count += MarkLive(&b, live); 22534c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump continue; 22544c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump } 225555f988efeb08b84c2dd9e4c05990b88c81fe2b58Mike Stump SourceLocation c = GetUnreachableLoc(b, R1, R2); 2256f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (!c.isValid()) { 2257f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Blocks without a location can't produce a warning, so don't mark 2258f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // reachable blocks from here as live. 2259f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump live.set(b.getBlockID()); 2260f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ++count; 2261f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2262f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 22634a415670481424a210df419a9f96e29db9939106Mike Stump lines.push_back(ErrLoc(c, R1, R2)); 2264f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Avoid excessive errors by marking everything reachable from here 2265f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump count += MarkLive(&b, live); 2266f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2267f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2268f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2269f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2270f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (count < cfg->getNumBlockIDs()) { 2271f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // And then give warnings for the tops of loops. 2272f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump for (CFG::iterator I = cfg->begin(), E = cfg->end(); I != E; ++I) { 2273f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump CFGBlock &b = **I; 2274f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (!live[b.getBlockID()]) 2275f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Avoid excessive errors by marking everything reachable from here 22768acc9f6370865e200f1bf63dee5c48d8c28e2b06Ted Kremenek lines.push_back(ErrLoc(MarkLiveTop(&b, live, 22778acc9f6370865e200f1bf63dee5c48d8c28e2b06Ted Kremenek Context.getSourceManager()), 22788acc9f6370865e200f1bf63dee5c48d8c28e2b06Ted Kremenek SourceRange(), SourceRange())); 2279f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2280f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2281f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2282f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump llvm::array_pod_sort(lines.begin(), lines.end(), LineCmp); 22834a415670481424a210df419a9f96e29db9939106Mike Stump for (llvm::SmallVector<ErrLoc, 24>::iterator I = lines.begin(), 2284f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump E = lines.end(); 2285f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump I != E; 2286f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ++I) 22874a415670481424a210df419a9f96e29db9939106Mike Stump if (I->Loc.isValid()) 22884a415670481424a210df419a9f96e29db9939106Mike Stump Diag(I->Loc, diag::warn_unreachable) << I->R1 << I->R2; 2289f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2290f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2291f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// CheckFallThrough - Check that we don't fall off the end of a 2292f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// Statement that should return a value. 2293f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// 2294f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// \returns AlwaysFallThrough iff we always fall off the end of the statement, 2295f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// MaybeFallThrough iff we might or might not fall off the end, 2296f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// NeverFallThroughOrReturn iff we never fall off the end of the statement or 2297f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// return. We assume NeverFallThrough iff we never fall off the end of the 2298f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// statement but we may return. We assume that functions not marked noreturn 2299f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// will return. 2300f8c4921c73d73123e2b79221ad4f1775ce984cfdMike StumpSema::ControlFlowKind Sema::CheckFallThrough(AnalysisContext &AC) { 2301f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump CFG *cfg = AC.getCFG(); 2302f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (cfg == 0) 2303f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // FIXME: This should be NeverFallThrough 2304f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return NeverFallThroughOrReturn; 2305f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 23064c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump // The CFG leaves in dead things, and we don't want the dead code paths to 2307f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // confuse us, so we mark all live things first. 2308f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump std::queue<CFGBlock*> workq; 2309f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump llvm::BitVector live(cfg->getNumBlockIDs()); 23104c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump unsigned count = MarkLive(&cfg->getEntry(), live); 23114c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump 23124c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump bool AddEHEdges = AC.getAddEHEdges(); 23134c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump if (!AddEHEdges && count != cfg->getNumBlockIDs()) 23144c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump // When there are things remaining dead, and we didn't add EH edges 23154c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump // from CallExprs to the catch clauses, we have to go back and 23164c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump // mark them as live. 23174c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump for (CFG::iterator I = cfg->begin(), E = cfg->end(); I != E; ++I) { 23184c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump CFGBlock &b = **I; 23194c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump if (!live[b.getBlockID()]) { 23204c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump if (b.pred_begin() == b.pred_end()) { 23214c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump if (b.getTerminator() && isa<CXXTryStmt>(b.getTerminator())) 23224c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump // When not adding EH edges from calls, catch clauses 23234c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump // can otherwise seem dead. Avoid noting them as dead. 23244c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump count += MarkLive(&b, live); 23254c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump continue; 23264c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump } 23274c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump } 23284c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump } 2329f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2330f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Now we know what is live, we check the live precessors of the exit block 2331f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // and look for fall through paths, being careful to ignore normal returns, 2332f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // and exceptional paths. 2333f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool HasLiveReturn = false; 2334f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool HasFakeEdge = false; 2335f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool HasPlainEdge = false; 2336f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool HasAbnormalEdge = false; 2337f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump for (CFGBlock::pred_iterator I=cfg->getExit().pred_begin(), 2338f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump E = cfg->getExit().pred_end(); 2339f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump I != E; 2340f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ++I) { 2341f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump CFGBlock& B = **I; 2342f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (!live[B.getBlockID()]) 2343f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2344f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (B.size() == 0) { 23454c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump if (B.getTerminator() && isa<CXXTryStmt>(B.getTerminator())) { 23464c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump HasAbnormalEdge = true; 23474c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump continue; 23484c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump } 23494c45aa1b00b91847acfb082acfaced3ffa294d1dMike Stump 2350f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // A labeled empty statement, or the entry block... 2351f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasPlainEdge = true; 2352f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2353f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2354f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Stmt *S = B[B.size()-1]; 2355f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (isa<ReturnStmt>(S)) { 2356f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasLiveReturn = true; 2357f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2358f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2359f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (isa<ObjCAtThrowStmt>(S)) { 2360f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasFakeEdge = true; 2361f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2362f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2363f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (isa<CXXThrowExpr>(S)) { 2364f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasFakeEdge = true; 2365f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2366f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2367f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (const AsmStmt *AS = dyn_cast<AsmStmt>(S)) { 2368f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (AS->isMSAsm()) { 2369f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasFakeEdge = true; 2370f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasLiveReturn = true; 2371f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2372f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2373f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2374f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (isa<CXXTryStmt>(S)) { 2375f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasAbnormalEdge = true; 2376f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2377f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2378f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2379f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool NoReturnEdge = false; 2380f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (CallExpr *C = dyn_cast<CallExpr>(S)) { 2381f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (B.succ_begin()[0] != &cfg->getExit()) { 2382f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasAbnormalEdge = true; 2383f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump continue; 2384f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2385f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Expr *CEE = C->getCallee()->IgnoreParenCasts(); 2386f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (CEE->getType().getNoReturnAttr()) { 2387f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump NoReturnEdge = true; 2388f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasFakeEdge = true; 2389f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) { 2390f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ValueDecl *VD = DRE->getDecl(); 2391f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (VD->hasAttr<NoReturnAttr>()) { 2392f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump NoReturnEdge = true; 2393f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasFakeEdge = true; 2394f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2395f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2396f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2397f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // FIXME: Add noreturn message sends. 2398f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (NoReturnEdge == false) 2399f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasPlainEdge = true; 2400f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2401f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (!HasPlainEdge) { 2402f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (HasLiveReturn) 2403f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return NeverFallThrough; 2404f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return NeverFallThroughOrReturn; 2405f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2406f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (HasAbnormalEdge || HasFakeEdge || HasLiveReturn) 2407f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return MaybeFallThrough; 2408f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // This says AlwaysFallThrough for calls to functions that are not marked 2409f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // noreturn, that don't return. If people would like this warning to be more 2410f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // accurate, such functions should be marked as noreturn. 2411f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return AlwaysFallThrough; 2412f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2413f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2414f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// CheckFallThroughForFunctionDef - Check that we don't fall off the end of a 2415f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// function that should return a value. Check that we don't fall off the end 2416f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// of a noreturn function. We assume that functions and blocks not marked 2417f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// noreturn will return. 2418f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stumpvoid Sema::CheckFallThroughForFunctionDef(Decl *D, Stmt *Body, 2419f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump AnalysisContext &AC) { 2420f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // FIXME: Would be nice if we had a better way to control cascading errors, 2421f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // but for now, avoid them. The problem is that when Parse sees: 2422f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // int foo() { return a; } 2423f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // The return is eaten and the Sema code sees just: 2424f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // int foo() { } 2425f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // which this code would then warn about. 2426f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (getDiagnostics().hasErrorOccurred()) 2427f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2428f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2429f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool ReturnsVoid = false; 2430f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool HasNoReturn = false; 2431f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2432f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // If the result type of the function is a dependent type, we don't know 2433f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // whether it will be void or not, so don't 2434f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (FD->getResultType()->isDependentType()) 2435f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2436f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (FD->getResultType()->isVoidType()) 2437f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ReturnsVoid = true; 2438f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (FD->hasAttr<NoReturnAttr>()) 2439f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasNoReturn = true; 2440f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 2441f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (MD->getResultType()->isVoidType()) 2442f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ReturnsVoid = true; 2443f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (MD->hasAttr<NoReturnAttr>()) 2444f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasNoReturn = true; 2445f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2446f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2447f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Short circuit for compilation speed. 2448f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if ((Diags.getDiagnosticLevel(diag::warn_maybe_falloff_nonvoid_function) 2449f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump == Diagnostic::Ignored || ReturnsVoid) 2450f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump && (Diags.getDiagnosticLevel(diag::warn_noreturn_function_has_return_expr) 2451f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump == Diagnostic::Ignored || !HasNoReturn) 2452f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump && (Diags.getDiagnosticLevel(diag::warn_suggest_noreturn_block) 2453f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump == Diagnostic::Ignored || !ReturnsVoid)) 2454f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2455f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // FIXME: Function try block 2456f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (CompoundStmt *Compound = dyn_cast<CompoundStmt>(Body)) { 2457f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump switch (CheckFallThrough(AC)) { 2458f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case MaybeFallThrough: 2459f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (HasNoReturn) 2460f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getRBracLoc(), diag::warn_falloff_noreturn_function); 2461f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump else if (!ReturnsVoid) 2462f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getRBracLoc(),diag::warn_maybe_falloff_nonvoid_function); 2463f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump break; 2464f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case AlwaysFallThrough: 2465f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (HasNoReturn) 2466f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getRBracLoc(), diag::warn_falloff_noreturn_function); 2467f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump else if (!ReturnsVoid) 2468f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getRBracLoc(), diag::warn_falloff_nonvoid_function); 2469f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump break; 2470f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case NeverFallThroughOrReturn: 2471f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (ReturnsVoid && !HasNoReturn) 2472f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getLBracLoc(), diag::warn_suggest_noreturn_function); 2473f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump break; 2474f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case NeverFallThrough: 2475f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump break; 2476f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2477f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2478f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2479f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2480f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// CheckFallThroughForBlock - Check that we don't fall off the end of a block 2481f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// that should return a value. Check that we don't fall off the end of a 2482f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// noreturn block. We assume that functions and blocks not marked noreturn 2483f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// will return. 2484f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stumpvoid Sema::CheckFallThroughForBlock(QualType BlockTy, Stmt *Body, 2485f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump AnalysisContext &AC) { 2486f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // FIXME: Would be nice if we had a better way to control cascading errors, 2487f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // but for now, avoid them. The problem is that when Parse sees: 2488f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // int foo() { return a; } 2489f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // The return is eaten and the Sema code sees just: 2490f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // int foo() { } 2491f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // which this code would then warn about. 2492f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (getDiagnostics().hasErrorOccurred()) 2493f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2494f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool ReturnsVoid = false; 2495f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool HasNoReturn = false; 2496f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (const FunctionType *FT =BlockTy->getPointeeType()->getAs<FunctionType>()){ 2497f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (FT->getResultType()->isVoidType()) 2498f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ReturnsVoid = true; 2499f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (FT->getNoReturnAttr()) 2500f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasNoReturn = true; 2501f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2502f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2503f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // Short circuit for compilation speed. 2504f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (ReturnsVoid 2505f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump && !HasNoReturn 2506f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump && (Diags.getDiagnosticLevel(diag::warn_suggest_noreturn_block) 2507f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump == Diagnostic::Ignored || !ReturnsVoid)) 2508f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return; 2509f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // FIXME: Funtion try block 2510f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (CompoundStmt *Compound = dyn_cast<CompoundStmt>(Body)) { 2511f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump switch (CheckFallThrough(AC)) { 2512f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case MaybeFallThrough: 2513f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (HasNoReturn) 2514f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getRBracLoc(), diag::err_noreturn_block_has_return_expr); 2515f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump else if (!ReturnsVoid) 2516f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getRBracLoc(), diag::err_maybe_falloff_nonvoid_block); 2517f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump break; 2518f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case AlwaysFallThrough: 2519f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (HasNoReturn) 2520f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getRBracLoc(), diag::err_noreturn_block_has_return_expr); 2521f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump else if (!ReturnsVoid) 2522f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getRBracLoc(), diag::err_falloff_nonvoid_block); 2523f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump break; 2524f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case NeverFallThroughOrReturn: 2525f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (ReturnsVoid) 2526f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Compound->getLBracLoc(), diag::warn_suggest_noreturn_block); 2527f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump break; 2528f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump case NeverFallThrough: 2529f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump break; 2530f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2531f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2532f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2533f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2534f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// CheckParmsForFunctionDef - Check that the parameters of the given 2535f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// function are appropriate for the definition of a function. This 2536f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// takes care of any checks that cannot be performed on the 2537f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// declaration itself, e.g., that the types of each of the function 2538f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump/// parameters are complete. 2539f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stumpbool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) { 2540f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump bool HasInvalidParm = false; 2541f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) { 2542f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump ParmVarDecl *Param = FD->getParamDecl(p); 2543f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2544f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // C99 6.7.5.3p4: the parameters in a parameter type list in a 2545f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // function declarator that is part of a function definition of 2546f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // that function shall not have incomplete type. 2547f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // 2548f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // This is also C++ [dcl.fct]p6. 2549f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (!Param->isInvalidDecl() && 2550f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump RequireCompleteType(Param->getLocation(), Param->getType(), 2551f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump diag::err_typecheck_decl_incomplete_type)) { 2552f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Param->setInvalidDecl(); 2553f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump HasInvalidParm = true; 2554f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2555f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2556f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // C99 6.9.1p5: If the declarator includes a parameter type list, the 2557f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump // declaration of each parameter shall include an identifier. 2558f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump if (Param->getIdentifier() == 0 && 2559f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump !Param->isImplicit() && 2560f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump !getLangOptions().CPlusPlus) 2561f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump Diag(Param->getLocation(), diag::err_parameter_name_omitted); 2562f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump } 2563f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump 2564f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump return HasInvalidParm; 2565f8c4921c73d73123e2b79221ad4f1775ce984cfdMike Stump} 2566