SemaChecking.cpp revision 40b598eea1310ec9ed554d56ce3e25b34c585458
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// 1059907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// This file implements extra semantic analysis beyond what is enforced 1159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// by the C type system. 1259907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner// 1359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner//===----------------------------------------------------------------------===// 1459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 1559907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "Sema.h" 1659907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "clang/AST/ASTContext.h" 17c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 182324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek#include "clang/AST/ExprCXX.h" 197ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek#include "clang/AST/ExprObjC.h" 20719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner#include "clang/Lex/LiteralSupport.h" 2159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner#include "clang/Lex/Preprocessor.h" 22a1f3dba77b7418575c1ff539ffa74ebaa068280cZhongxing Xu#include <limits> 2359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattnerusing namespace clang; 2459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 2560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// getLocationOfStringLiteralByte - Return a source location that points to the 2660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// specified byte of the specified string literal. 2760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// 2860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// Strings are amazingly complex. They can be formed from multiple tokens and 2960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// can have escape sequences in them in addition to the usual trigraph and 3060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// escaped newline business. This routine handles this complexity. 3160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner/// 3260800081361b0ffc114877b8abbc81cb57b4edf6Chris LattnerSourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL, 3360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner unsigned ByteNo) const { 3460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner assert(!SL->isWide() && "This doesn't work for wide strings yet"); 3560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 3660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Loop over all of the tokens in this string until we find the one that 3760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // contains the byte we're looking for. 3860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner unsigned TokNo = 0; 3960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner while (1) { 4060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner assert(TokNo < SL->getNumConcatenated() && "Invalid byte number!"); 4160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation StrTokLoc = SL->getStrTokenLoc(TokNo); 4260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 4360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Get the spelling of the string so that we can get the data that makes up 4460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // the string literal, not the identifier for the macro it is potentially 4560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // expanded through. 4660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation StrTokSpellingLoc = SourceMgr.getSpellingLoc(StrTokLoc); 4760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 4860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Re-lex the token to get its length and original spelling. 4960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner std::pair<FileID, unsigned> LocInfo = 5060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceMgr.getDecomposedLoc(StrTokSpellingLoc); 5160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner std::pair<const char *,const char *> Buffer = 5260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceMgr.getBufferData(LocInfo.first); 5360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner const char *StrData = Buffer.first+LocInfo.second; 5460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 5560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Create a langops struct and enable trigraphs. This is sufficient for 5660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // relexing tokens. 5760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner LangOptions LangOpts; 5860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner LangOpts.Trigraphs = true; 5960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 6060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Create a lexer starting at the beginning of this token. 6160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Lexer TheLexer(StrTokSpellingLoc, LangOpts, Buffer.first, StrData, 6260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Buffer.second); 6360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Token TheTok; 6460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner TheLexer.LexFromRawLexer(TheTok); 6560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 66443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner // Use the StringLiteralParser to compute the length of the string in bytes. 67443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner StringLiteralParser SLP(&TheTok, 1, PP); 68443e53c7845f01c8ed693ccd137abb0bd76564f6Chris Lattner unsigned TokNumBytes = SLP.GetStringLength(); 69d0d082f2eba4e3ed4eb467d76fd227c6dcd6cce7Chris Lattner 702197c963543397777919cec22b65feb31a9ddf79Chris Lattner // If the byte is in this token, return the location of the byte. 7160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner if (ByteNo < TokNumBytes || 7260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner (ByteNo == TokNumBytes && TokNo == SL->getNumConcatenated())) { 73719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner unsigned Offset = 74719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner StringLiteralParser::getOffsetOfStringByte(TheTok, ByteNo, PP); 75719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner 76719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner // Now that we know the offset of the token in the spelling, use the 77719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner // preprocessor to get the offset in the original source. 78719e61573f27c11057ecfe0dd8f141621602c571Chris Lattner return PP.AdvanceToTokenCharacter(StrTokLoc, Offset); 7960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner } 8060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 8160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner // Move to the next string token. 8260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner ++TokNo; 8360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner ByteNo -= TokNumBytes; 8460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner } 8560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner} 8660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 8760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner 8859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// CheckFunctionCall - Check a direct function call for various correctness 8959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// and safety properties not strictly enforced by the C type system. 900eb23307222bda7ad95d968eac4e1ab30864b213Sebastian RedlAction::OwningExprResult 910eb23307222bda7ad95d968eac4e1ab30864b213Sebastian RedlSema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall) { 920eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl OwningExprResult TheCallResult(Owned(TheCall)); 9359907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // Get the IdentifierInfo* for the called function. 9459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner IdentifierInfo *FnInfo = FDecl->getIdentifier(); 952def48394f6d48bde0dec2b514193c2b533265b5Douglas Gregor 962def48394f6d48bde0dec2b514193c2b533265b5Douglas Gregor // None of the checks below are needed for functions that don't have 972def48394f6d48bde0dec2b514193c2b533265b5Douglas Gregor // simple names (e.g., C++ conversion functions). 982def48394f6d48bde0dec2b514193c2b533265b5Douglas Gregor if (!FnInfo) 990eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return move(TheCallResult); 1002def48394f6d48bde0dec2b514193c2b533265b5Douglas Gregor 1013c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor switch (FDecl->getBuiltinID(Context)) { 10230ce344307f8a8b00054021307015571f83c7364Chris Lattner case Builtin::BI__builtin___CFStringMakeConstantString: 103925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner assert(TheCall->getNumArgs() == 1 && 1041b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner "Wrong # arguments to builtin CFStringMakeConstantString"); 105690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattner if (CheckObjCString(TheCall->getArg(0))) 1060eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 1070eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return move(TheCallResult); 10849ff7a1c8c67d56e62d3b4627463b705c0d5008cTed Kremenek case Builtin::BI__builtin_stdarg_start: 10930ce344307f8a8b00054021307015571f83c7364Chris Lattner case Builtin::BI__builtin_va_start: 1100eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinVAStart(TheCall)) 1110eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 1120eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return move(TheCallResult); 1131b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isgreater: 1141b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isgreaterequal: 1151b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isless: 1161b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_islessequal: 1171b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_islessgreater: 1181b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner case Builtin::BI__builtin_isunordered: 1190eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinUnorderedCompare(TheCall)) 1200eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 1210eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return move(TheCallResult); 1226cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman case Builtin::BI__builtin_return_address: 1236cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman case Builtin::BI__builtin_frame_address: 1240eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinStackAddress(TheCall)) 1250eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 1260eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return move(TheCallResult); 127d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman case Builtin::BI__builtin_shufflevector: 1280eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return SemaBuiltinShuffleVector(TheCall); 1290eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl // TheCall will be freed by the smart pointer here, but that's fine, since 1300eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl // SemaBuiltinShuffleVector guts it, but then doesn't release it. 1314493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar case Builtin::BI__builtin_prefetch: 1320eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinPrefetch(TheCall)) 1330eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 1340eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return move(TheCallResult); 135d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar case Builtin::BI__builtin_object_size: 1360eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (SemaBuiltinObjectSize(TheCall)) 1370eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(); 138586d6a81428da2d1ce70bcb98df29d749361cbf3Eli Friedman return move(TheCallResult); 139d875fed28578835de89cd407e9db4be788596d7cEli Friedman case Builtin::BI__builtin_longjmp: 140d875fed28578835de89cd407e9db4be788596d7cEli Friedman if (SemaBuiltinLongjmp(TheCall)) 141d875fed28578835de89cd407e9db4be788596d7cEli Friedman return ExprError(); 142586d6a81428da2d1ce70bcb98df29d749361cbf3Eli Friedman return move(TheCallResult); 1435caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_add: 1445caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_sub: 1455caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_or: 1465caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_and: 1475caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_xor: 148eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_fetch_and_nand: 1495caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_add_and_fetch: 1505caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_sub_and_fetch: 1515caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_and_and_fetch: 1525caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_or_and_fetch: 1535caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_xor_and_fetch: 154eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_nand_and_fetch: 1555caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_val_compare_and_swap: 1565caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_bool_compare_and_swap: 1575caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_test_and_set: 1585caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_release: 1595caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (SemaBuiltinAtomicOverloaded(TheCall)) 1605caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return ExprError(); 1615caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return move(TheCallResult); 16271993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 163de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar 164de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // FIXME: This mechanism should be abstracted to be less fragile and 165de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // more efficient. For example, just map function ids to custom 166de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar // handlers. 167de45428f923b38d80407dbb9ede0df504256f9f6Daniel Dunbar 16859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // Printf checking. 16940b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis if (const FormatAttr *Format = FDecl->getAttr<FormatAttr>()) { 1703c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (Format->getType() == "printf") { 1713d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek bool HasVAListArg = Format->getFirstArg() == 0; 1723d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek if (!HasVAListArg) { 1733d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek if (const FunctionProtoType *Proto 1743d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek = FDecl->getType()->getAsFunctionProtoType()) 1753c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor HasVAListArg = !Proto->isVariadic(); 1763d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek } 1773c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1, 1783d692df4b9c58895f9843b03543ec57447c93679Ted Kremenek HasVAListArg ? 0 : Format->getFirstArg() - 1); 1793c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor } 18059907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner } 18140b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis for (const Attr *attr = FDecl->getAttrs(); 18268584ed35ad819a1668e3f527ba7f5dd4ae6a333Douglas Gregor attr; attr = attr->getNext()) { 183e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian if (const NonNullAttr *NonNull = dyn_cast<NonNullAttr>(attr)) 184e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian CheckNonNullArguments(NonNull, TheCall); 185e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian } 1860eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl 1870eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return move(TheCallResult); 18871993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson} 18971993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 190725165f2846bd37d3aaf863747fa30126992085eFariborz JahanianAction::OwningExprResult 191725165f2846bd37d3aaf863747fa30126992085eFariborz JahanianSema::CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall) { 192725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian 193725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian OwningExprResult TheCallResult(Owned(TheCall)); 194725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian // Printf checking. 19540b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis const FormatAttr *Format = NDecl->getAttr<FormatAttr>(); 196725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!Format) 197725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian return move(TheCallResult); 198725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian const VarDecl *V = dyn_cast<VarDecl>(NDecl); 199725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!V) 200725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian return move(TheCallResult); 201725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian QualType Ty = V->getType(); 202725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!Ty->isBlockPointerType()) 203725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian return move(TheCallResult); 204725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (Format->getType() == "printf") { 205725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian bool HasVAListArg = Format->getFirstArg() == 0; 206725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (!HasVAListArg) { 207725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian const FunctionType *FT = 208725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian Ty->getAsBlockPointerType()->getPointeeType()->getAsFunctionType(); 209725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) 210725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian HasVAListArg = !Proto->isVariadic(); 211725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian } 212725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1, 213725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian HasVAListArg ? 0 : Format->getFirstArg() - 1); 214725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian } 215725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian return move(TheCallResult); 216725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian} 217725165f2846bd37d3aaf863747fa30126992085eFariborz Jahanian 2185caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// SemaBuiltinAtomicOverloaded - We have a call to a function like 2195caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// __sync_fetch_and_add, which is an overloaded function based on the pointer 2205caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// type of its first argument. The main ActOnCallExpr routines have already 2215caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// promoted the types of arguments because all of these calls are prototyped as 2225caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// void(...). 2235caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// 2245caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// This function goes through and does final semantic checking for these 2255caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner/// builtins, 2265caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattnerbool Sema::SemaBuiltinAtomicOverloaded(CallExpr *TheCall) { 2275caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts()); 2285caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl()); 2295caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2305caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Ensure that we have at least one argument to do type inference from. 2315caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (TheCall->getNumArgs() < 1) 2325caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 2335caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << 0 << TheCall->getCallee()->getSourceRange(); 2345caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2355caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Inspect the first argument of the atomic builtin. This should always be 2365caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // a pointer type, whose element is an integral scalar or pointer type. 2375caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Because it is a pointer type, we don't have to worry about any implicit 2385caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // casts here. 2395caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *FirstArg = TheCall->getArg(0); 2405caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (!FirstArg->getType()->isPointerType()) 2415caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer) 2425caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 2435caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2445caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner QualType ValType = FirstArg->getType()->getAsPointerType()->getPointeeType(); 2455caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (!ValType->isIntegerType() && !ValType->isPointerType() && 2465caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner !ValType->isBlockPointerType()) 2475caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), 2485caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner diag::err_atomic_builtin_must_be_pointer_intptr) 2495caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 2505caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2515caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // We need to figure out which concrete builtin this maps onto. For example, 2525caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // __sync_fetch_and_add with a 2 byte object turns into 2535caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // __sync_fetch_and_add_2. 2545caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner#define BUILTIN_ROW(x) \ 2555caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \ 2565caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Builtin::BI##x##_8, Builtin::BI##x##_16 } 2575caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2585caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner static const unsigned BuiltinIndices[][5] = { 2595caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_add), 2605caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_sub), 2615caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_or), 2625caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_and), 2635caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_fetch_and_xor), 264eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BUILTIN_ROW(__sync_fetch_and_nand), 2655caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2665caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_add_and_fetch), 2675caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_sub_and_fetch), 2685caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_and_and_fetch), 2695caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_or_and_fetch), 2705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_xor_and_fetch), 271eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BUILTIN_ROW(__sync_nand_and_fetch), 2725caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2735caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_val_compare_and_swap), 2745caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_bool_compare_and_swap), 2755caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_lock_test_and_set), 2765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner BUILTIN_ROW(__sync_lock_release) 2775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner }; 2785caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner#undef BUILTIN_ROW 2795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Determine the index of the size. 2815caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned SizeIndex; 2825caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner switch (Context.getTypeSize(ValType)/8) { 2835caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 1: SizeIndex = 0; break; 2845caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 2: SizeIndex = 1; break; 2855caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 4: SizeIndex = 2; break; 2865caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 8: SizeIndex = 3; break; 2875caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case 16: SizeIndex = 4; break; 2885caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner default: 2895caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(DRE->getLocStart(), diag::err_atomic_builtin_pointer_size) 2905caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << FirstArg->getType() << FirstArg->getSourceRange(); 2915caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 2925caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 2935caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Each of these builtins has one pointer argument, followed by some number of 2945caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // values (0, 1 or 2) followed by a potentially empty varags list of stuff 2955caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // that we ignore. Find out which row of BuiltinIndices to read from as well 2965caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // as the number of fixed args. 2975caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned BuiltinID = FDecl->getBuiltinID(Context); 2985caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner unsigned BuiltinIndex, NumFixed = 1; 2995caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner switch (BuiltinID) { 3005caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner default: assert(0 && "Unknown overloaded atomic builtin!"); 3015caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_add: BuiltinIndex = 0; break; 3025caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_sub: BuiltinIndex = 1; break; 3035caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_or: BuiltinIndex = 2; break; 3045caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_and: BuiltinIndex = 3; break; 3055caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_fetch_and_xor: BuiltinIndex = 4; break; 306eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_fetch_and_nand:BuiltinIndex = 5; break; 3075caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 308eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_add_and_fetch: BuiltinIndex = 6; break; 309eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_sub_and_fetch: BuiltinIndex = 7; break; 310eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_and_and_fetch: BuiltinIndex = 8; break; 311eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_or_and_fetch: BuiltinIndex = 9; break; 312eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_xor_and_fetch: BuiltinIndex =10; break; 313eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_nand_and_fetch:BuiltinIndex =11; break; 3145caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3155caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_val_compare_and_swap: 316eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 12; 3175caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 2; 3185caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 3195caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_bool_compare_and_swap: 320eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 13; 3215caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 2; 3225caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 323eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner case Builtin::BI__sync_lock_test_and_set: BuiltinIndex = 14; break; 3245caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner case Builtin::BI__sync_lock_release: 325eebd9d2165a705ce6a8a6b6a7327864189d02785Chris Lattner BuiltinIndex = 15; 3265caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner NumFixed = 0; 3275caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner break; 3285caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 3295caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3305caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Now that we know how many fixed arguments we expect, first check that we 3315caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // have at least that many. 3325caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (TheCall->getNumArgs() < 1+NumFixed) 3335caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 3345caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner << 0 << TheCall->getCallee()->getSourceRange(); 3355caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 336e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner 337e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // Get the decl for the concrete builtin from this, we can tell what the 338e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // concrete integer type we should convert to is. 339e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex]; 340e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner const char *NewBuiltinName = Context.BuiltinInfo.GetName(NewBuiltinID); 341e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner IdentifierInfo *NewBuiltinII = PP.getIdentifierInfo(NewBuiltinName); 342e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner FunctionDecl *NewBuiltinDecl = 343e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner cast<FunctionDecl>(LazilyCreateBuiltin(NewBuiltinII, NewBuiltinID, 344e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner TUScope, false, DRE->getLocStart())); 345e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner const FunctionProtoType *BuiltinFT = 346e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner NewBuiltinDecl->getType()->getAsFunctionProtoType(); 347e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner ValType = BuiltinFT->getArgType(0)->getAsPointerType()->getPointeeType(); 348e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner 349e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner // If the first type needs to be converted (e.g. void** -> int*), do it now. 350e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner if (BuiltinFT->getArgType(0) != FirstArg->getType()) { 351e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner ImpCastExprToType(FirstArg, BuiltinFT->getArgType(0), false); 352e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner TheCall->setArg(0, FirstArg); 353e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner } 354e7ac0a94f1dee3fae9292eb8372962b6d70b3e0dChris Lattner 3555caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Next, walk the valid ones promoting to the right type. 3565caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner for (unsigned i = 0; i != NumFixed; ++i) { 3575caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *Arg = TheCall->getArg(i+1); 3585caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3595caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // If the argument is an implicit cast, then there was a promotion due to 3605caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // "...", just remove it now. 3615caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) { 3625caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Arg = ICE->getSubExpr(); 3635caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner ICE->setSubExpr(0); 3645caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner ICE->Destroy(Context); 3655caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setArg(i+1, Arg); 3665caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 3675caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3685caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // GCC does an implicit conversion to the pointer or integer ValType. This 3695caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // can fail in some cases (1i -> int**), check for this error case now. 3705caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner if (CheckCastTypes(Arg->getSourceRange(), ValType, Arg)) 3715caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return true; 3725caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3735caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Okay, we have something that *can* be converted to the right type. Check 3745caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // to see if there is a potentially weird extension going on here. This can 3755caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // happen when you do an atomic operation on something like an char* and 3765caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // pass in 42. The 42 gets converted to char. This is even more strange 3775caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // for things like 45.123 -> char, etc. 3785caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // FIXME: Do this check. 3795caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner ImpCastExprToType(Arg, ValType, false); 3805caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setArg(i+1, Arg); 3815caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner } 3825caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3835caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Switch the DeclRefExpr to refer to the new decl. 3845caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DRE->setDecl(NewBuiltinDecl); 3855caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner DRE->setType(NewBuiltinDecl->getType()); 3865caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3875caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Set the callee in the CallExpr. 3885caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // FIXME: This leaks the original parens and implicit casts. 3895caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner Expr *PromotedCall = DRE; 3905caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner UsualUnaryConversions(PromotedCall); 3915caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setCallee(PromotedCall); 3925caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3935caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3945caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner // Change the result type of the call to match the result type of the decl. 3955caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner TheCall->setType(NewBuiltinDecl->getResultType()); 3965caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner return false; 3975caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner} 3985caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 3995caa370ea6f70bd3e7e4a9cc3b69ac1a849c8534Chris Lattner 400690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattner/// CheckObjCString - Checks that the argument to the builtin 40171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson/// CFString constructor is correct 402fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// FIXME: GCC currently emits the following warning: 403fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// "warning: input conversion stopped due to an input byte that does not 404fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// belong to the input codeset UTF-8" 405fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// Note: It might also make sense to do the UTF-16 conversion here (would 406fd942628abfe30e30427875db953222ae99b4325Steve Naroff/// simplify the backend). 407690398188ea5b428f06aa13c7d4ce6eb741ad4f9Chris Lattnerbool Sema::CheckObjCString(Expr *Arg) { 40856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Arg = Arg->IgnoreParenCasts(); 40971993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson StringLiteral *Literal = dyn_cast<StringLiteral>(Arg); 41071993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 41171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!Literal || Literal->isWide()) { 412fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner Diag(Arg->getLocStart(), diag::err_cfstring_literal_not_string_constant) 413fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << Arg->getSourceRange(); 4149cdc4d3834f203dcde3ff274b8928e4620a914d5Anders Carlsson return true; 41571993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 41671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 41771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson const char *Data = Literal->getStrData(); 41871993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson unsigned Length = Literal->getByteLength(); 41971993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 42071993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson for (unsigned i = 0; i < Length; ++i) { 42171993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson if (!Data[i]) { 42260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Diag(getLocationOfStringLiteralByte(Literal, i), 423fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::warn_cfstring_literal_contains_nul_character) 424fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << Arg->getSourceRange(); 42571993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson break; 42671993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 42771993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson } 42871993dd85eed9cc42c6b2fa61ee5c53026b74817Anders Carlsson 4299cdc4d3834f203dcde3ff274b8928e4620a914d5Anders Carlsson return false; 43059907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner} 43159907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner 432c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner/// SemaBuiltinVAStart - Check the arguments to __builtin_va_start for validity. 433c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner/// Emit an error and return true on failure, return false on success. 434925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattnerbool Sema::SemaBuiltinVAStart(CallExpr *TheCall) { 435925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *Fn = TheCall->getCallee(); 436925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() > 2) { 4372c21a073525cdfa68e4439b7af551385dc2796abChris Lattner Diag(TheCall->getArg(2)->getLocStart(), 438fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_too_many_args) 4392c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ << Fn->getSourceRange() 440fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(TheCall->getArg(2)->getLocStart(), 441fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner (*(TheCall->arg_end()-1))->getLocEnd()); 44230ce344307f8a8b00054021307015571f83c7364Chris Lattner return true; 44330ce344307f8a8b00054021307015571f83c7364Chris Lattner } 44456f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman 44556f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman if (TheCall->getNumArgs() < 2) { 44656f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 44756f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman << 0 /*function call*/; 44856f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } 44956f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman 450c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner // Determine whether the current function is variadic or not. 451c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner bool isVariadic; 452cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff if (CurBlock) 453cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff isVariadic = CurBlock->isVariadic; 454cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff else if (getCurFunctionDecl()) { 45572564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor if (FunctionProtoType* FTP = 45672564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor dyn_cast<FunctionProtoType>(getCurFunctionDecl()->getType())) 45756f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman isVariadic = FTP->isVariadic(); 45856f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman else 45956f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman isVariadic = false; 46056f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } else { 46153d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis isVariadic = getCurMethodDecl()->isVariadic(); 46256f20ae1010aa71defd7572f660b41288c56cdd1Eli Friedman } 46330ce344307f8a8b00054021307015571f83c7364Chris Lattner 464c27c665c88b49dfb212aedc7bab8b9bf67658b9eChris Lattner if (!isVariadic) { 46530ce344307f8a8b00054021307015571f83c7364Chris Lattner Diag(Fn->getLocStart(), diag::err_va_start_used_in_non_variadic_function); 46630ce344307f8a8b00054021307015571f83c7364Chris Lattner return true; 46730ce344307f8a8b00054021307015571f83c7364Chris Lattner } 46830ce344307f8a8b00054021307015571f83c7364Chris Lattner 46930ce344307f8a8b00054021307015571f83c7364Chris Lattner // Verify that the second argument to the builtin is the last argument of the 47030ce344307f8a8b00054021307015571f83c7364Chris Lattner // current function or method. 47130ce344307f8a8b00054021307015571f83c7364Chris Lattner bool SecondArgIsLastNamedArgument = false; 472e2c14103dec39cbd24dac9d7b3e91277b109c14fAnders Carlsson const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts(); 47388cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson 47488cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) { 47588cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) { 47630ce344307f8a8b00054021307015571f83c7364Chris Lattner // FIXME: This isn't correct for methods (results in bogus warning). 47730ce344307f8a8b00054021307015571f83c7364Chris Lattner // Get the last formal in the current function. 47888cf226caee50956ef47edd4d44cf7b80703a26cAnders Carlsson const ParmVarDecl *LastArg; 479cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff if (CurBlock) 480cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff LastArg = *(CurBlock->TheDecl->param_end()-1); 481cd9c51433c06705645d1ee5a13da3c9a72d7d025Steve Naroff else if (FunctionDecl *FD = getCurFunctionDecl()) 482371f258e61e1365b951b17931a3c5ac1530fd1a0Chris Lattner LastArg = *(FD->param_end()-1); 48330ce344307f8a8b00054021307015571f83c7364Chris Lattner else 48453d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis LastArg = *(getCurMethodDecl()->param_end()-1); 48530ce344307f8a8b00054021307015571f83c7364Chris Lattner SecondArgIsLastNamedArgument = PV == LastArg; 48630ce344307f8a8b00054021307015571f83c7364Chris Lattner } 48730ce344307f8a8b00054021307015571f83c7364Chris Lattner } 48830ce344307f8a8b00054021307015571f83c7364Chris Lattner 48930ce344307f8a8b00054021307015571f83c7364Chris Lattner if (!SecondArgIsLastNamedArgument) 490925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Diag(TheCall->getArg(1)->getLocStart(), 49130ce344307f8a8b00054021307015571f83c7364Chris Lattner diag::warn_second_parameter_of_va_start_not_last_named_argument); 49230ce344307f8a8b00054021307015571f83c7364Chris Lattner return false; 4936cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman} 49430ce344307f8a8b00054021307015571f83c7364Chris Lattner 4951b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner/// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isgreater and 4961b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner/// friends. This is declared to take (...), so we have to check everything. 497925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattnerbool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) { 498925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() < 2) 4992c21a073525cdfa68e4439b7af551385dc2796abChris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args) 5002c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/; 501925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (TheCall->getNumArgs() > 2) 502925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner return Diag(TheCall->getArg(2)->getLocStart(), 503fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_too_many_args) 5042c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ 505fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(TheCall->getArg(2)->getLocStart(), 506fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner (*(TheCall->arg_end()-1))->getLocEnd()); 5071b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner 508925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *OrigArg0 = TheCall->getArg(0); 509925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Expr *OrigArg1 = TheCall->getArg(1); 510cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 5111b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // Do standard promotions between the two arguments, returning their common 5121b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // type. 513925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner QualType Res = UsualArithmeticConversions(OrigArg0, OrigArg1, false); 514403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar 515403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // Make sure any conversions are pushed back into the call; this is 516403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // type safe since unordered compare builtins are declared as "_Bool 517403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar // foo(...)". 518403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar TheCall->setArg(0, OrigArg0); 519403bc2bd9edffe51d73776643fa87696c9417678Daniel Dunbar TheCall->setArg(1, OrigArg1); 5201b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner 521cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (OrigArg0->isTypeDependent() || OrigArg1->isTypeDependent()) 522cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 523cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 5241b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // If the common type isn't a real floating type, then the arguments were 5251b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner // invalid for this operation. 5261b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner if (!Res->isRealFloatingType()) 527925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner return Diag(OrigArg0->getLocStart(), 528fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_typecheck_call_invalid_ordered_compare) 529d162584991885ab004a02573a73ce06422b921fcChris Lattner << OrigArg0->getType() << OrigArg1->getType() 530fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(OrigArg0->getLocStart(), OrigArg1->getLocEnd()); 5311b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner 5321b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner return false; 5331b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner} 5341b9a0793955070738cac6f04b5abe9496be9b317Chris Lattner 5356cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedmanbool Sema::SemaBuiltinStackAddress(CallExpr *TheCall) { 5366cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman // The signature for these builtins is exact; the only thing we need 5376cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman // to check is that the argument is a constant. 5386cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman SourceLocation Loc; 539cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!TheCall->getArg(0)->isTypeDependent() && 540cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(0)->isValueDependent() && 541cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(0)->isIntegerConstantExpr(Context, &Loc)) 542fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(Loc, diag::err_stack_const_level) << TheCall->getSourceRange(); 543d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner 5446cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman return false; 5456cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman} 5466cfda23b3768f93a6eb0b2a9135c8334a20125bbEli Friedman 547d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman/// SemaBuiltinShuffleVector - Handle __builtin_shufflevector. 548d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// This is declared to take (...), so we have to check everything. 5490eb23307222bda7ad95d968eac4e1ab30864b213Sebastian RedlAction::OwningExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) { 550d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman if (TheCall->getNumArgs() < 3) 5510eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocEnd(), 5520eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl diag::err_typecheck_call_too_few_args) 5530eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << 0 /*function call*/ << TheCall->getSourceRange()); 554d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 555cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor unsigned numElements = std::numeric_limits<unsigned>::max(); 556cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!TheCall->getArg(0)->isTypeDependent() && 557cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor !TheCall->getArg(1)->isTypeDependent()) { 558cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor QualType FAType = TheCall->getArg(0)->getType(); 559cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor QualType SAType = TheCall->getArg(1)->getType(); 560cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 561cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!FAType->isVectorType() || !SAType->isVectorType()) { 562cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Diag(TheCall->getLocStart(), diag::err_shufflevector_non_vector) 563cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << SourceRange(TheCall->getArg(0)->getLocStart(), 564cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(1)->getLocEnd()); 565cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(); 566cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 567cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 568cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Context.getCanonicalType(FAType).getUnqualifiedType() != 569cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Context.getCanonicalType(SAType).getUnqualifiedType()) { 570cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector) 571cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << SourceRange(TheCall->getArg(0)->getLocStart(), 572cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(1)->getLocEnd()); 573cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(); 574cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 575d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 576cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor numElements = FAType->getAsVectorType()->getNumElements(); 577cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getNumArgs() != numElements+2) { 578cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getNumArgs() < numElements+2) 579cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return ExprError(Diag(TheCall->getLocEnd(), 580cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor diag::err_typecheck_call_too_few_args) 581cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << 0 /*function call*/ << TheCall->getSourceRange()); 5820eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocEnd(), 583cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor diag::err_typecheck_call_too_many_args) 584cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << 0 /*function call*/ << TheCall->getSourceRange()); 585cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor } 586d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 587d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 588d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman for (unsigned i = 2; i < TheCall->getNumArgs(); i++) { 589cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (TheCall->getArg(i)->isTypeDependent() || 590cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor TheCall->getArg(i)->isValueDependent()) 591cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 592cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 593d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman llvm::APSInt Result(32); 594d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context)) 5950eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocStart(), 596fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_shufflevector_nonconstant_argument) 5970eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << TheCall->getArg(i)->getSourceRange()); 5980eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl 599d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner if (Result.getActiveBits() > 64 || Result.getZExtValue() >= numElements*2) 6000eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl return ExprError(Diag(TheCall->getLocStart(), 601fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner diag::err_shufflevector_argument_too_large) 6020eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl << TheCall->getArg(i)->getSourceRange()); 603d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 604d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 605d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman llvm::SmallVector<Expr*, 32> exprs; 606d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 607d1a0b6d3dfb208f638d3d750b588d9c0daa49289Chris Lattner for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) { 608d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman exprs.push_back(TheCall->getArg(i)); 609d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman TheCall->setArg(i, 0); 610d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 611d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 612cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return Owned(new (Context) ShuffleVectorExpr(exprs.begin(), exprs.size(), 613cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor exprs[0]->getType(), 6148189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek TheCall->getCallee()->getLocStart(), 6158189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek TheCall->getRParenLoc())); 616d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 61730ce344307f8a8b00054021307015571f83c7364Chris Lattner 6184493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar/// SemaBuiltinPrefetch - Handle __builtin_prefetch. 6194493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar// This is declared to take (const void*, ...) and can take two 6204493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar// optional constant int args. 6214493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbarbool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) { 622fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner unsigned NumArgs = TheCall->getNumArgs(); 6234493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 624fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner if (NumArgs > 3) 625fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_many_args) 6262c21a073525cdfa68e4439b7af551385dc2796abChris Lattner << 0 /*function call*/ << TheCall->getSourceRange(); 6274493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 6284493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // Argument 0 is checked for us and the remaining arguments must be 6294493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // constant integers. 630fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner for (unsigned i = 1; i != NumArgs; ++i) { 6314493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar Expr *Arg = TheCall->getArg(i); 632cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent()) 633cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 634cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 6354493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar QualType RWType = Arg->getType(); 6364493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 6374493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar const BuiltinType *BT = RWType->getAsBuiltinType(); 638d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar llvm::APSInt Result; 639cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!BT || BT->getKind() != BuiltinType::Int) 640fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_argument) 641fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 642cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 643cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isValueDependent()) 644cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor continue; 645cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 646cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!Arg->isIntegerConstantExpr(Result, Context)) 647cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_argument) 648cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 6494493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 6504493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // FIXME: gcc issues a warning and rewrites these to 0. These 6514493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // seems especially odd for the third argument since the default 6524493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar // is 3. 653fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner if (i == 1) { 6544493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar if (Result.getSExtValue() < 0 || Result.getSExtValue() > 1) 655fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 656fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << "0" << "1" << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 6574493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } else { 6584493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar if (Result.getSExtValue() < 0 || Result.getSExtValue() > 3) 659fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 660fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << "0" << "3" << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 6614493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } 6624493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar } 6634493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 664fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return false; 6654493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar} 6664493f79fce48cd9cbd9f55fa9d452cde736747a0Daniel Dunbar 667d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// SemaBuiltinObjectSize - Handle __builtin_object_size(void *ptr, 668d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// int type). This simply type checks that type is one of the defined 669d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar/// constants (0-3). 670d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbarbool Sema::SemaBuiltinObjectSize(CallExpr *TheCall) { 671d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar Expr *Arg = TheCall->getArg(1); 672cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent()) 673cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 674cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 675d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar QualType ArgType = Arg->getType(); 676d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar const BuiltinType *BT = ArgType->getAsBuiltinType(); 677d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar llvm::APSInt Result(32); 678cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!BT || BT->getKind() != BuiltinType::Int) 679cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument) 680cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 681cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 682cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isValueDependent()) 683cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 684cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 685cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (!Arg->isIntegerConstantExpr(Result, Context)) { 686fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument) 687fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 688d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar } 689d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 690d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar if (Result.getSExtValue() < 0 || Result.getSExtValue() > 3) { 691fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range) 692fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << "0" << "3" << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 693d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar } 694d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 695d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar return false; 696d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar} 697d5f8a4fd4d6dfb0415b93bb7ab721bba5cab1332Daniel Dunbar 698586d6a81428da2d1ce70bcb98df29d749361cbf3Eli Friedman/// SemaBuiltinLongjmp - Handle __builtin_longjmp(void *env[5], int val). 699d875fed28578835de89cd407e9db4be788596d7cEli Friedman/// This checks that val is a constant 1. 700d875fed28578835de89cd407e9db4be788596d7cEli Friedmanbool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) { 701d875fed28578835de89cd407e9db4be788596d7cEli Friedman Expr *Arg = TheCall->getArg(1); 702cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (Arg->isTypeDependent() || Arg->isValueDependent()) 703cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 704cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor 705d875fed28578835de89cd407e9db4be788596d7cEli Friedman llvm::APSInt Result(32); 706d875fed28578835de89cd407e9db4be788596d7cEli Friedman if (!Arg->isIntegerConstantExpr(Result, Context) || Result != 1) 707d875fed28578835de89cd407e9db4be788596d7cEli Friedman return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val) 708d875fed28578835de89cd407e9db4be788596d7cEli Friedman << SourceRange(Arg->getLocStart(), Arg->getLocEnd()); 709d875fed28578835de89cd407e9db4be788596d7cEli Friedman 710d875fed28578835de89cd407e9db4be788596d7cEli Friedman return false; 711d875fed28578835de89cd407e9db4be788596d7cEli Friedman} 712d875fed28578835de89cd407e9db4be788596d7cEli Friedman 713d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek// Handle i > 1 ? "x" : "y", recursivelly 714082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenekbool Sema::SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall, 715082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek bool HasVAListArg, 7163c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor unsigned format_idx, unsigned firstDataArg) { 717cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor if (E->isTypeDependent() || E->isValueDependent()) 718cde01739dffe574c53a6ba1def1a57a2cc7b4a8bDouglas Gregor return false; 719d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 720d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek switch (E->getStmtClass()) { 721d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ConditionalOperatorClass: { 722082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ConditionalOperator *C = cast<ConditionalOperator>(E); 723d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return SemaCheckStringLiteral(C->getLHS(), TheCall, 7243c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor HasVAListArg, format_idx, firstDataArg) 725d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek && SemaCheckStringLiteral(C->getRHS(), TheCall, 7263c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor HasVAListArg, format_idx, firstDataArg); 727d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 728d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 729d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ImplicitCastExprClass: { 730082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ImplicitCastExpr *Expr = cast<ImplicitCastExpr>(E); 731d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg, 7323c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor format_idx, firstDataArg); 733d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 734d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 735d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek case Stmt::ParenExprClass: { 736082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ParenExpr *Expr = cast<ParenExpr>(E); 737d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg, 7383c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor format_idx, firstDataArg); 739d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 740082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 741082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::DeclRefExprClass: { 742082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const DeclRefExpr *DR = cast<DeclRefExpr>(E); 743082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 744082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek // As an exception, do not flag errors for variables binding to 745082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek // const string literals. 746082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) { 747082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek bool isConstant = false; 748082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek QualType T = DR->getType(); 749082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 750082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const ArrayType *AT = Context.getAsArrayType(T)) { 751082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek isConstant = AT->getElementType().isConstant(Context); 752082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 753082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek else if (const PointerType *PT = T->getAsPointerType()) { 754082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek isConstant = T.isConstant(Context) && 755082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek PT->getPointeeType().isConstant(Context); 756082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 757082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 758082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (isConstant) { 759082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const VarDecl *Def = 0; 760082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const Expr *Init = VD->getDefinition(Def)) 761082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return SemaCheckStringLiteral(Init, TheCall, 762082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek HasVAListArg, format_idx, firstDataArg); 763082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 764d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson 765d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // For vprintf* functions (i.e., HasVAListArg==true), we add a 766d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // special check to see if the format string is a function parameter 767d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // of the function calling the printf function. If the function 768d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // has an attribute indicating it is a printf-like function, then we 769d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // should suppress warnings concerning non-literals being used in a call 770d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // to a vprintf function. For example: 771d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 772d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // void 773d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // logmessage(char const *fmt __attribute__ (format (printf, 1, 2)), ...){ 774d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // va_list ap; 775d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // va_start(ap, fmt); 776d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // vprintf(fmt, ap); // Do NOT emit a warning about "fmt". 777d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // ... 778d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 779d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // 780d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // FIXME: We don't have full attribute support yet, so just check to see 781d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // if the argument is a DeclRefExpr that references a parameter. We'll 782d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson // add proper support for checking the attribute later. 783d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson if (HasVAListArg) 784d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson if (isa<ParmVarDecl>(VD)) 785d966a55bccae13f34d18958877c5e71dd643a125Anders Carlsson return true; 786082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 787082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 788082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return false; 789082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek } 790d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 7918f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson case Stmt::CallExprClass: { 7928f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson const CallExpr *CE = cast<CallExpr>(E); 7938f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const ImplicitCastExpr *ICE 7948f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson = dyn_cast<ImplicitCastExpr>(CE->getCallee())) { 7958f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) { 7968f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) { 79740b598eea1310ec9ed554d56ce3e25b34c585458Argyrios Kyrtzidis if (const FormatArgAttr *FA = FD->getAttr<FormatArgAttr>()) { 7988f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson unsigned ArgIndex = FA->getFormatIdx(); 7998f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson const Expr *Arg = CE->getArg(ArgIndex - 1); 8008f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson 8018f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson return SemaCheckStringLiteral(Arg, TheCall, HasVAListArg, 8028f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson format_idx, firstDataArg); 8038f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8048f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8058f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8068f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 8078f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson 8088f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson return false; 8098f031b3b14e726b093fb8693c2be4ab6d779e331Anders Carlsson } 810082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::ObjCStringLiteralClass: 811082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek case Stmt::StringLiteralClass: { 812082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const StringLiteral *StrE = NULL; 813082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 814082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek if (const ObjCStringLiteral *ObjCFExpr = dyn_cast<ObjCStringLiteral>(E)) 815d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek StrE = ObjCFExpr->getString(); 816d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek else 817082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek StrE = cast<StringLiteral>(E); 818082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 819d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek if (StrE) { 8203c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor CheckPrintfString(StrE, E, TheCall, HasVAListArg, format_idx, 8213c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor firstDataArg); 822d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return true; 823d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 824d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 825d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek return false; 826d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 827082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 828082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek default: 829082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek return false; 830d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek } 831d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek} 832d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 833e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanianvoid 834e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz JahanianSema::CheckNonNullArguments(const NonNullAttr *NonNull, const CallExpr *TheCall) 835e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian{ 836e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian for (NonNullAttr::iterator i = NonNull->begin(), e = NonNull->end(); 837e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian i != e; ++i) { 83812b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner const Expr *ArgExpr = TheCall->getArg(*i); 839e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian if (ArgExpr->isNullPointerConstant(Context)) 84012b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner Diag(TheCall->getCallee()->getLocStart(), diag::warn_null_arg) 84112b97ff9ce1412e388444f03049bfa6ad1bb5eb9Chris Lattner << ArgExpr->getSourceRange(); 842e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian } 843e898f8a94947c6074d76ff83943b47d5bbdf210dFariborz Jahanian} 844d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 84559907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// CheckPrintfArguments - Check calls to printf (and similar functions) for 84671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// correct use of format strings. 84771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 84871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// HasVAListArg - A predicate indicating whether the printf-like 84971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// function is passed an explicit va_arg argument (e.g., vprintf) 85071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 85171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// format_idx - The index into Args for the format string. 85271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 85371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Improper format strings to functions in the printf family can be 85471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// the source of bizarre bugs and very serious security holes. A 85571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// good source of information is available in the following paper 85671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (which includes additional references): 85759907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// 85859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// FormatGuard: Automatic Protection From printf Format String 85959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner/// Vulnerabilities, Proceedings of the 10th USENIX Security Symposium, 2001. 86071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 86171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Functionality implemented: 86271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 86371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// We can statically check the following properties for string 86471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// literal format strings for non v.*printf functions (where the 86571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// arguments are passed directly): 86671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek// 86771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (1) Are the number of format conversions equal to the number of 86871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// data arguments? 86971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 87071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (2) Does each format conversion correctly match the type of the 87171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// corresponding data argument? (TODO) 87271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 87371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// Moreover, for all printf functions we can: 87471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 87571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (3) Check for a missing format string (when not caught by type checking). 87671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 87771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (4) Check for no-operation flags; e.g. using "#" with format 87871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// conversion 'c' (TODO) 87971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 88071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (5) Check the use of '%n', a major source of security holes. 88171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 88271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (6) Check for malformed format conversions that don't specify anything. 88371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 88471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (7) Check for empty format strings. e.g: printf(""); 88571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 88671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// (8) Check that the format string is a wide literal. 88771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 8886d43959ad845a43f27e00d2720f6bc3d3219d632Ted Kremenek/// (9) Also check the arguments of functions with the __format__ attribute. 8896d43959ad845a43f27e00d2720f6bc3d3219d632Ted Kremenek/// (TODO). 8906d43959ad845a43f27e00d2720f6bc3d3219d632Ted Kremenek/// 89171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// All of these checks can be done by parsing the format string. 89271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// 89371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek/// For now, we ONLY do (1), (3), (5), (6), (7), and (8). 89459907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattnervoid 895082d936a5b8323ac2c04558d8bca277a647831a3Ted KremenekSema::CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg, 8963c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor unsigned format_idx, unsigned firstDataArg) { 897082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *Fn = TheCall->getCallee(); 898925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner 89971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: printf-like function is called with no format string. 900925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (format_idx >= TheCall->getNumArgs()) { 901dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(TheCall->getRParenLoc(), diag::warn_printf_missing_format_string) 902dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << Fn->getSourceRange(); 90371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 90471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 90571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 906082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *OrigFormatExpr = TheCall->getArg(format_idx)->IgnoreParenCasts(); 907459e8488046be5df0bf57f0a8677316abf253167Chris Lattner 90859907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // CHECK: format string is not a string literal. 90959907c4d8f6fc8aacfdaa0273bd7a9c140fbb45fChris Lattner // 91071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Dynamically generated format strings are difficult to 91171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // automatically vet at compile time. Requiring that format strings 91271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // are string literals: (1) permits the checking of format strings by 91371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // the compiler and thereby (2) can practically remove the source of 91471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // many format string exploits. 9157ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek 9167ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // Format string can be either ObjC string (e.g. @"%d") or 9177ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // C string (e.g. "%d") 9187ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // ObjC string uses the same format specifiers as C string, so we can use 9197ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // the same format string checking logic for both ObjC and C strings. 9201cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner if (SemaCheckStringLiteral(OrigFormatExpr, TheCall, HasVAListArg, format_idx, 9211cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner firstDataArg)) 9221cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner return; // Literal format string found, check done! 9231cd3e1f72c3a1c256fb6a5c3d4512bca1f1b751dChris Lattner 924655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner // If there are no arguments specified, warn with -Wformat-security, otherwise 925655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner // warn only with -Wformat-nonliteral. 926655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner if (TheCall->getNumArgs() == format_idx+1) 927655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner Diag(TheCall->getArg(format_idx)->getLocStart(), 928655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner diag::warn_printf_nonliteral_noargs) 929655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner << OrigFormatExpr->getSourceRange(); 930655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner else 931655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner Diag(TheCall->getArg(format_idx)->getLocStart(), 932655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner diag::warn_printf_nonliteral) 933655f141f4d4c92eeebcc880211313e84c0a8b2f2Chris Lattner << OrigFormatExpr->getSourceRange(); 934d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek} 935d30ef87f34015d18bde20b9632032d0063d761aaTed Kremenek 936082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenekvoid Sema::CheckPrintfString(const StringLiteral *FExpr, 937082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const Expr *OrigFormatExpr, 938082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const CallExpr *TheCall, bool HasVAListArg, 939082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek unsigned format_idx, unsigned firstDataArg) { 940082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek 941082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek const ObjCStringLiteral *ObjCFExpr = 942082d936a5b8323ac2c04558d8bca277a647831a3Ted Kremenek dyn_cast<ObjCStringLiteral>(OrigFormatExpr); 94371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 94471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: is the format string a wide literal? 94571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (FExpr->isWide()) { 946925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Diag(FExpr->getLocStart(), 947dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner diag::warn_printf_format_string_is_wide_literal) 948dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 94971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 95071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 95171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 95271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Str - The format string. NOTE: this is NOT null-terminated! 953b9fc856696defc78750fdb4977c4dce34307a7f1Chris Lattner const char *Str = FExpr->getStrData(); 95471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 95571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: empty format string? 956b9fc856696defc78750fdb4977c4dce34307a7f1Chris Lattner unsigned StrLen = FExpr->getByteLength(); 95771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 95871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (StrLen == 0) { 959dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(FExpr->getLocStart(), diag::warn_printf_empty_format_string) 960dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 96171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 96271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 96371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 96471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // We process the format string using a binary state machine. The 96571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // current state is stored in CurrentState. 96671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek enum { 96771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek state_OrdChr, 96871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek state_Conversion 96971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } CurrentState = state_OrdChr; 97071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 97171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // numConversions - The number of conversions seen so far. This is 97271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // incremented as we traverse the format string. 97371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek unsigned numConversions = 0; 97471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 97571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // numDataArgs - The number of data arguments after the format 97671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // string. This can only be determined for non vprintf-like 97771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // functions. For those functions, this value is 1 (the sole 97871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // va_arg argument). 9793c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor unsigned numDataArgs = TheCall->getNumArgs()-firstDataArg; 98071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 98171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Inspect the format string. 98271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek unsigned StrIdx = 0; 98371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 98471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // LastConversionIdx - Index within the format string where we last saw 98571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // a '%' character that starts a new format conversion. 98671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek unsigned LastConversionIdx = 0; 98771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 988925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner for (; StrIdx < StrLen; ++StrIdx) { 989998568f24d6665b8a9bf26b42a04e5f80d14668fChris Lattner 99071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Is the number of detected conversion conversions greater than 99171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // the number of matching data arguments? If so, stop. 99271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (!HasVAListArg && numConversions > numDataArgs) break; 99371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 99471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Handle "\0" 995925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner if (Str[StrIdx] == '\0') { 99671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // The string returned by getStrData() is not null-terminated, 99771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // so the presence of a null character is likely an error. 99860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner Diag(getLocationOfStringLiteralByte(FExpr, StrIdx), 999dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner diag::warn_printf_format_string_contains_null_char) 1000dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 100171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 100271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 100371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 100471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Ordinary characters (not processing a format conversion). 100571895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (CurrentState == state_OrdChr) { 100671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (Str[StrIdx] == '%') { 100771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek CurrentState = state_Conversion; 100871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek LastConversionIdx = StrIdx; 100971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 101071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek continue; 101171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 101271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 101371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Seen '%'. Now processing a format conversion. 101471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek switch (Str[StrIdx]) { 1015fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle dynamic precision or width specifier. 1016fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case '*': { 1017fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ++numConversions; 1018fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 101942ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (!HasVAListArg) { 102042ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (numConversions > numDataArgs) { 102142ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek SourceLocation Loc = getLocationOfStringLiteralByte(FExpr, StrIdx); 102242ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek 102342ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (Str[StrIdx-1] == '.') 102442ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek Diag(Loc, diag::warn_printf_asterisk_precision_missing_arg) 102542ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek << OrigFormatExpr->getSourceRange(); 102642ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek else 102742ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek Diag(Loc, diag::warn_printf_asterisk_width_missing_arg) 102842ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek << OrigFormatExpr->getSourceRange(); 102942ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek 103042ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek // Don't do any more checking. We'll just emit spurious errors. 103142ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek return; 103242ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek } 103342ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek 103442ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek // Perform type checking on width/precision specifier. 103542ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek const Expr *E = TheCall->getArg(format_idx+numConversions); 103642ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (const BuiltinType *BT = E->getType()->getAsBuiltinType()) 103742ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek if (BT->getKind() == BuiltinType::Int) 103842ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek break; 103942ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek 104060800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = getLocationOfStringLiteralByte(FExpr, StrIdx); 104142ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek 1042580b664e9c2acd3bffddfea79b1ce2863cfd9dd0Ted Kremenek if (Str[StrIdx-1] == '.') 104342ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek Diag(Loc, diag::warn_printf_asterisk_precision_wrong_type) 104442ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek << E->getType() << E->getSourceRange(); 1045580b664e9c2acd3bffddfea79b1ce2863cfd9dd0Ted Kremenek else 104642ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek Diag(Loc, diag::warn_printf_asterisk_width_wrong_type) 104742ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek << E->getType() << E->getSourceRange(); 1048580b664e9c2acd3bffddfea79b1ce2863cfd9dd0Ted Kremenek 104942ae3e81a811362c0bf78deb71b72455aadff772Ted Kremenek break; 1050580b664e9c2acd3bffddfea79b1ce2863cfd9dd0Ted Kremenek } 1051fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 1052fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1053fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Characters which can terminate a format conversion 1054fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // (e.g. "%d"). Characters that specify length modifiers or 1055fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // other flags are handled by the default case below. 1056fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // 1057fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // FIXME: additional checks will go into the following cases. 1058fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'i': 1059fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'd': 1060fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'o': 1061fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'u': 1062fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'x': 1063fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'X': 1064fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'D': 1065fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'O': 1066fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'U': 1067fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'e': 1068fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'E': 1069fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'f': 1070fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'F': 1071fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'g': 1072fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'G': 1073fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'a': 1074fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'A': 1075fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'c': 1076fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'C': 1077fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'S': 1078fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 's': 1079fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'p': 1080fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ++numConversions; 1081fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner CurrentState = state_OrdChr; 1082fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner break; 108371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 1084b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman case 'm': 1085b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman // FIXME: Warn in situations where this isn't supported! 1086b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman CurrentState = state_OrdChr; 1087b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman break; 1088b92abb460be254fe577ccb95355ff7debf6a7719Eli Friedman 1089fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // CHECK: Are we using "%n"? Issue a warning. 1090fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case 'n': { 1091fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ++numConversions; 1092fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner CurrentState = state_OrdChr; 109360800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = getLocationOfStringLiteralByte(FExpr, 109460800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner LastConversionIdx); 1095fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1096dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(Loc, diag::warn_printf_write_back)<<OrigFormatExpr->getSourceRange(); 1097fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner break; 1098fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 10997ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek 11007ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // Handle "%@" 11017ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek case '@': 11027ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // %@ is allowed in ObjC format strings only. 11037ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek if(ObjCFExpr != NULL) 11047ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek CurrentState = state_OrdChr; 11057ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek else { 11067ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek // Issue a warning: invalid format conversion. 110760800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = 110860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner getLocationOfStringLiteralByte(FExpr, LastConversionIdx); 11097ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek 1110d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Diag(Loc, diag::warn_printf_invalid_conversion) 1111d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << std::string(Str+LastConversionIdx, 1112d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Str+std::min(LastConversionIdx+2, StrLen)) 1113d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << OrigFormatExpr->getSourceRange(); 11147ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek } 11157ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek ++numConversions; 11167ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek break; 11177ff22b259d4d4729f701679e3a7f0e242365e07fTed Kremenek 1118fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle "%%" 1119fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case '%': 1120fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Sanity check: Was the first "%" character the previous one? 1121fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // If not, we will assume that we have a malformed format 1122fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // conversion, and that the current "%" character is the start 1123fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // of a new conversion. 1124fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (StrIdx - LastConversionIdx == 1) 1125fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner CurrentState = state_OrdChr; 1126fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else { 1127fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Issue a warning: invalid format conversion. 112860800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = 112960800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner getLocationOfStringLiteralByte(FExpr, LastConversionIdx); 1130fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1131d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Diag(Loc, diag::warn_printf_invalid_conversion) 1132d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << std::string(Str+LastConversionIdx, Str+StrIdx) 1133d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << OrigFormatExpr->getSourceRange(); 1134fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1135fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // This conversion is broken. Advance to the next format 1136fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // conversion. 1137fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner LastConversionIdx = StrIdx; 1138fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ++numConversions; 113971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 1140fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner break; 114171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 1142fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner default: 1143fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // This case catches all other characters: flags, widths, etc. 1144fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // We should eventually process those as well. 1145fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner break; 114671895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 114771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 114871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 114971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (CurrentState == state_Conversion) { 115071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // Issue a warning: invalid format conversion. 115160800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = 115260800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner getLocationOfStringLiteralByte(FExpr, LastConversionIdx); 115371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 1154d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Diag(Loc, diag::warn_printf_invalid_conversion) 1155d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << std::string(Str+LastConversionIdx, 1156d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner Str+std::min(LastConversionIdx+2, StrLen)) 1157d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner << OrigFormatExpr->getSourceRange(); 115871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek return; 115971895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 116071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 116171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (!HasVAListArg) { 116271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: Does the number of format conversions exceed the number 116371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // of data arguments? 116471895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek if (numConversions > numDataArgs) { 116560800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner SourceLocation Loc = 116660800081361b0ffc114877b8abbc81cb57b4edf6Chris Lattner getLocationOfStringLiteralByte(FExpr, LastConversionIdx); 116771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek 1168dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(Loc, diag::warn_printf_insufficient_data_args) 1169dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 117071895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 117171895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // CHECK: Does the number of data arguments exceed the number of 117271895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek // format conversions in the format string? 117371895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek else if (numConversions < numDataArgs) 1174925e60d3fa706f31886027c876989af79eb0e0d2Chris Lattner Diag(TheCall->getArg(format_idx+numConversions+1)->getLocStart(), 1175dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner diag::warn_printf_too_many_data_args) 1176dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << OrigFormatExpr->getSourceRange(); 117771895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek } 117871895b9aa3ad71957359497e136b50fcb6136bdfTed Kremenek} 117906de276fff91264437fa75111ed76de43097e089Ted Kremenek 118006de276fff91264437fa75111ed76de43097e089Ted Kremenek//===--- CHECK: Return Address of Stack Variable --------------------------===// 118106de276fff91264437fa75111ed76de43097e089Ted Kremenek 118206de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalVal(Expr *E); 118306de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalAddr(Expr* E); 118406de276fff91264437fa75111ed76de43097e089Ted Kremenek 118506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// CheckReturnStackAddr - Check if a return statement returns the address 118606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// of a stack variable. 118706de276fff91264437fa75111ed76de43097e089Ted Kremenekvoid 118806de276fff91264437fa75111ed76de43097e089Ted KremenekSema::CheckReturnStackAddr(Expr *RetValExp, QualType lhsType, 118906de276fff91264437fa75111ed76de43097e089Ted Kremenek SourceLocation ReturnLoc) { 119056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 119106de276fff91264437fa75111ed76de43097e089Ted Kremenek // Perform checking for returned stack addresses. 1192dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (lhsType->isPointerType() || lhsType->isBlockPointerType()) { 119306de276fff91264437fa75111ed76de43097e089Ted Kremenek if (DeclRefExpr *DR = EvalAddr(RetValExp)) 11943c73c41cefcfe76f36b7bed72c9f1ec195490951Chris Lattner Diag(DR->getLocStart(), diag::warn_ret_stack_addr) 119508631c5fa053867146b5ee8be658c229f6bf127cChris Lattner << DR->getDecl()->getDeclName() << RetValExp->getSourceRange(); 1196c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff 1197c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff // Skip over implicit cast expressions when checking for block expressions. 1198c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff if (ImplicitCastExpr *IcExpr = 1199c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff dyn_cast_or_null<ImplicitCastExpr>(RetValExp)) 1200c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff RetValExp = IcExpr->getSubExpr(); 1201c50a4a5f2eac14ac4c631d50b0a55cadc87700ceSteve Naroff 120261f40a2b67fc2046768e14f66b617e564cbcc3d8Steve Naroff if (BlockExpr *C = dyn_cast_or_null<BlockExpr>(RetValExp)) 1203397195bf3077fb42789b326f69f7d417227a0588Mike Stump if (C->hasBlockDeclRefExprs()) 1204397195bf3077fb42789b326f69f7d417227a0588Mike Stump Diag(C->getLocStart(), diag::err_ret_local_block) 1205397195bf3077fb42789b326f69f7d417227a0588Mike Stump << C->getSourceRange(); 120606de276fff91264437fa75111ed76de43097e089Ted Kremenek } 120706de276fff91264437fa75111ed76de43097e089Ted Kremenek // Perform checking for stack values returned by reference. 120806de276fff91264437fa75111ed76de43097e089Ted Kremenek else if (lhsType->isReferenceType()) { 120949badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // Check for a reference to the stack 121049badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor if (DeclRefExpr *DR = EvalVal(RetValExp)) 1211dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner Diag(DR->getLocStart(), diag::warn_ret_stack_ref) 121208631c5fa053867146b5ee8be658c229f6bf127cChris Lattner << DR->getDecl()->getDeclName() << RetValExp->getSourceRange(); 121306de276fff91264437fa75111ed76de43097e089Ted Kremenek } 121406de276fff91264437fa75111ed76de43097e089Ted Kremenek} 121506de276fff91264437fa75111ed76de43097e089Ted Kremenek 121606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// EvalAddr - EvalAddr and EvalVal are mutually recursive functions that 121706de276fff91264437fa75111ed76de43097e089Ted Kremenek/// check if the expression in a return statement evaluates to an address 121806de276fff91264437fa75111ed76de43097e089Ted Kremenek/// to a location on the stack. The recursion is used to traverse the 121906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// AST of the return expression, with recursion backtracking when we 122006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// encounter a subexpression that (1) clearly does not lead to the address 122106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// of a stack variable or (2) is something we cannot determine leads to 122206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// the address of a stack variable based on such local checking. 122306de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 1224e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek/// EvalAddr processes expressions that are pointers that are used as 1225e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek/// references (and not L-values). EvalVal handles all other values. 122606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// At the base case of the recursion is a check for a DeclRefExpr* in 122706de276fff91264437fa75111ed76de43097e089Ted Kremenek/// the refers to a stack variable. 122806de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 122906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// This implementation handles: 123006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// 123106de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * pointer-to-pointer casts 123206de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * implicit conversions from array references to pointers 123306de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * taking the address of fields 123406de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * arbitrary interplay between "&" and "*" operators 123506de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * pointer arithmetic from an address of a stack variable 123606de276fff91264437fa75111ed76de43097e089Ted Kremenek/// * taking the address of an array element where the array is on the stack 123706de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalAddr(Expr *E) { 123806de276fff91264437fa75111ed76de43097e089Ted Kremenek // We should only be called for evaluating pointer expressions. 1239dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff assert((E->getType()->isPointerType() || 1240dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff E->getType()->isBlockPointerType() || 1241a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek E->getType()->isObjCQualifiedIdType()) && 1242fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner "EvalAddr only works on pointers"); 124306de276fff91264437fa75111ed76de43097e089Ted Kremenek 124406de276fff91264437fa75111ed76de43097e089Ted Kremenek // Our "symbolic interpreter" is just a dispatch off the currently 124506de276fff91264437fa75111ed76de43097e089Ted Kremenek // viewed AST node. We then recursively traverse the AST by calling 124606de276fff91264437fa75111ed76de43097e089Ted Kremenek // EvalAddr and EvalVal appropriately. 124706de276fff91264437fa75111ed76de43097e089Ted Kremenek switch (E->getStmtClass()) { 1248fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::ParenExprClass: 1249fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Ignore parentheses. 1250fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(cast<ParenExpr>(E)->getSubExpr()); 125106de276fff91264437fa75111ed76de43097e089Ted Kremenek 1252fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::UnaryOperatorClass: { 1253fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // The only unary operator that make sense to handle here 1254fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // is AddrOf. All others don't make sense as pointers. 1255fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner UnaryOperator *U = cast<UnaryOperator>(E); 125606de276fff91264437fa75111ed76de43097e089Ted Kremenek 1257fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (U->getOpcode() == UnaryOperator::AddrOf) 1258fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalVal(U->getSubExpr()); 1259fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else 1260fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 1261fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 1262fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1263fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::BinaryOperatorClass: { 1264fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle pointer arithmetic. All other binary operators are not valid 1265fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // in this context. 1266fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner BinaryOperator *B = cast<BinaryOperator>(E); 1267fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner BinaryOperator::Opcode op = B->getOpcode(); 126806de276fff91264437fa75111ed76de43097e089Ted Kremenek 1269fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (op != BinaryOperator::Add && op != BinaryOperator::Sub) 1270fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 127106de276fff91264437fa75111ed76de43097e089Ted Kremenek 1272fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner Expr *Base = B->getLHS(); 12733907323dd6665c0c4e383435cb145233f4533406Anders Carlsson 1274fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Determine which argument is the real pointer base. It could be 1275fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // the RHS argument instead of the LHS. 1276fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (!Base->getType()->isPointerType()) Base = B->getRHS(); 127706de276fff91264437fa75111ed76de43097e089Ted Kremenek 1278fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner assert (Base->getType()->isPointerType()); 1279fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(Base); 1280fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 128161f40a2b67fc2046768e14f66b617e564cbcc3d8Steve Naroff 1282fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // For conditional operators we need to see if either the LHS or RHS are 1283fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // valid DeclRefExpr*s. If one of them is valid, we return it. 1284fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner case Stmt::ConditionalOperatorClass: { 1285fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner ConditionalOperator *C = cast<ConditionalOperator>(E); 1286fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1287fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Handle the GNU extension for missing LHS. 1288fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (Expr *lhsExpr = C->getLHS()) 1289fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner if (DeclRefExpr* LHS = EvalAddr(lhsExpr)) 1290fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return LHS; 129106de276fff91264437fa75111ed76de43097e089Ted Kremenek 1292fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(C->getRHS()); 1293fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 1294fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 129554b5274f2c190331438375ad114dad12ae098b57Ted Kremenek // For casts, we need to handle conversions from arrays to 129654b5274f2c190331438375ad114dad12ae098b57Ted Kremenek // pointer values, and pointer-to-pointer conversions. 129749badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::ImplicitCastExprClass: 12986eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case Stmt::CStyleCastExprClass: 129949badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXFunctionalCastExprClass: { 13000835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis Expr* SubExpr = cast<CastExpr>(E)->getSubExpr(); 130154b5274f2c190331438375ad114dad12ae098b57Ted Kremenek QualType T = SubExpr->getType(); 1302fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1303dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (SubExpr->getType()->isPointerType() || 1304dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff SubExpr->getType()->isBlockPointerType() || 1305dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff SubExpr->getType()->isObjCQualifiedIdType()) 1306fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(SubExpr); 130754b5274f2c190331438375ad114dad12ae098b57Ted Kremenek else if (T->isArrayType()) 130854b5274f2c190331438375ad114dad12ae098b57Ted Kremenek return EvalVal(SubExpr); 1309fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner else 131054b5274f2c190331438375ad114dad12ae098b57Ted Kremenek return 0; 1311fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 1312fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1313fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // C++ casts. For dynamic casts, static casts, and const casts, we 1314fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // are always converting from a pointer-to-pointer, so we just blow 131549badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // through the cast. In the case the dynamic cast doesn't fail (and 131649badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // return NULL), we take the conservative route and report cases 1317fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // where we return the address of a stack variable. For Reinterpre 131849badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // FIXME: The comment about is wrong; we're not always converting 131949badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // from pointer to pointer. I'm guessing that this code should also 132049badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor // handle references to objects. 132149badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXStaticCastExprClass: 132249badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXDynamicCastExprClass: 132349badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXConstCastExprClass: 132449badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor case Stmt::CXXReinterpretCastExprClass: { 132549badde06e066d058d6c7fcf4e628a72999b65a9Douglas Gregor Expr *S = cast<CXXNamedCastExpr>(E)->getSubExpr(); 1326dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff if (S->getType()->isPointerType() || S->getType()->isBlockPointerType()) 1327fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return EvalAddr(S); 132806de276fff91264437fa75111ed76de43097e089Ted Kremenek else 132906de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 1330fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner } 1331fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner 1332fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner // Everything else: we simply don't reason about them. 1333fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner default: 1334fae3f1f6565c74d3238747b58357a6e56fbb0e9cChris Lattner return NULL; 133506de276fff91264437fa75111ed76de43097e089Ted Kremenek } 133606de276fff91264437fa75111ed76de43097e089Ted Kremenek} 133706de276fff91264437fa75111ed76de43097e089Ted Kremenek 133806de276fff91264437fa75111ed76de43097e089Ted Kremenek 133906de276fff91264437fa75111ed76de43097e089Ted Kremenek/// EvalVal - This function is complements EvalAddr in the mutual recursion. 134006de276fff91264437fa75111ed76de43097e089Ted Kremenek/// See the comments for EvalAddr for more details. 134106de276fff91264437fa75111ed76de43097e089Ted Kremenekstatic DeclRefExpr* EvalVal(Expr *E) { 134206de276fff91264437fa75111ed76de43097e089Ted Kremenek 1343e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // We should only be called for evaluating non-pointer expressions, or 1344e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // expressions with a pointer type that are not used as references but instead 1345e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek // are l-values (e.g., DeclRefExpr with a pointer type). 1346e8c600f9fedf2cfd69cdd2cb4bde4a9b39ce2873Ted Kremenek 134706de276fff91264437fa75111ed76de43097e089Ted Kremenek // Our "symbolic interpreter" is just a dispatch off the currently 134806de276fff91264437fa75111ed76de43097e089Ted Kremenek // viewed AST node. We then recursively traverse the AST by calling 134906de276fff91264437fa75111ed76de43097e089Ted Kremenek // EvalAddr and EvalVal appropriately. 135006de276fff91264437fa75111ed76de43097e089Ted Kremenek switch (E->getStmtClass()) { 13511a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case Stmt::DeclRefExprClass: 13521a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case Stmt::QualifiedDeclRefExprClass: { 135306de276fff91264437fa75111ed76de43097e089Ted Kremenek // DeclRefExpr: the base case. When we hit a DeclRefExpr we are looking 135406de276fff91264437fa75111ed76de43097e089Ted Kremenek // at code that refers to a variable's name. We check if it has local 135506de276fff91264437fa75111ed76de43097e089Ted Kremenek // storage within the function, and if so, return the expression. 135606de276fff91264437fa75111ed76de43097e089Ted Kremenek DeclRefExpr *DR = cast<DeclRefExpr>(E); 135706de276fff91264437fa75111ed76de43097e089Ted Kremenek 135806de276fff91264437fa75111ed76de43097e089Ted Kremenek if (VarDecl *V = dyn_cast<VarDecl>(DR->getDecl())) 135927c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor if(V->hasLocalStorage() && !V->getType()->isReferenceType()) return DR; 136006de276fff91264437fa75111ed76de43097e089Ted Kremenek 136106de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 136206de276fff91264437fa75111ed76de43097e089Ted Kremenek } 136306de276fff91264437fa75111ed76de43097e089Ted Kremenek 136406de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ParenExprClass: 136506de276fff91264437fa75111ed76de43097e089Ted Kremenek // Ignore parentheses. 136606de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalVal(cast<ParenExpr>(E)->getSubExpr()); 136706de276fff91264437fa75111ed76de43097e089Ted Kremenek 136806de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::UnaryOperatorClass: { 136906de276fff91264437fa75111ed76de43097e089Ted Kremenek // The only unary operator that make sense to handle here 137006de276fff91264437fa75111ed76de43097e089Ted Kremenek // is Deref. All others don't resolve to a "name." This includes 137106de276fff91264437fa75111ed76de43097e089Ted Kremenek // handling all sorts of rvalues passed to a unary operator. 137206de276fff91264437fa75111ed76de43097e089Ted Kremenek UnaryOperator *U = cast<UnaryOperator>(E); 137306de276fff91264437fa75111ed76de43097e089Ted Kremenek 137406de276fff91264437fa75111ed76de43097e089Ted Kremenek if (U->getOpcode() == UnaryOperator::Deref) 137506de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalAddr(U->getSubExpr()); 137606de276fff91264437fa75111ed76de43097e089Ted Kremenek 137706de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 137806de276fff91264437fa75111ed76de43097e089Ted Kremenek } 137906de276fff91264437fa75111ed76de43097e089Ted Kremenek 138006de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ArraySubscriptExprClass: { 138106de276fff91264437fa75111ed76de43097e089Ted Kremenek // Array subscripts are potential references to data on the stack. We 138206de276fff91264437fa75111ed76de43097e089Ted Kremenek // retrieve the DeclRefExpr* for the array variable if it indeed 138306de276fff91264437fa75111ed76de43097e089Ted Kremenek // has local storage. 13842324512285caac0332bbbc6e4cab6245d2a370a1Ted Kremenek return EvalAddr(cast<ArraySubscriptExpr>(E)->getBase()); 138506de276fff91264437fa75111ed76de43097e089Ted Kremenek } 138606de276fff91264437fa75111ed76de43097e089Ted Kremenek 138706de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::ConditionalOperatorClass: { 138806de276fff91264437fa75111ed76de43097e089Ted Kremenek // For conditional operators we need to see if either the LHS or RHS are 138906de276fff91264437fa75111ed76de43097e089Ted Kremenek // non-NULL DeclRefExpr's. If one is non-NULL, we return it. 139006de276fff91264437fa75111ed76de43097e089Ted Kremenek ConditionalOperator *C = cast<ConditionalOperator>(E); 139106de276fff91264437fa75111ed76de43097e089Ted Kremenek 13923907323dd6665c0c4e383435cb145233f4533406Anders Carlsson // Handle the GNU extension for missing LHS. 13933907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (Expr *lhsExpr = C->getLHS()) 13943907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (DeclRefExpr *LHS = EvalVal(lhsExpr)) 13953907323dd6665c0c4e383435cb145233f4533406Anders Carlsson return LHS; 13963907323dd6665c0c4e383435cb145233f4533406Anders Carlsson 13973907323dd6665c0c4e383435cb145233f4533406Anders Carlsson return EvalVal(C->getRHS()); 139806de276fff91264437fa75111ed76de43097e089Ted Kremenek } 139906de276fff91264437fa75111ed76de43097e089Ted Kremenek 140006de276fff91264437fa75111ed76de43097e089Ted Kremenek // Accesses to members are potential references to data on the stack. 140106de276fff91264437fa75111ed76de43097e089Ted Kremenek case Stmt::MemberExprClass: { 140206de276fff91264437fa75111ed76de43097e089Ted Kremenek MemberExpr *M = cast<MemberExpr>(E); 140306de276fff91264437fa75111ed76de43097e089Ted Kremenek 140406de276fff91264437fa75111ed76de43097e089Ted Kremenek // Check for indirect access. We only want direct field accesses. 140506de276fff91264437fa75111ed76de43097e089Ted Kremenek if (!M->isArrow()) 140606de276fff91264437fa75111ed76de43097e089Ted Kremenek return EvalVal(M->getBase()); 140706de276fff91264437fa75111ed76de43097e089Ted Kremenek else 140806de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 140906de276fff91264437fa75111ed76de43097e089Ted Kremenek } 141006de276fff91264437fa75111ed76de43097e089Ted Kremenek 141106de276fff91264437fa75111ed76de43097e089Ted Kremenek // Everything else: we simply don't reason about them. 141206de276fff91264437fa75111ed76de43097e089Ted Kremenek default: 141306de276fff91264437fa75111ed76de43097e089Ted Kremenek return NULL; 141406de276fff91264437fa75111ed76de43097e089Ted Kremenek } 141506de276fff91264437fa75111ed76de43097e089Ted Kremenek} 1416588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1417588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek//===--- CHECK: Floating-Point comparisons (-Wfloat-equal) ---------------===// 1418588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1419588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// Check for comparisons of floating point operands using != and ==. 1420588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// Issue a warning if these are no self-comparisons, as they are not likely 1421588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek/// to do what the programmer intended. 1422588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenekvoid Sema::CheckFloatComparison(SourceLocation loc, Expr* lex, Expr *rex) { 1423588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek bool EmitWarning = true; 1424588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 14254e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* LeftExprSansParen = lex->IgnoreParens(); 142632e97b66bbce16c9e81c877794fb7a0aeeb66ccbTed Kremenek Expr* RightExprSansParen = rex->IgnoreParens(); 1427588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1428588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Special case: check for x == x (which is OK). 1429588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Do not emit warnings for such cases. 1430588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen)) 1431588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RightExprSansParen)) 1432588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (DRL->getDecl() == DRR->getDecl()) 1433588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 1434588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 14351b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek 14361b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // Special case: check for comparisons against literals that can be exactly 14371b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // represented by APFloat. In such cases, do not emit a warning. This 14381b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // is a heuristic: often comparison against such literals are used to 14391b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // detect if a value in a variable has not changed. This clearly can 14401b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek // lead to false negatives. 14411b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (EmitWarning) { 14421b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) { 14431b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FLL->isExact()) 14441b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek EmitWarning = false; 14451b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 14461b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek else 14471b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen)){ 14481b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek if (FLR->isExact()) 14491b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek EmitWarning = false; 14501b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 14511b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek } 14521b500bb0d40aa3ebf1ace47340bb5f401a9ae99cTed Kremenek 1453588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Check for comparisons with builtin types. 14540eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (EmitWarning) 1455588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen)) 14563c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CL->isBuiltinCall(Context)) 1457588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 1458588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 14590eb23307222bda7ad95d968eac4e1ab30864b213Sebastian Redl if (EmitWarning) 1460588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen)) 14613c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CR->isBuiltinCall(Context)) 1462588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek EmitWarning = false; 1463588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek 1464588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek // Emit the diagnostic. 1465588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek if (EmitWarning) 1466fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner Diag(loc, diag::warn_floatingpoint_eq) 1467fa25bbb351f4fdd977f51254119cdfc2b525ce90Chris Lattner << lex->getSourceRange() << rex->getSourceRange(); 1468588e5ebee2db045c3611e0c8f601bc4495ebd0f3Ted Kremenek} 1469