blob: 0a33485dd7777e931240147e8a915e22d7c46ecc [file] [log] [blame]
Chris Lattner59907c42007-08-10 20:18:51 +00001//===--- SemaChecking.cpp - Extra Semantic Checking -----------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner59907c42007-08-10 20:18:51 +00007//
8//===----------------------------------------------------------------------===//
9//
Mike Stump1eb44332009-09-09 15:08:12 +000010// This file implements extra semantic analysis beyond what is enforced
Chris Lattner59907c42007-08-10 20:18:51 +000011// by the C type system.
12//
13//===----------------------------------------------------------------------===//
14
15#include "Sema.h"
Ted Kremeneke0e53132010-01-28 23:39:18 +000016#include "clang/Analysis/Analyses/PrintfFormatString.h"
Chris Lattner59907c42007-08-10 20:18:51 +000017#include "clang/AST/ASTContext.h"
Ken Dyck199c3d62010-01-11 17:06:35 +000018#include "clang/AST/CharUnits.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000019#include "clang/AST/DeclObjC.h"
Ted Kremenek23245122007-08-20 16:18:38 +000020#include "clang/AST/ExprCXX.h"
Ted Kremenek7ff22b22008-06-16 18:00:42 +000021#include "clang/AST/ExprObjC.h"
Mike Stumpf8c49212010-01-21 03:59:47 +000022#include "clang/AST/DeclObjC.h"
23#include "clang/AST/StmtCXX.h"
24#include "clang/AST/StmtObjC.h"
Chris Lattner719e6152009-02-18 19:21:10 +000025#include "clang/Lex/LiteralSupport.h"
Chris Lattner59907c42007-08-10 20:18:51 +000026#include "clang/Lex/Preprocessor.h"
Mike Stumpf8c49212010-01-21 03:59:47 +000027#include "llvm/ADT/BitVector.h"
28#include "llvm/ADT/STLExtras.h"
Zhongxing Xua1f3dba2009-05-20 01:55:10 +000029#include <limits>
Chris Lattner59907c42007-08-10 20:18:51 +000030using namespace clang;
31
Chris Lattner60800082009-02-18 17:49:48 +000032/// getLocationOfStringLiteralByte - Return a source location that points to the
33/// specified byte of the specified string literal.
34///
35/// Strings are amazingly complex. They can be formed from multiple tokens and
36/// can have escape sequences in them in addition to the usual trigraph and
37/// escaped newline business. This routine handles this complexity.
38///
39SourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL,
40 unsigned ByteNo) const {
41 assert(!SL->isWide() && "This doesn't work for wide strings yet");
Mike Stump1eb44332009-09-09 15:08:12 +000042
Chris Lattner60800082009-02-18 17:49:48 +000043 // Loop over all of the tokens in this string until we find the one that
44 // contains the byte we're looking for.
45 unsigned TokNo = 0;
46 while (1) {
47 assert(TokNo < SL->getNumConcatenated() && "Invalid byte number!");
48 SourceLocation StrTokLoc = SL->getStrTokenLoc(TokNo);
Mike Stump1eb44332009-09-09 15:08:12 +000049
Chris Lattner60800082009-02-18 17:49:48 +000050 // Get the spelling of the string so that we can get the data that makes up
51 // the string literal, not the identifier for the macro it is potentially
52 // expanded through.
53 SourceLocation StrTokSpellingLoc = SourceMgr.getSpellingLoc(StrTokLoc);
54
55 // Re-lex the token to get its length and original spelling.
56 std::pair<FileID, unsigned> LocInfo =
57 SourceMgr.getDecomposedLoc(StrTokSpellingLoc);
Douglas Gregorf715ca12010-03-16 00:06:06 +000058 bool Invalid = false;
Benjamin Kramerf6ac97b2010-03-16 14:14:31 +000059 llvm::StringRef Buffer = SourceMgr.getBufferData(LocInfo.first, &Invalid);
Douglas Gregorf715ca12010-03-16 00:06:06 +000060 if (Invalid)
Douglas Gregoraea67db2010-03-15 22:54:52 +000061 return StrTokSpellingLoc;
62
Benjamin Kramerf6ac97b2010-03-16 14:14:31 +000063 const char *StrData = Buffer.data()+LocInfo.second;
Mike Stump1eb44332009-09-09 15:08:12 +000064
Chris Lattner60800082009-02-18 17:49:48 +000065 // Create a langops struct and enable trigraphs. This is sufficient for
66 // relexing tokens.
67 LangOptions LangOpts;
68 LangOpts.Trigraphs = true;
Mike Stump1eb44332009-09-09 15:08:12 +000069
Chris Lattner60800082009-02-18 17:49:48 +000070 // Create a lexer starting at the beginning of this token.
Benjamin Kramerf6ac97b2010-03-16 14:14:31 +000071 Lexer TheLexer(StrTokSpellingLoc, LangOpts, Buffer.begin(), StrData,
72 Buffer.end());
Chris Lattner60800082009-02-18 17:49:48 +000073 Token TheTok;
74 TheLexer.LexFromRawLexer(TheTok);
Mike Stump1eb44332009-09-09 15:08:12 +000075
Chris Lattner443e53c2009-02-18 19:26:42 +000076 // Use the StringLiteralParser to compute the length of the string in bytes.
77 StringLiteralParser SLP(&TheTok, 1, PP);
78 unsigned TokNumBytes = SLP.GetStringLength();
Mike Stump1eb44332009-09-09 15:08:12 +000079
Chris Lattner2197c962009-02-18 18:52:52 +000080 // If the byte is in this token, return the location of the byte.
Chris Lattner60800082009-02-18 17:49:48 +000081 if (ByteNo < TokNumBytes ||
82 (ByteNo == TokNumBytes && TokNo == SL->getNumConcatenated())) {
Mike Stump1eb44332009-09-09 15:08:12 +000083 unsigned Offset =
Chris Lattner719e6152009-02-18 19:21:10 +000084 StringLiteralParser::getOffsetOfStringByte(TheTok, ByteNo, PP);
Mike Stump1eb44332009-09-09 15:08:12 +000085
Chris Lattner719e6152009-02-18 19:21:10 +000086 // Now that we know the offset of the token in the spelling, use the
87 // preprocessor to get the offset in the original source.
88 return PP.AdvanceToTokenCharacter(StrTokLoc, Offset);
Chris Lattner60800082009-02-18 17:49:48 +000089 }
Mike Stump1eb44332009-09-09 15:08:12 +000090
Chris Lattner60800082009-02-18 17:49:48 +000091 // Move to the next string token.
92 ++TokNo;
93 ByteNo -= TokNumBytes;
94 }
95}
96
Ryan Flynn4403a5e2009-08-06 03:00:50 +000097/// CheckablePrintfAttr - does a function call have a "printf" attribute
98/// and arguments that merit checking?
99bool Sema::CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall) {
100 if (Format->getType() == "printf") return true;
101 if (Format->getType() == "printf0") {
102 // printf0 allows null "format" string; if so don't check format/args
103 unsigned format_idx = Format->getFormatIdx() - 1;
Sebastian Redl4a2614e2009-11-17 18:02:24 +0000104 // Does the index refer to the implicit object argument?
105 if (isa<CXXMemberCallExpr>(TheCall)) {
106 if (format_idx == 0)
107 return false;
108 --format_idx;
109 }
Ryan Flynn4403a5e2009-08-06 03:00:50 +0000110 if (format_idx < TheCall->getNumArgs()) {
111 Expr *Format = TheCall->getArg(format_idx)->IgnoreParenCasts();
Ted Kremenekefaff192010-02-27 01:41:03 +0000112 if (!Format->isNullPointerConstant(Context,
113 Expr::NPC_ValueDependentIsNull))
Ryan Flynn4403a5e2009-08-06 03:00:50 +0000114 return true;
115 }
116 }
117 return false;
118}
Chris Lattner60800082009-02-18 17:49:48 +0000119
Sebastian Redl0eb23302009-01-19 00:08:26 +0000120Action::OwningExprResult
Anders Carlssond406bf02009-08-16 01:56:34 +0000121Sema::CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
Sebastian Redl0eb23302009-01-19 00:08:26 +0000122 OwningExprResult TheCallResult(Owned(TheCall));
Douglas Gregor2def4832008-11-17 20:34:05 +0000123
Anders Carlssond406bf02009-08-16 01:56:34 +0000124 switch (BuiltinID) {
Chris Lattner30ce3442007-12-19 23:59:04 +0000125 case Builtin::BI__builtin___CFStringMakeConstantString:
Chris Lattner925e60d2007-12-28 05:29:59 +0000126 assert(TheCall->getNumArgs() == 1 &&
Chris Lattner1b9a0792007-12-20 00:26:33 +0000127 "Wrong # arguments to builtin CFStringMakeConstantString");
Chris Lattner69039812009-02-18 06:01:06 +0000128 if (CheckObjCString(TheCall->getArg(0)))
Sebastian Redl0eb23302009-01-19 00:08:26 +0000129 return ExprError();
Anders Carlssond406bf02009-08-16 01:56:34 +0000130 break;
Ted Kremenek49ff7a12008-07-09 17:58:53 +0000131 case Builtin::BI__builtin_stdarg_start:
Chris Lattner30ce3442007-12-19 23:59:04 +0000132 case Builtin::BI__builtin_va_start:
Sebastian Redl0eb23302009-01-19 00:08:26 +0000133 if (SemaBuiltinVAStart(TheCall))
134 return ExprError();
Anders Carlssond406bf02009-08-16 01:56:34 +0000135 break;
Chris Lattner1b9a0792007-12-20 00:26:33 +0000136 case Builtin::BI__builtin_isgreater:
137 case Builtin::BI__builtin_isgreaterequal:
138 case Builtin::BI__builtin_isless:
139 case Builtin::BI__builtin_islessequal:
140 case Builtin::BI__builtin_islessgreater:
141 case Builtin::BI__builtin_isunordered:
Sebastian Redl0eb23302009-01-19 00:08:26 +0000142 if (SemaBuiltinUnorderedCompare(TheCall))
143 return ExprError();
Anders Carlssond406bf02009-08-16 01:56:34 +0000144 break;
Benjamin Kramere771a7a2010-02-15 22:42:31 +0000145 case Builtin::BI__builtin_fpclassify:
146 if (SemaBuiltinFPClassification(TheCall, 6))
147 return ExprError();
148 break;
Eli Friedman9ac6f622009-08-31 20:06:00 +0000149 case Builtin::BI__builtin_isfinite:
150 case Builtin::BI__builtin_isinf:
151 case Builtin::BI__builtin_isinf_sign:
152 case Builtin::BI__builtin_isnan:
153 case Builtin::BI__builtin_isnormal:
Benjamin Kramer3b1e26b2010-02-16 10:07:31 +0000154 if (SemaBuiltinFPClassification(TheCall, 1))
Eli Friedman9ac6f622009-08-31 20:06:00 +0000155 return ExprError();
156 break;
Eli Friedman6cfda232008-05-20 08:23:37 +0000157 case Builtin::BI__builtin_return_address:
158 case Builtin::BI__builtin_frame_address:
Sebastian Redl0eb23302009-01-19 00:08:26 +0000159 if (SemaBuiltinStackAddress(TheCall))
160 return ExprError();
Anders Carlssond406bf02009-08-16 01:56:34 +0000161 break;
Chris Lattner21fb98e2009-09-23 06:06:36 +0000162 case Builtin::BI__builtin_eh_return_data_regno:
163 if (SemaBuiltinEHReturnDataRegNo(TheCall))
164 return ExprError();
165 break;
Eli Friedmand38617c2008-05-14 19:38:39 +0000166 case Builtin::BI__builtin_shufflevector:
Sebastian Redl0eb23302009-01-19 00:08:26 +0000167 return SemaBuiltinShuffleVector(TheCall);
168 // TheCall will be freed by the smart pointer here, but that's fine, since
169 // SemaBuiltinShuffleVector guts it, but then doesn't release it.
Daniel Dunbar4493f792008-07-21 22:59:13 +0000170 case Builtin::BI__builtin_prefetch:
Sebastian Redl0eb23302009-01-19 00:08:26 +0000171 if (SemaBuiltinPrefetch(TheCall))
172 return ExprError();
Anders Carlssond406bf02009-08-16 01:56:34 +0000173 break;
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +0000174 case Builtin::BI__builtin_object_size:
Sebastian Redl0eb23302009-01-19 00:08:26 +0000175 if (SemaBuiltinObjectSize(TheCall))
176 return ExprError();
Anders Carlssond406bf02009-08-16 01:56:34 +0000177 break;
Eli Friedmand875fed2009-05-03 04:46:36 +0000178 case Builtin::BI__builtin_longjmp:
179 if (SemaBuiltinLongjmp(TheCall))
180 return ExprError();
Anders Carlssond406bf02009-08-16 01:56:34 +0000181 break;
Chris Lattner5caa3702009-05-08 06:58:22 +0000182 case Builtin::BI__sync_fetch_and_add:
183 case Builtin::BI__sync_fetch_and_sub:
184 case Builtin::BI__sync_fetch_and_or:
185 case Builtin::BI__sync_fetch_and_and:
186 case Builtin::BI__sync_fetch_and_xor:
Chris Lattnereebd9d22009-05-13 04:37:52 +0000187 case Builtin::BI__sync_fetch_and_nand:
Chris Lattner5caa3702009-05-08 06:58:22 +0000188 case Builtin::BI__sync_add_and_fetch:
189 case Builtin::BI__sync_sub_and_fetch:
190 case Builtin::BI__sync_and_and_fetch:
191 case Builtin::BI__sync_or_and_fetch:
192 case Builtin::BI__sync_xor_and_fetch:
Chris Lattnereebd9d22009-05-13 04:37:52 +0000193 case Builtin::BI__sync_nand_and_fetch:
Chris Lattner5caa3702009-05-08 06:58:22 +0000194 case Builtin::BI__sync_val_compare_and_swap:
195 case Builtin::BI__sync_bool_compare_and_swap:
196 case Builtin::BI__sync_lock_test_and_set:
197 case Builtin::BI__sync_lock_release:
198 if (SemaBuiltinAtomicOverloaded(TheCall))
199 return ExprError();
Anders Carlssond406bf02009-08-16 01:56:34 +0000200 break;
Anders Carlsson71993dd2007-08-17 05:31:46 +0000201 }
Mike Stump1eb44332009-09-09 15:08:12 +0000202
Anders Carlssond406bf02009-08-16 01:56:34 +0000203 return move(TheCallResult);
204}
Daniel Dunbarde454282008-10-02 18:44:07 +0000205
Anders Carlssond406bf02009-08-16 01:56:34 +0000206/// CheckFunctionCall - Check a direct function call for various correctness
207/// and safety properties not strictly enforced by the C type system.
208bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall) {
209 // Get the IdentifierInfo* for the called function.
210 IdentifierInfo *FnInfo = FDecl->getIdentifier();
211
212 // None of the checks below are needed for functions that don't have
213 // simple names (e.g., C++ conversion functions).
214 if (!FnInfo)
215 return false;
Mike Stump1eb44332009-09-09 15:08:12 +0000216
Daniel Dunbarde454282008-10-02 18:44:07 +0000217 // FIXME: This mechanism should be abstracted to be less fragile and
218 // more efficient. For example, just map function ids to custom
219 // handlers.
220
Chris Lattner59907c42007-08-10 20:18:51 +0000221 // Printf checking.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000222 if (const FormatAttr *Format = FDecl->getAttr<FormatAttr>()) {
Ryan Flynn4403a5e2009-08-06 03:00:50 +0000223 if (CheckablePrintfAttr(Format, TheCall)) {
Ted Kremenek3d692df2009-02-27 17:58:43 +0000224 bool HasVAListArg = Format->getFirstArg() == 0;
225 if (!HasVAListArg) {
Mike Stump1eb44332009-09-09 15:08:12 +0000226 if (const FunctionProtoType *Proto
John McCall183700f2009-09-21 23:43:11 +0000227 = FDecl->getType()->getAs<FunctionProtoType>())
Sebastian Redl4a2614e2009-11-17 18:02:24 +0000228 HasVAListArg = !Proto->isVariadic();
Ted Kremenek3d692df2009-02-27 17:58:43 +0000229 }
Douglas Gregor3c385e52009-02-14 18:57:46 +0000230 CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1,
Ted Kremenek3d692df2009-02-27 17:58:43 +0000231 HasVAListArg ? 0 : Format->getFirstArg() - 1);
Douglas Gregor3c385e52009-02-14 18:57:46 +0000232 }
Chris Lattner59907c42007-08-10 20:18:51 +0000233 }
Mike Stump1eb44332009-09-09 15:08:12 +0000234
235 for (const NonNullAttr *NonNull = FDecl->getAttr<NonNullAttr>(); NonNull;
Anders Carlssond406bf02009-08-16 01:56:34 +0000236 NonNull = NonNull->getNext<NonNullAttr>())
237 CheckNonNullArguments(NonNull, TheCall);
Sebastian Redl0eb23302009-01-19 00:08:26 +0000238
Anders Carlssond406bf02009-08-16 01:56:34 +0000239 return false;
Anders Carlsson71993dd2007-08-17 05:31:46 +0000240}
241
Anders Carlssond406bf02009-08-16 01:56:34 +0000242bool Sema::CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall) {
Fariborz Jahanian725165f2009-05-18 21:05:18 +0000243 // Printf checking.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000244 const FormatAttr *Format = NDecl->getAttr<FormatAttr>();
Fariborz Jahanian725165f2009-05-18 21:05:18 +0000245 if (!Format)
Anders Carlssond406bf02009-08-16 01:56:34 +0000246 return false;
Mike Stump1eb44332009-09-09 15:08:12 +0000247
Fariborz Jahanian725165f2009-05-18 21:05:18 +0000248 const VarDecl *V = dyn_cast<VarDecl>(NDecl);
249 if (!V)
Anders Carlssond406bf02009-08-16 01:56:34 +0000250 return false;
Mike Stump1eb44332009-09-09 15:08:12 +0000251
Fariborz Jahanian725165f2009-05-18 21:05:18 +0000252 QualType Ty = V->getType();
253 if (!Ty->isBlockPointerType())
Anders Carlssond406bf02009-08-16 01:56:34 +0000254 return false;
Mike Stump1eb44332009-09-09 15:08:12 +0000255
Anders Carlssond406bf02009-08-16 01:56:34 +0000256 if (!CheckablePrintfAttr(Format, TheCall))
257 return false;
Mike Stump1eb44332009-09-09 15:08:12 +0000258
Anders Carlssond406bf02009-08-16 01:56:34 +0000259 bool HasVAListArg = Format->getFirstArg() == 0;
260 if (!HasVAListArg) {
Mike Stump1eb44332009-09-09 15:08:12 +0000261 const FunctionType *FT =
John McCall183700f2009-09-21 23:43:11 +0000262 Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
Anders Carlssond406bf02009-08-16 01:56:34 +0000263 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT))
264 HasVAListArg = !Proto->isVariadic();
Fariborz Jahanian725165f2009-05-18 21:05:18 +0000265 }
Anders Carlssond406bf02009-08-16 01:56:34 +0000266 CheckPrintfArguments(TheCall, HasVAListArg, Format->getFormatIdx() - 1,
267 HasVAListArg ? 0 : Format->getFirstArg() - 1);
268
269 return false;
Fariborz Jahanian725165f2009-05-18 21:05:18 +0000270}
271
Chris Lattner5caa3702009-05-08 06:58:22 +0000272/// SemaBuiltinAtomicOverloaded - We have a call to a function like
273/// __sync_fetch_and_add, which is an overloaded function based on the pointer
274/// type of its first argument. The main ActOnCallExpr routines have already
275/// promoted the types of arguments because all of these calls are prototyped as
276/// void(...).
277///
278/// This function goes through and does final semantic checking for these
279/// builtins,
280bool Sema::SemaBuiltinAtomicOverloaded(CallExpr *TheCall) {
281 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
282 FunctionDecl *FDecl = cast<FunctionDecl>(DRE->getDecl());
283
284 // Ensure that we have at least one argument to do type inference from.
285 if (TheCall->getNumArgs() < 1)
286 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
287 << 0 << TheCall->getCallee()->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +0000288
Chris Lattner5caa3702009-05-08 06:58:22 +0000289 // Inspect the first argument of the atomic builtin. This should always be
290 // a pointer type, whose element is an integral scalar or pointer type.
291 // Because it is a pointer type, we don't have to worry about any implicit
292 // casts here.
293 Expr *FirstArg = TheCall->getArg(0);
294 if (!FirstArg->getType()->isPointerType())
295 return Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer)
296 << FirstArg->getType() << FirstArg->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +0000297
Ted Kremenek6217b802009-07-29 21:53:49 +0000298 QualType ValType = FirstArg->getType()->getAs<PointerType>()->getPointeeType();
Mike Stump1eb44332009-09-09 15:08:12 +0000299 if (!ValType->isIntegerType() && !ValType->isPointerType() &&
Chris Lattner5caa3702009-05-08 06:58:22 +0000300 !ValType->isBlockPointerType())
301 return Diag(DRE->getLocStart(),
302 diag::err_atomic_builtin_must_be_pointer_intptr)
303 << FirstArg->getType() << FirstArg->getSourceRange();
304
305 // We need to figure out which concrete builtin this maps onto. For example,
306 // __sync_fetch_and_add with a 2 byte object turns into
307 // __sync_fetch_and_add_2.
308#define BUILTIN_ROW(x) \
309 { Builtin::BI##x##_1, Builtin::BI##x##_2, Builtin::BI##x##_4, \
310 Builtin::BI##x##_8, Builtin::BI##x##_16 }
Mike Stump1eb44332009-09-09 15:08:12 +0000311
Chris Lattner5caa3702009-05-08 06:58:22 +0000312 static const unsigned BuiltinIndices[][5] = {
313 BUILTIN_ROW(__sync_fetch_and_add),
314 BUILTIN_ROW(__sync_fetch_and_sub),
315 BUILTIN_ROW(__sync_fetch_and_or),
316 BUILTIN_ROW(__sync_fetch_and_and),
317 BUILTIN_ROW(__sync_fetch_and_xor),
Chris Lattnereebd9d22009-05-13 04:37:52 +0000318 BUILTIN_ROW(__sync_fetch_and_nand),
Mike Stump1eb44332009-09-09 15:08:12 +0000319
Chris Lattner5caa3702009-05-08 06:58:22 +0000320 BUILTIN_ROW(__sync_add_and_fetch),
321 BUILTIN_ROW(__sync_sub_and_fetch),
322 BUILTIN_ROW(__sync_and_and_fetch),
323 BUILTIN_ROW(__sync_or_and_fetch),
324 BUILTIN_ROW(__sync_xor_and_fetch),
Chris Lattnereebd9d22009-05-13 04:37:52 +0000325 BUILTIN_ROW(__sync_nand_and_fetch),
Mike Stump1eb44332009-09-09 15:08:12 +0000326
Chris Lattner5caa3702009-05-08 06:58:22 +0000327 BUILTIN_ROW(__sync_val_compare_and_swap),
328 BUILTIN_ROW(__sync_bool_compare_and_swap),
329 BUILTIN_ROW(__sync_lock_test_and_set),
330 BUILTIN_ROW(__sync_lock_release)
331 };
Mike Stump1eb44332009-09-09 15:08:12 +0000332#undef BUILTIN_ROW
333
Chris Lattner5caa3702009-05-08 06:58:22 +0000334 // Determine the index of the size.
335 unsigned SizeIndex;
Ken Dyck199c3d62010-01-11 17:06:35 +0000336 switch (Context.getTypeSizeInChars(ValType).getQuantity()) {
Chris Lattner5caa3702009-05-08 06:58:22 +0000337 case 1: SizeIndex = 0; break;
338 case 2: SizeIndex = 1; break;
339 case 4: SizeIndex = 2; break;
340 case 8: SizeIndex = 3; break;
341 case 16: SizeIndex = 4; break;
342 default:
343 return Diag(DRE->getLocStart(), diag::err_atomic_builtin_pointer_size)
344 << FirstArg->getType() << FirstArg->getSourceRange();
345 }
Mike Stump1eb44332009-09-09 15:08:12 +0000346
Chris Lattner5caa3702009-05-08 06:58:22 +0000347 // Each of these builtins has one pointer argument, followed by some number of
348 // values (0, 1 or 2) followed by a potentially empty varags list of stuff
349 // that we ignore. Find out which row of BuiltinIndices to read from as well
350 // as the number of fixed args.
Douglas Gregor7814e6d2009-09-12 00:22:50 +0000351 unsigned BuiltinID = FDecl->getBuiltinID();
Chris Lattner5caa3702009-05-08 06:58:22 +0000352 unsigned BuiltinIndex, NumFixed = 1;
353 switch (BuiltinID) {
354 default: assert(0 && "Unknown overloaded atomic builtin!");
355 case Builtin::BI__sync_fetch_and_add: BuiltinIndex = 0; break;
356 case Builtin::BI__sync_fetch_and_sub: BuiltinIndex = 1; break;
357 case Builtin::BI__sync_fetch_and_or: BuiltinIndex = 2; break;
358 case Builtin::BI__sync_fetch_and_and: BuiltinIndex = 3; break;
359 case Builtin::BI__sync_fetch_and_xor: BuiltinIndex = 4; break;
Chris Lattnereebd9d22009-05-13 04:37:52 +0000360 case Builtin::BI__sync_fetch_and_nand:BuiltinIndex = 5; break;
Mike Stump1eb44332009-09-09 15:08:12 +0000361
Chris Lattnereebd9d22009-05-13 04:37:52 +0000362 case Builtin::BI__sync_add_and_fetch: BuiltinIndex = 6; break;
363 case Builtin::BI__sync_sub_and_fetch: BuiltinIndex = 7; break;
364 case Builtin::BI__sync_and_and_fetch: BuiltinIndex = 8; break;
365 case Builtin::BI__sync_or_and_fetch: BuiltinIndex = 9; break;
366 case Builtin::BI__sync_xor_and_fetch: BuiltinIndex =10; break;
367 case Builtin::BI__sync_nand_and_fetch:BuiltinIndex =11; break;
Mike Stump1eb44332009-09-09 15:08:12 +0000368
Chris Lattner5caa3702009-05-08 06:58:22 +0000369 case Builtin::BI__sync_val_compare_and_swap:
Chris Lattnereebd9d22009-05-13 04:37:52 +0000370 BuiltinIndex = 12;
Chris Lattner5caa3702009-05-08 06:58:22 +0000371 NumFixed = 2;
372 break;
373 case Builtin::BI__sync_bool_compare_and_swap:
Chris Lattnereebd9d22009-05-13 04:37:52 +0000374 BuiltinIndex = 13;
Chris Lattner5caa3702009-05-08 06:58:22 +0000375 NumFixed = 2;
376 break;
Chris Lattnereebd9d22009-05-13 04:37:52 +0000377 case Builtin::BI__sync_lock_test_and_set: BuiltinIndex = 14; break;
Chris Lattner5caa3702009-05-08 06:58:22 +0000378 case Builtin::BI__sync_lock_release:
Chris Lattnereebd9d22009-05-13 04:37:52 +0000379 BuiltinIndex = 15;
Chris Lattner5caa3702009-05-08 06:58:22 +0000380 NumFixed = 0;
381 break;
382 }
Mike Stump1eb44332009-09-09 15:08:12 +0000383
Chris Lattner5caa3702009-05-08 06:58:22 +0000384 // Now that we know how many fixed arguments we expect, first check that we
385 // have at least that many.
386 if (TheCall->getNumArgs() < 1+NumFixed)
387 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
388 << 0 << TheCall->getCallee()->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +0000389
390
Chris Lattnere7ac0a92009-05-08 15:36:58 +0000391 // Get the decl for the concrete builtin from this, we can tell what the
392 // concrete integer type we should convert to is.
393 unsigned NewBuiltinID = BuiltinIndices[BuiltinIndex][SizeIndex];
394 const char *NewBuiltinName = Context.BuiltinInfo.GetName(NewBuiltinID);
395 IdentifierInfo *NewBuiltinII = PP.getIdentifierInfo(NewBuiltinName);
Mike Stump1eb44332009-09-09 15:08:12 +0000396 FunctionDecl *NewBuiltinDecl =
Chris Lattnere7ac0a92009-05-08 15:36:58 +0000397 cast<FunctionDecl>(LazilyCreateBuiltin(NewBuiltinII, NewBuiltinID,
398 TUScope, false, DRE->getLocStart()));
399 const FunctionProtoType *BuiltinFT =
John McCall183700f2009-09-21 23:43:11 +0000400 NewBuiltinDecl->getType()->getAs<FunctionProtoType>();
Ted Kremenek6217b802009-07-29 21:53:49 +0000401 ValType = BuiltinFT->getArgType(0)->getAs<PointerType>()->getPointeeType();
Mike Stump1eb44332009-09-09 15:08:12 +0000402
Chris Lattnere7ac0a92009-05-08 15:36:58 +0000403 // If the first type needs to be converted (e.g. void** -> int*), do it now.
404 if (BuiltinFT->getArgType(0) != FirstArg->getType()) {
Eli Friedman73c39ab2009-10-20 08:27:19 +0000405 ImpCastExprToType(FirstArg, BuiltinFT->getArgType(0), CastExpr::CK_BitCast);
Chris Lattnere7ac0a92009-05-08 15:36:58 +0000406 TheCall->setArg(0, FirstArg);
407 }
Mike Stump1eb44332009-09-09 15:08:12 +0000408
Chris Lattner5caa3702009-05-08 06:58:22 +0000409 // Next, walk the valid ones promoting to the right type.
410 for (unsigned i = 0; i != NumFixed; ++i) {
411 Expr *Arg = TheCall->getArg(i+1);
Mike Stump1eb44332009-09-09 15:08:12 +0000412
Chris Lattner5caa3702009-05-08 06:58:22 +0000413 // If the argument is an implicit cast, then there was a promotion due to
414 // "...", just remove it now.
415 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
416 Arg = ICE->getSubExpr();
417 ICE->setSubExpr(0);
418 ICE->Destroy(Context);
419 TheCall->setArg(i+1, Arg);
420 }
Mike Stump1eb44332009-09-09 15:08:12 +0000421
Chris Lattner5caa3702009-05-08 06:58:22 +0000422 // GCC does an implicit conversion to the pointer or integer ValType. This
423 // can fail in some cases (1i -> int**), check for this error case now.
Anders Carlssoncdb61972009-08-07 22:21:05 +0000424 CastExpr::CastKind Kind = CastExpr::CK_Unknown;
Fariborz Jahaniane9f42082009-08-26 18:55:36 +0000425 CXXMethodDecl *ConversionDecl = 0;
426 if (CheckCastTypes(Arg->getSourceRange(), ValType, Arg, Kind,
427 ConversionDecl))
Chris Lattner5caa3702009-05-08 06:58:22 +0000428 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000429
Chris Lattner5caa3702009-05-08 06:58:22 +0000430 // Okay, we have something that *can* be converted to the right type. Check
431 // to see if there is a potentially weird extension going on here. This can
432 // happen when you do an atomic operation on something like an char* and
433 // pass in 42. The 42 gets converted to char. This is even more strange
434 // for things like 45.123 -> char, etc.
Mike Stump1eb44332009-09-09 15:08:12 +0000435 // FIXME: Do this check.
Anders Carlssoncdb61972009-08-07 22:21:05 +0000436 ImpCastExprToType(Arg, ValType, Kind, /*isLvalue=*/false);
Chris Lattner5caa3702009-05-08 06:58:22 +0000437 TheCall->setArg(i+1, Arg);
438 }
Mike Stump1eb44332009-09-09 15:08:12 +0000439
Chris Lattner5caa3702009-05-08 06:58:22 +0000440 // Switch the DeclRefExpr to refer to the new decl.
441 DRE->setDecl(NewBuiltinDecl);
442 DRE->setType(NewBuiltinDecl->getType());
Mike Stump1eb44332009-09-09 15:08:12 +0000443
Chris Lattner5caa3702009-05-08 06:58:22 +0000444 // Set the callee in the CallExpr.
445 // FIXME: This leaks the original parens and implicit casts.
446 Expr *PromotedCall = DRE;
447 UsualUnaryConversions(PromotedCall);
448 TheCall->setCallee(PromotedCall);
Mike Stump1eb44332009-09-09 15:08:12 +0000449
Chris Lattner5caa3702009-05-08 06:58:22 +0000450
451 // Change the result type of the call to match the result type of the decl.
452 TheCall->setType(NewBuiltinDecl->getResultType());
453 return false;
454}
455
456
Chris Lattner69039812009-02-18 06:01:06 +0000457/// CheckObjCString - Checks that the argument to the builtin
Anders Carlsson71993dd2007-08-17 05:31:46 +0000458/// CFString constructor is correct
Steve Narofffd942622009-04-13 20:26:29 +0000459/// FIXME: GCC currently emits the following warning:
Mike Stump1eb44332009-09-09 15:08:12 +0000460/// "warning: input conversion stopped due to an input byte that does not
Steve Narofffd942622009-04-13 20:26:29 +0000461/// belong to the input codeset UTF-8"
462/// Note: It might also make sense to do the UTF-16 conversion here (would
463/// simplify the backend).
Chris Lattner69039812009-02-18 06:01:06 +0000464bool Sema::CheckObjCString(Expr *Arg) {
Chris Lattner56f34942008-02-13 01:02:39 +0000465 Arg = Arg->IgnoreParenCasts();
Anders Carlsson71993dd2007-08-17 05:31:46 +0000466 StringLiteral *Literal = dyn_cast<StringLiteral>(Arg);
467
468 if (!Literal || Literal->isWide()) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000469 Diag(Arg->getLocStart(), diag::err_cfstring_literal_not_string_constant)
470 << Arg->getSourceRange();
Anders Carlsson9cdc4d32007-08-17 15:44:17 +0000471 return true;
Anders Carlsson71993dd2007-08-17 05:31:46 +0000472 }
Mike Stump1eb44332009-09-09 15:08:12 +0000473
Daniel Dunbarf015b032009-09-22 10:03:52 +0000474 const char *Data = Literal->getStrData();
475 unsigned Length = Literal->getByteLength();
Mike Stump1eb44332009-09-09 15:08:12 +0000476
Daniel Dunbarf015b032009-09-22 10:03:52 +0000477 for (unsigned i = 0; i < Length; ++i) {
478 if (!Data[i]) {
479 Diag(getLocationOfStringLiteralByte(Literal, i),
480 diag::warn_cfstring_literal_contains_nul_character)
481 << Arg->getSourceRange();
482 break;
483 }
484 }
Mike Stump1eb44332009-09-09 15:08:12 +0000485
Anders Carlsson9cdc4d32007-08-17 15:44:17 +0000486 return false;
Chris Lattner59907c42007-08-10 20:18:51 +0000487}
488
Chris Lattnerc27c6652007-12-20 00:05:45 +0000489/// SemaBuiltinVAStart - Check the arguments to __builtin_va_start for validity.
490/// Emit an error and return true on failure, return false on success.
Chris Lattner925e60d2007-12-28 05:29:59 +0000491bool Sema::SemaBuiltinVAStart(CallExpr *TheCall) {
492 Expr *Fn = TheCall->getCallee();
493 if (TheCall->getNumArgs() > 2) {
Chris Lattner2c21a072008-11-21 18:44:24 +0000494 Diag(TheCall->getArg(2)->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000495 diag::err_typecheck_call_too_many_args)
Chris Lattner2c21a072008-11-21 18:44:24 +0000496 << 0 /*function call*/ << Fn->getSourceRange()
Mike Stump1eb44332009-09-09 15:08:12 +0000497 << SourceRange(TheCall->getArg(2)->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000498 (*(TheCall->arg_end()-1))->getLocEnd());
Chris Lattner30ce3442007-12-19 23:59:04 +0000499 return true;
500 }
Eli Friedman56f20ae2008-12-15 22:05:35 +0000501
502 if (TheCall->getNumArgs() < 2) {
503 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
504 << 0 /*function call*/;
505 }
506
Chris Lattnerc27c6652007-12-20 00:05:45 +0000507 // Determine whether the current function is variadic or not.
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +0000508 BlockScopeInfo *CurBlock = getCurBlock();
Chris Lattnerc27c6652007-12-20 00:05:45 +0000509 bool isVariadic;
Steve Naroffcd9c5142009-04-15 19:33:47 +0000510 if (CurBlock)
511 isVariadic = CurBlock->isVariadic;
512 else if (getCurFunctionDecl()) {
Douglas Gregor72564e72009-02-26 23:50:07 +0000513 if (FunctionProtoType* FTP =
514 dyn_cast<FunctionProtoType>(getCurFunctionDecl()->getType()))
Eli Friedman56f20ae2008-12-15 22:05:35 +0000515 isVariadic = FTP->isVariadic();
516 else
517 isVariadic = false;
518 } else {
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000519 isVariadic = getCurMethodDecl()->isVariadic();
Eli Friedman56f20ae2008-12-15 22:05:35 +0000520 }
Mike Stump1eb44332009-09-09 15:08:12 +0000521
Chris Lattnerc27c6652007-12-20 00:05:45 +0000522 if (!isVariadic) {
Chris Lattner30ce3442007-12-19 23:59:04 +0000523 Diag(Fn->getLocStart(), diag::err_va_start_used_in_non_variadic_function);
524 return true;
525 }
Mike Stump1eb44332009-09-09 15:08:12 +0000526
Chris Lattner30ce3442007-12-19 23:59:04 +0000527 // Verify that the second argument to the builtin is the last argument of the
528 // current function or method.
529 bool SecondArgIsLastNamedArgument = false;
Anders Carlssone2c14102008-02-13 01:22:59 +0000530 const Expr *Arg = TheCall->getArg(1)->IgnoreParenCasts();
Mike Stump1eb44332009-09-09 15:08:12 +0000531
Anders Carlsson88cf2262008-02-11 04:20:54 +0000532 if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Arg)) {
533 if (const ParmVarDecl *PV = dyn_cast<ParmVarDecl>(DR->getDecl())) {
Chris Lattner30ce3442007-12-19 23:59:04 +0000534 // FIXME: This isn't correct for methods (results in bogus warning).
535 // Get the last formal in the current function.
Anders Carlsson88cf2262008-02-11 04:20:54 +0000536 const ParmVarDecl *LastArg;
Steve Naroffcd9c5142009-04-15 19:33:47 +0000537 if (CurBlock)
538 LastArg = *(CurBlock->TheDecl->param_end()-1);
539 else if (FunctionDecl *FD = getCurFunctionDecl())
Chris Lattner371f2582008-12-04 23:50:19 +0000540 LastArg = *(FD->param_end()-1);
Chris Lattner30ce3442007-12-19 23:59:04 +0000541 else
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000542 LastArg = *(getCurMethodDecl()->param_end()-1);
Chris Lattner30ce3442007-12-19 23:59:04 +0000543 SecondArgIsLastNamedArgument = PV == LastArg;
544 }
545 }
Mike Stump1eb44332009-09-09 15:08:12 +0000546
Chris Lattner30ce3442007-12-19 23:59:04 +0000547 if (!SecondArgIsLastNamedArgument)
Mike Stump1eb44332009-09-09 15:08:12 +0000548 Diag(TheCall->getArg(1)->getLocStart(),
Chris Lattner30ce3442007-12-19 23:59:04 +0000549 diag::warn_second_parameter_of_va_start_not_last_named_argument);
550 return false;
Eli Friedman6cfda232008-05-20 08:23:37 +0000551}
Chris Lattner30ce3442007-12-19 23:59:04 +0000552
Chris Lattner1b9a0792007-12-20 00:26:33 +0000553/// SemaBuiltinUnorderedCompare - Handle functions like __builtin_isgreater and
554/// friends. This is declared to take (...), so we have to check everything.
Chris Lattner925e60d2007-12-28 05:29:59 +0000555bool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) {
556 if (TheCall->getNumArgs() < 2)
Chris Lattner2c21a072008-11-21 18:44:24 +0000557 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
558 << 0 /*function call*/;
Chris Lattner925e60d2007-12-28 05:29:59 +0000559 if (TheCall->getNumArgs() > 2)
Mike Stump1eb44332009-09-09 15:08:12 +0000560 return Diag(TheCall->getArg(2)->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000561 diag::err_typecheck_call_too_many_args)
Chris Lattner2c21a072008-11-21 18:44:24 +0000562 << 0 /*function call*/
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000563 << SourceRange(TheCall->getArg(2)->getLocStart(),
564 (*(TheCall->arg_end()-1))->getLocEnd());
Mike Stump1eb44332009-09-09 15:08:12 +0000565
Chris Lattner925e60d2007-12-28 05:29:59 +0000566 Expr *OrigArg0 = TheCall->getArg(0);
567 Expr *OrigArg1 = TheCall->getArg(1);
Douglas Gregorcde01732009-05-19 22:10:17 +0000568
Chris Lattner1b9a0792007-12-20 00:26:33 +0000569 // Do standard promotions between the two arguments, returning their common
570 // type.
Chris Lattner925e60d2007-12-28 05:29:59 +0000571 QualType Res = UsualArithmeticConversions(OrigArg0, OrigArg1, false);
Daniel Dunbar403bc2b2009-02-19 19:28:43 +0000572
573 // Make sure any conversions are pushed back into the call; this is
574 // type safe since unordered compare builtins are declared as "_Bool
575 // foo(...)".
576 TheCall->setArg(0, OrigArg0);
577 TheCall->setArg(1, OrigArg1);
Mike Stump1eb44332009-09-09 15:08:12 +0000578
Douglas Gregorcde01732009-05-19 22:10:17 +0000579 if (OrigArg0->isTypeDependent() || OrigArg1->isTypeDependent())
580 return false;
581
Chris Lattner1b9a0792007-12-20 00:26:33 +0000582 // If the common type isn't a real floating type, then the arguments were
583 // invalid for this operation.
584 if (!Res->isRealFloatingType())
Mike Stump1eb44332009-09-09 15:08:12 +0000585 return Diag(OrigArg0->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000586 diag::err_typecheck_call_invalid_ordered_compare)
Chris Lattnerd1625842008-11-24 06:25:27 +0000587 << OrigArg0->getType() << OrigArg1->getType()
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000588 << SourceRange(OrigArg0->getLocStart(), OrigArg1->getLocEnd());
Mike Stump1eb44332009-09-09 15:08:12 +0000589
Chris Lattner1b9a0792007-12-20 00:26:33 +0000590 return false;
591}
592
Benjamin Kramere771a7a2010-02-15 22:42:31 +0000593/// SemaBuiltinSemaBuiltinFPClassification - Handle functions like
594/// __builtin_isnan and friends. This is declared to take (...), so we have
Benjamin Kramer3b1e26b2010-02-16 10:07:31 +0000595/// to check everything. We expect the last argument to be a floating point
596/// value.
597bool Sema::SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs) {
598 if (TheCall->getNumArgs() < NumArgs)
Eli Friedman9ac6f622009-08-31 20:06:00 +0000599 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_few_args)
600 << 0 /*function call*/;
Benjamin Kramer3b1e26b2010-02-16 10:07:31 +0000601 if (TheCall->getNumArgs() > NumArgs)
602 return Diag(TheCall->getArg(NumArgs)->getLocStart(),
Eli Friedman9ac6f622009-08-31 20:06:00 +0000603 diag::err_typecheck_call_too_many_args)
604 << 0 /*function call*/
Benjamin Kramer3b1e26b2010-02-16 10:07:31 +0000605 << SourceRange(TheCall->getArg(NumArgs)->getLocStart(),
Eli Friedman9ac6f622009-08-31 20:06:00 +0000606 (*(TheCall->arg_end()-1))->getLocEnd());
607
Benjamin Kramer3b1e26b2010-02-16 10:07:31 +0000608 Expr *OrigArg = TheCall->getArg(NumArgs-1);
Mike Stump1eb44332009-09-09 15:08:12 +0000609
Eli Friedman9ac6f622009-08-31 20:06:00 +0000610 if (OrigArg->isTypeDependent())
611 return false;
612
613 // This operation requires a floating-point number
614 if (!OrigArg->getType()->isRealFloatingType())
Mike Stump1eb44332009-09-09 15:08:12 +0000615 return Diag(OrigArg->getLocStart(),
Eli Friedman9ac6f622009-08-31 20:06:00 +0000616 diag::err_typecheck_call_invalid_unary_fp)
617 << OrigArg->getType() << OrigArg->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +0000618
Eli Friedman9ac6f622009-08-31 20:06:00 +0000619 return false;
620}
621
Eli Friedman6cfda232008-05-20 08:23:37 +0000622bool Sema::SemaBuiltinStackAddress(CallExpr *TheCall) {
623 // The signature for these builtins is exact; the only thing we need
624 // to check is that the argument is a constant.
625 SourceLocation Loc;
Douglas Gregorcde01732009-05-19 22:10:17 +0000626 if (!TheCall->getArg(0)->isTypeDependent() &&
627 !TheCall->getArg(0)->isValueDependent() &&
628 !TheCall->getArg(0)->isIntegerConstantExpr(Context, &Loc))
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000629 return Diag(Loc, diag::err_stack_const_level) << TheCall->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +0000630
Eli Friedman6cfda232008-05-20 08:23:37 +0000631 return false;
632}
633
Eli Friedmand38617c2008-05-14 19:38:39 +0000634/// SemaBuiltinShuffleVector - Handle __builtin_shufflevector.
635// This is declared to take (...), so we have to check everything.
Sebastian Redl0eb23302009-01-19 00:08:26 +0000636Action::OwningExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {
Eli Friedmand38617c2008-05-14 19:38:39 +0000637 if (TheCall->getNumArgs() < 3)
Sebastian Redl0eb23302009-01-19 00:08:26 +0000638 return ExprError(Diag(TheCall->getLocEnd(),
639 diag::err_typecheck_call_too_few_args)
640 << 0 /*function call*/ << TheCall->getSourceRange());
Eli Friedmand38617c2008-05-14 19:38:39 +0000641
Douglas Gregorcde01732009-05-19 22:10:17 +0000642 unsigned numElements = std::numeric_limits<unsigned>::max();
643 if (!TheCall->getArg(0)->isTypeDependent() &&
644 !TheCall->getArg(1)->isTypeDependent()) {
645 QualType FAType = TheCall->getArg(0)->getType();
646 QualType SAType = TheCall->getArg(1)->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000647
Douglas Gregorcde01732009-05-19 22:10:17 +0000648 if (!FAType->isVectorType() || !SAType->isVectorType()) {
649 Diag(TheCall->getLocStart(), diag::err_shufflevector_non_vector)
Mike Stump1eb44332009-09-09 15:08:12 +0000650 << SourceRange(TheCall->getArg(0)->getLocStart(),
Douglas Gregorcde01732009-05-19 22:10:17 +0000651 TheCall->getArg(1)->getLocEnd());
652 return ExprError();
653 }
Mike Stump1eb44332009-09-09 15:08:12 +0000654
Douglas Gregora4923eb2009-11-16 21:35:15 +0000655 if (!Context.hasSameUnqualifiedType(FAType, SAType)) {
Douglas Gregorcde01732009-05-19 22:10:17 +0000656 Diag(TheCall->getLocStart(), diag::err_shufflevector_incompatible_vector)
Mike Stump1eb44332009-09-09 15:08:12 +0000657 << SourceRange(TheCall->getArg(0)->getLocStart(),
Douglas Gregorcde01732009-05-19 22:10:17 +0000658 TheCall->getArg(1)->getLocEnd());
659 return ExprError();
660 }
Eli Friedmand38617c2008-05-14 19:38:39 +0000661
John McCall183700f2009-09-21 23:43:11 +0000662 numElements = FAType->getAs<VectorType>()->getNumElements();
Douglas Gregorcde01732009-05-19 22:10:17 +0000663 if (TheCall->getNumArgs() != numElements+2) {
664 if (TheCall->getNumArgs() < numElements+2)
665 return ExprError(Diag(TheCall->getLocEnd(),
666 diag::err_typecheck_call_too_few_args)
667 << 0 /*function call*/ << TheCall->getSourceRange());
Sebastian Redl0eb23302009-01-19 00:08:26 +0000668 return ExprError(Diag(TheCall->getLocEnd(),
Douglas Gregorcde01732009-05-19 22:10:17 +0000669 diag::err_typecheck_call_too_many_args)
670 << 0 /*function call*/ << TheCall->getSourceRange());
671 }
Eli Friedmand38617c2008-05-14 19:38:39 +0000672 }
673
674 for (unsigned i = 2; i < TheCall->getNumArgs(); i++) {
Douglas Gregorcde01732009-05-19 22:10:17 +0000675 if (TheCall->getArg(i)->isTypeDependent() ||
676 TheCall->getArg(i)->isValueDependent())
677 continue;
678
Eli Friedmand38617c2008-05-14 19:38:39 +0000679 llvm::APSInt Result(32);
Chris Lattnerd1a0b6d2008-08-10 02:05:13 +0000680 if (!TheCall->getArg(i)->isIntegerConstantExpr(Result, Context))
Sebastian Redl0eb23302009-01-19 00:08:26 +0000681 return ExprError(Diag(TheCall->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000682 diag::err_shufflevector_nonconstant_argument)
Sebastian Redl0eb23302009-01-19 00:08:26 +0000683 << TheCall->getArg(i)->getSourceRange());
684
Chris Lattnerd1a0b6d2008-08-10 02:05:13 +0000685 if (Result.getActiveBits() > 64 || Result.getZExtValue() >= numElements*2)
Sebastian Redl0eb23302009-01-19 00:08:26 +0000686 return ExprError(Diag(TheCall->getLocStart(),
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000687 diag::err_shufflevector_argument_too_large)
Sebastian Redl0eb23302009-01-19 00:08:26 +0000688 << TheCall->getArg(i)->getSourceRange());
Eli Friedmand38617c2008-05-14 19:38:39 +0000689 }
690
691 llvm::SmallVector<Expr*, 32> exprs;
692
Chris Lattnerd1a0b6d2008-08-10 02:05:13 +0000693 for (unsigned i = 0, e = TheCall->getNumArgs(); i != e; i++) {
Eli Friedmand38617c2008-05-14 19:38:39 +0000694 exprs.push_back(TheCall->getArg(i));
695 TheCall->setArg(i, 0);
696 }
697
Nate Begemana88dc302009-08-12 02:10:25 +0000698 return Owned(new (Context) ShuffleVectorExpr(Context, exprs.begin(),
699 exprs.size(), exprs[0]->getType(),
Ted Kremenek8189cde2009-02-07 01:47:29 +0000700 TheCall->getCallee()->getLocStart(),
701 TheCall->getRParenLoc()));
Eli Friedmand38617c2008-05-14 19:38:39 +0000702}
Chris Lattner30ce3442007-12-19 23:59:04 +0000703
Daniel Dunbar4493f792008-07-21 22:59:13 +0000704/// SemaBuiltinPrefetch - Handle __builtin_prefetch.
705// This is declared to take (const void*, ...) and can take two
706// optional constant int args.
707bool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000708 unsigned NumArgs = TheCall->getNumArgs();
Daniel Dunbar4493f792008-07-21 22:59:13 +0000709
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000710 if (NumArgs > 3)
711 return Diag(TheCall->getLocEnd(), diag::err_typecheck_call_too_many_args)
Chris Lattner2c21a072008-11-21 18:44:24 +0000712 << 0 /*function call*/ << TheCall->getSourceRange();
Daniel Dunbar4493f792008-07-21 22:59:13 +0000713
714 // Argument 0 is checked for us and the remaining arguments must be
715 // constant integers.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000716 for (unsigned i = 1; i != NumArgs; ++i) {
Daniel Dunbar4493f792008-07-21 22:59:13 +0000717 Expr *Arg = TheCall->getArg(i);
Douglas Gregorcde01732009-05-19 22:10:17 +0000718 if (Arg->isTypeDependent())
719 continue;
720
Eli Friedman9aef7262009-12-04 00:30:06 +0000721 if (!Arg->getType()->isIntegralType())
722 return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_arg_type)
Chris Lattner21fb98e2009-09-23 06:06:36 +0000723 << Arg->getSourceRange();
Douglas Gregorcde01732009-05-19 22:10:17 +0000724
Eli Friedman9aef7262009-12-04 00:30:06 +0000725 ImpCastExprToType(Arg, Context.IntTy, CastExpr::CK_IntegralCast);
726 TheCall->setArg(i, Arg);
727
Douglas Gregorcde01732009-05-19 22:10:17 +0000728 if (Arg->isValueDependent())
729 continue;
730
Eli Friedman9aef7262009-12-04 00:30:06 +0000731 llvm::APSInt Result;
Douglas Gregorcde01732009-05-19 22:10:17 +0000732 if (!Arg->isIntegerConstantExpr(Result, Context))
Eli Friedman9aef7262009-12-04 00:30:06 +0000733 return Diag(TheCall->getLocStart(), diag::err_prefetch_invalid_arg_ice)
Douglas Gregorcde01732009-05-19 22:10:17 +0000734 << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
Mike Stump1eb44332009-09-09 15:08:12 +0000735
Daniel Dunbar4493f792008-07-21 22:59:13 +0000736 // FIXME: gcc issues a warning and rewrites these to 0. These
737 // seems especially odd for the third argument since the default
738 // is 3.
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000739 if (i == 1) {
Eli Friedman9aef7262009-12-04 00:30:06 +0000740 if (Result.getLimitedValue() > 1)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000741 return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
Chris Lattner21fb98e2009-09-23 06:06:36 +0000742 << "0" << "1" << Arg->getSourceRange();
Daniel Dunbar4493f792008-07-21 22:59:13 +0000743 } else {
Eli Friedman9aef7262009-12-04 00:30:06 +0000744 if (Result.getLimitedValue() > 3)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000745 return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
Chris Lattner21fb98e2009-09-23 06:06:36 +0000746 << "0" << "3" << Arg->getSourceRange();
Daniel Dunbar4493f792008-07-21 22:59:13 +0000747 }
748 }
749
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000750 return false;
Daniel Dunbar4493f792008-07-21 22:59:13 +0000751}
752
Chris Lattner21fb98e2009-09-23 06:06:36 +0000753/// SemaBuiltinEHReturnDataRegNo - Handle __builtin_eh_return_data_regno, the
754/// operand must be an integer constant.
755bool Sema::SemaBuiltinEHReturnDataRegNo(CallExpr *TheCall) {
756 llvm::APSInt Result;
757 if (!TheCall->getArg(0)->isIntegerConstantExpr(Result, Context))
758 return Diag(TheCall->getLocStart(), diag::err_expr_not_ice)
759 << TheCall->getArg(0)->getSourceRange();
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000760
Chris Lattner21fb98e2009-09-23 06:06:36 +0000761 return false;
762}
763
764
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +0000765/// SemaBuiltinObjectSize - Handle __builtin_object_size(void *ptr,
766/// int type). This simply type checks that type is one of the defined
767/// constants (0-3).
Eric Christopherfee667f2009-12-23 03:49:37 +0000768// For compatability check 0-3, llvm only handles 0 and 2.
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +0000769bool Sema::SemaBuiltinObjectSize(CallExpr *TheCall) {
770 Expr *Arg = TheCall->getArg(1);
Douglas Gregorcde01732009-05-19 22:10:17 +0000771 if (Arg->isTypeDependent())
772 return false;
773
Mike Stump1eb44332009-09-09 15:08:12 +0000774 QualType ArgType = Arg->getType();
John McCall183700f2009-09-21 23:43:11 +0000775 const BuiltinType *BT = ArgType->getAs<BuiltinType>();
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +0000776 llvm::APSInt Result(32);
Douglas Gregorcde01732009-05-19 22:10:17 +0000777 if (!BT || BT->getKind() != BuiltinType::Int)
778 return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument)
779 << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
780
781 if (Arg->isValueDependent())
782 return false;
783
784 if (!Arg->isIntegerConstantExpr(Result, Context)) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000785 return Diag(TheCall->getLocStart(), diag::err_object_size_invalid_argument)
786 << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +0000787 }
788
789 if (Result.getSExtValue() < 0 || Result.getSExtValue() > 3) {
Chris Lattnerfa25bbb2008-11-19 05:08:23 +0000790 return Diag(TheCall->getLocStart(), diag::err_argument_invalid_range)
791 << "0" << "3" << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +0000792 }
793
794 return false;
795}
796
Eli Friedman586d6a82009-05-03 06:04:26 +0000797/// SemaBuiltinLongjmp - Handle __builtin_longjmp(void *env[5], int val).
Eli Friedmand875fed2009-05-03 04:46:36 +0000798/// This checks that val is a constant 1.
799bool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) {
800 Expr *Arg = TheCall->getArg(1);
Douglas Gregorcde01732009-05-19 22:10:17 +0000801 if (Arg->isTypeDependent() || Arg->isValueDependent())
802 return false;
803
Eli Friedmand875fed2009-05-03 04:46:36 +0000804 llvm::APSInt Result(32);
805 if (!Arg->isIntegerConstantExpr(Result, Context) || Result != 1)
806 return Diag(TheCall->getLocStart(), diag::err_builtin_longjmp_invalid_val)
807 << SourceRange(Arg->getLocStart(), Arg->getLocEnd());
808
809 return false;
810}
811
Ted Kremenekd30ef872009-01-12 23:09:09 +0000812// Handle i > 1 ? "x" : "y", recursivelly
Ted Kremenek082d9362009-03-20 21:35:28 +0000813bool Sema::SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
814 bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +0000815 unsigned format_idx, unsigned firstDataArg) {
Douglas Gregorcde01732009-05-19 22:10:17 +0000816 if (E->isTypeDependent() || E->isValueDependent())
817 return false;
Ted Kremenekd30ef872009-01-12 23:09:09 +0000818
819 switch (E->getStmtClass()) {
820 case Stmt::ConditionalOperatorClass: {
Ted Kremenek082d9362009-03-20 21:35:28 +0000821 const ConditionalOperator *C = cast<ConditionalOperator>(E);
Chris Lattner813b70d2009-12-22 06:00:13 +0000822 return SemaCheckStringLiteral(C->getTrueExpr(), TheCall,
Douglas Gregor3c385e52009-02-14 18:57:46 +0000823 HasVAListArg, format_idx, firstDataArg)
Ted Kremenekd30ef872009-01-12 23:09:09 +0000824 && SemaCheckStringLiteral(C->getRHS(), TheCall,
Douglas Gregor3c385e52009-02-14 18:57:46 +0000825 HasVAListArg, format_idx, firstDataArg);
Ted Kremenekd30ef872009-01-12 23:09:09 +0000826 }
827
828 case Stmt::ImplicitCastExprClass: {
Ted Kremenek082d9362009-03-20 21:35:28 +0000829 const ImplicitCastExpr *Expr = cast<ImplicitCastExpr>(E);
Ted Kremenekd30ef872009-01-12 23:09:09 +0000830 return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +0000831 format_idx, firstDataArg);
Ted Kremenekd30ef872009-01-12 23:09:09 +0000832 }
833
834 case Stmt::ParenExprClass: {
Ted Kremenek082d9362009-03-20 21:35:28 +0000835 const ParenExpr *Expr = cast<ParenExpr>(E);
Ted Kremenekd30ef872009-01-12 23:09:09 +0000836 return SemaCheckStringLiteral(Expr->getSubExpr(), TheCall, HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +0000837 format_idx, firstDataArg);
Ted Kremenekd30ef872009-01-12 23:09:09 +0000838 }
Mike Stump1eb44332009-09-09 15:08:12 +0000839
Ted Kremenek082d9362009-03-20 21:35:28 +0000840 case Stmt::DeclRefExprClass: {
841 const DeclRefExpr *DR = cast<DeclRefExpr>(E);
Mike Stump1eb44332009-09-09 15:08:12 +0000842
Ted Kremenek082d9362009-03-20 21:35:28 +0000843 // As an exception, do not flag errors for variables binding to
844 // const string literals.
845 if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl())) {
846 bool isConstant = false;
847 QualType T = DR->getType();
Ted Kremenekd30ef872009-01-12 23:09:09 +0000848
Ted Kremenek082d9362009-03-20 21:35:28 +0000849 if (const ArrayType *AT = Context.getAsArrayType(T)) {
850 isConstant = AT->getElementType().isConstant(Context);
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000851 } else if (const PointerType *PT = T->getAs<PointerType>()) {
Mike Stump1eb44332009-09-09 15:08:12 +0000852 isConstant = T.isConstant(Context) &&
Ted Kremenek082d9362009-03-20 21:35:28 +0000853 PT->getPointeeType().isConstant(Context);
854 }
Mike Stump1eb44332009-09-09 15:08:12 +0000855
Ted Kremenek082d9362009-03-20 21:35:28 +0000856 if (isConstant) {
Sebastian Redl31310a22010-02-01 20:16:42 +0000857 if (const Expr *Init = VD->getAnyInitializer())
Ted Kremenek082d9362009-03-20 21:35:28 +0000858 return SemaCheckStringLiteral(Init, TheCall,
859 HasVAListArg, format_idx, firstDataArg);
860 }
Mike Stump1eb44332009-09-09 15:08:12 +0000861
Anders Carlssond966a552009-06-28 19:55:58 +0000862 // For vprintf* functions (i.e., HasVAListArg==true), we add a
863 // special check to see if the format string is a function parameter
864 // of the function calling the printf function. If the function
865 // has an attribute indicating it is a printf-like function, then we
866 // should suppress warnings concerning non-literals being used in a call
867 // to a vprintf function. For example:
868 //
869 // void
870 // logmessage(char const *fmt __attribute__ (format (printf, 1, 2)), ...){
871 // va_list ap;
872 // va_start(ap, fmt);
873 // vprintf(fmt, ap); // Do NOT emit a warning about "fmt".
874 // ...
875 //
876 //
877 // FIXME: We don't have full attribute support yet, so just check to see
878 // if the argument is a DeclRefExpr that references a parameter. We'll
879 // add proper support for checking the attribute later.
880 if (HasVAListArg)
881 if (isa<ParmVarDecl>(VD))
882 return true;
Ted Kremenek082d9362009-03-20 21:35:28 +0000883 }
Mike Stump1eb44332009-09-09 15:08:12 +0000884
Ted Kremenek082d9362009-03-20 21:35:28 +0000885 return false;
886 }
Ted Kremenekd30ef872009-01-12 23:09:09 +0000887
Anders Carlsson8f031b32009-06-27 04:05:33 +0000888 case Stmt::CallExprClass: {
889 const CallExpr *CE = cast<CallExpr>(E);
Mike Stump1eb44332009-09-09 15:08:12 +0000890 if (const ImplicitCastExpr *ICE
Anders Carlsson8f031b32009-06-27 04:05:33 +0000891 = dyn_cast<ImplicitCastExpr>(CE->getCallee())) {
892 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
893 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000894 if (const FormatArgAttr *FA = FD->getAttr<FormatArgAttr>()) {
Anders Carlsson8f031b32009-06-27 04:05:33 +0000895 unsigned ArgIndex = FA->getFormatIdx();
896 const Expr *Arg = CE->getArg(ArgIndex - 1);
Mike Stump1eb44332009-09-09 15:08:12 +0000897
898 return SemaCheckStringLiteral(Arg, TheCall, HasVAListArg,
Anders Carlsson8f031b32009-06-27 04:05:33 +0000899 format_idx, firstDataArg);
900 }
901 }
902 }
903 }
Mike Stump1eb44332009-09-09 15:08:12 +0000904
Anders Carlsson8f031b32009-06-27 04:05:33 +0000905 return false;
906 }
Ted Kremenek082d9362009-03-20 21:35:28 +0000907 case Stmt::ObjCStringLiteralClass:
908 case Stmt::StringLiteralClass: {
909 const StringLiteral *StrE = NULL;
Mike Stump1eb44332009-09-09 15:08:12 +0000910
Ted Kremenek082d9362009-03-20 21:35:28 +0000911 if (const ObjCStringLiteral *ObjCFExpr = dyn_cast<ObjCStringLiteral>(E))
Ted Kremenekd30ef872009-01-12 23:09:09 +0000912 StrE = ObjCFExpr->getString();
913 else
Ted Kremenek082d9362009-03-20 21:35:28 +0000914 StrE = cast<StringLiteral>(E);
Mike Stump1eb44332009-09-09 15:08:12 +0000915
Ted Kremenekd30ef872009-01-12 23:09:09 +0000916 if (StrE) {
Mike Stump1eb44332009-09-09 15:08:12 +0000917 CheckPrintfString(StrE, E, TheCall, HasVAListArg, format_idx,
Douglas Gregor3c385e52009-02-14 18:57:46 +0000918 firstDataArg);
Ted Kremenekd30ef872009-01-12 23:09:09 +0000919 return true;
920 }
Mike Stump1eb44332009-09-09 15:08:12 +0000921
Ted Kremenekd30ef872009-01-12 23:09:09 +0000922 return false;
923 }
Mike Stump1eb44332009-09-09 15:08:12 +0000924
Ted Kremenek082d9362009-03-20 21:35:28 +0000925 default:
926 return false;
Ted Kremenekd30ef872009-01-12 23:09:09 +0000927 }
928}
929
Fariborz Jahaniane898f8a2009-05-21 18:48:51 +0000930void
Mike Stump1eb44332009-09-09 15:08:12 +0000931Sema::CheckNonNullArguments(const NonNullAttr *NonNull,
932 const CallExpr *TheCall) {
Fariborz Jahaniane898f8a2009-05-21 18:48:51 +0000933 for (NonNullAttr::iterator i = NonNull->begin(), e = NonNull->end();
934 i != e; ++i) {
Chris Lattner12b97ff2009-05-25 18:23:36 +0000935 const Expr *ArgExpr = TheCall->getArg(*i);
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000936 if (ArgExpr->isNullPointerConstant(Context,
Douglas Gregorce940492009-09-25 04:25:58 +0000937 Expr::NPC_ValueDependentIsNotNull))
Chris Lattner12b97ff2009-05-25 18:23:36 +0000938 Diag(TheCall->getCallee()->getLocStart(), diag::warn_null_arg)
939 << ArgExpr->getSourceRange();
Fariborz Jahaniane898f8a2009-05-21 18:48:51 +0000940 }
941}
Ted Kremenekd30ef872009-01-12 23:09:09 +0000942
Chris Lattner59907c42007-08-10 20:18:51 +0000943/// CheckPrintfArguments - Check calls to printf (and similar functions) for
Mike Stump1eb44332009-09-09 15:08:12 +0000944/// correct use of format strings.
Ted Kremenek71895b92007-08-14 17:39:48 +0000945///
946/// HasVAListArg - A predicate indicating whether the printf-like
947/// function is passed an explicit va_arg argument (e.g., vprintf)
948///
949/// format_idx - The index into Args for the format string.
950///
951/// Improper format strings to functions in the printf family can be
952/// the source of bizarre bugs and very serious security holes. A
953/// good source of information is available in the following paper
954/// (which includes additional references):
Chris Lattner59907c42007-08-10 20:18:51 +0000955///
956/// FormatGuard: Automatic Protection From printf Format String
957/// Vulnerabilities, Proceedings of the 10th USENIX Security Symposium, 2001.
Ted Kremenek71895b92007-08-14 17:39:48 +0000958///
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000959/// TODO:
Ted Kremenek71895b92007-08-14 17:39:48 +0000960/// Functionality implemented:
961///
962/// We can statically check the following properties for string
963/// literal format strings for non v.*printf functions (where the
964/// arguments are passed directly):
965//
966/// (1) Are the number of format conversions equal to the number of
967/// data arguments?
968///
969/// (2) Does each format conversion correctly match the type of the
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000970/// corresponding data argument?
Ted Kremenek71895b92007-08-14 17:39:48 +0000971///
972/// Moreover, for all printf functions we can:
973///
974/// (3) Check for a missing format string (when not caught by type checking).
975///
976/// (4) Check for no-operation flags; e.g. using "#" with format
977/// conversion 'c' (TODO)
978///
979/// (5) Check the use of '%n', a major source of security holes.
980///
981/// (6) Check for malformed format conversions that don't specify anything.
982///
983/// (7) Check for empty format strings. e.g: printf("");
984///
985/// (8) Check that the format string is a wide literal.
986///
987/// All of these checks can be done by parsing the format string.
988///
Chris Lattner59907c42007-08-10 20:18:51 +0000989void
Mike Stump1eb44332009-09-09 15:08:12 +0000990Sema::CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +0000991 unsigned format_idx, unsigned firstDataArg) {
Ted Kremenek082d9362009-03-20 21:35:28 +0000992 const Expr *Fn = TheCall->getCallee();
Chris Lattner925e60d2007-12-28 05:29:59 +0000993
Sebastian Redl4a2614e2009-11-17 18:02:24 +0000994 // The way the format attribute works in GCC, the implicit this argument
995 // of member functions is counted. However, it doesn't appear in our own
996 // lists, so decrement format_idx in that case.
997 if (isa<CXXMemberCallExpr>(TheCall)) {
998 // Catch a format attribute mistakenly referring to the object argument.
999 if (format_idx == 0)
1000 return;
1001 --format_idx;
1002 if(firstDataArg != 0)
1003 --firstDataArg;
1004 }
1005
Mike Stump1eb44332009-09-09 15:08:12 +00001006 // CHECK: printf-like function is called with no format string.
Chris Lattner925e60d2007-12-28 05:29:59 +00001007 if (format_idx >= TheCall->getNumArgs()) {
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00001008 Diag(TheCall->getRParenLoc(), diag::warn_printf_missing_format_string)
1009 << Fn->getSourceRange();
Ted Kremenek71895b92007-08-14 17:39:48 +00001010 return;
1011 }
Mike Stump1eb44332009-09-09 15:08:12 +00001012
Ted Kremenek082d9362009-03-20 21:35:28 +00001013 const Expr *OrigFormatExpr = TheCall->getArg(format_idx)->IgnoreParenCasts();
Mike Stump1eb44332009-09-09 15:08:12 +00001014
Chris Lattner59907c42007-08-10 20:18:51 +00001015 // CHECK: format string is not a string literal.
Mike Stump1eb44332009-09-09 15:08:12 +00001016 //
Ted Kremenek71895b92007-08-14 17:39:48 +00001017 // Dynamically generated format strings are difficult to
1018 // automatically vet at compile time. Requiring that format strings
1019 // are string literals: (1) permits the checking of format strings by
1020 // the compiler and thereby (2) can practically remove the source of
1021 // many format string exploits.
Ted Kremenek7ff22b22008-06-16 18:00:42 +00001022
Mike Stump1eb44332009-09-09 15:08:12 +00001023 // Format string can be either ObjC string (e.g. @"%d") or
Ted Kremenek7ff22b22008-06-16 18:00:42 +00001024 // C string (e.g. "%d")
Mike Stump1eb44332009-09-09 15:08:12 +00001025 // ObjC string uses the same format specifiers as C string, so we can use
Ted Kremenek7ff22b22008-06-16 18:00:42 +00001026 // the same format string checking logic for both ObjC and C strings.
Chris Lattner1cd3e1f2009-04-29 04:49:34 +00001027 if (SemaCheckStringLiteral(OrigFormatExpr, TheCall, HasVAListArg, format_idx,
1028 firstDataArg))
1029 return; // Literal format string found, check done!
Ted Kremenek7ff22b22008-06-16 18:00:42 +00001030
Chris Lattner655f1412009-04-29 04:59:47 +00001031 // If there are no arguments specified, warn with -Wformat-security, otherwise
1032 // warn only with -Wformat-nonliteral.
1033 if (TheCall->getNumArgs() == format_idx+1)
Mike Stump1eb44332009-09-09 15:08:12 +00001034 Diag(TheCall->getArg(format_idx)->getLocStart(),
Chris Lattner655f1412009-04-29 04:59:47 +00001035 diag::warn_printf_nonliteral_noargs)
1036 << OrigFormatExpr->getSourceRange();
1037 else
Mike Stump1eb44332009-09-09 15:08:12 +00001038 Diag(TheCall->getArg(format_idx)->getLocStart(),
Chris Lattner655f1412009-04-29 04:59:47 +00001039 diag::warn_printf_nonliteral)
1040 << OrigFormatExpr->getSourceRange();
Ted Kremenekd30ef872009-01-12 23:09:09 +00001041}
Ted Kremenek71895b92007-08-14 17:39:48 +00001042
Ted Kremeneke0e53132010-01-28 23:39:18 +00001043namespace {
Ted Kremenek74d56a12010-02-04 20:46:58 +00001044class CheckPrintfHandler : public analyze_printf::FormatStringHandler {
Ted Kremeneke0e53132010-01-28 23:39:18 +00001045 Sema &S;
1046 const StringLiteral *FExpr;
1047 const Expr *OrigFormatExpr;
Ted Kremeneke0e53132010-01-28 23:39:18 +00001048 const unsigned NumDataArgs;
1049 const bool IsObjCLiteral;
1050 const char *Beg; // Start of format string.
Ted Kremenek0d277352010-01-29 01:06:55 +00001051 const bool HasVAListArg;
1052 const CallExpr *TheCall;
1053 unsigned FormatIdx;
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001054 llvm::BitVector CoveredArgs;
Ted Kremenekefaff192010-02-27 01:41:03 +00001055 bool usesPositionalArgs;
1056 bool atFirstArg;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001057public:
Ted Kremeneke0e53132010-01-28 23:39:18 +00001058 CheckPrintfHandler(Sema &s, const StringLiteral *fexpr,
1059 const Expr *origFormatExpr,
1060 unsigned numDataArgs, bool isObjCLiteral,
Ted Kremenek0d277352010-01-29 01:06:55 +00001061 const char *beg, bool hasVAListArg,
1062 const CallExpr *theCall, unsigned formatIdx)
Ted Kremeneke0e53132010-01-28 23:39:18 +00001063 : S(s), FExpr(fexpr), OrigFormatExpr(origFormatExpr),
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001064 NumDataArgs(numDataArgs),
Ted Kremenek0d277352010-01-29 01:06:55 +00001065 IsObjCLiteral(isObjCLiteral), Beg(beg),
1066 HasVAListArg(hasVAListArg),
Ted Kremenekefaff192010-02-27 01:41:03 +00001067 TheCall(theCall), FormatIdx(formatIdx),
1068 usesPositionalArgs(false), atFirstArg(true) {
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001069 CoveredArgs.resize(numDataArgs);
1070 CoveredArgs.reset();
1071 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001072
Ted Kremenek07d161f2010-01-29 01:50:07 +00001073 void DoneProcessing();
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001074
Ted Kremenek808015a2010-01-29 03:16:21 +00001075 void HandleIncompleteFormatSpecifier(const char *startSpecifier,
1076 unsigned specifierLen);
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001077
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001078 bool
Ted Kremenek74d56a12010-02-04 20:46:58 +00001079 HandleInvalidConversionSpecifier(const analyze_printf::FormatSpecifier &FS,
1080 const char *startSpecifier,
1081 unsigned specifierLen);
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001082
Ted Kremenekefaff192010-02-27 01:41:03 +00001083 virtual void HandleInvalidPosition(const char *startSpecifier,
1084 unsigned specifierLen,
1085 analyze_printf::PositionContext p);
1086
1087 virtual void HandleZeroPosition(const char *startPos, unsigned posLen);
1088
Ted Kremeneke0e53132010-01-28 23:39:18 +00001089 void HandleNullChar(const char *nullCharacter);
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001090
Ted Kremeneke0e53132010-01-28 23:39:18 +00001091 bool HandleFormatSpecifier(const analyze_printf::FormatSpecifier &FS,
1092 const char *startSpecifier,
1093 unsigned specifierLen);
1094private:
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001095 SourceRange getFormatStringRange();
1096 SourceRange getFormatSpecifierRange(const char *startSpecifier,
Ted Kremenek0e5675d2010-02-10 02:16:30 +00001097 unsigned specifierLen);
Ted Kremeneke0e53132010-01-28 23:39:18 +00001098 SourceLocation getLocationOfByte(const char *x);
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001099
Ted Kremenekefaff192010-02-27 01:41:03 +00001100 bool HandleAmount(const analyze_printf::OptionalAmount &Amt, unsigned k,
1101 const char *startSpecifier, unsigned specifierLen);
Ted Kremenek5c41ee82010-02-11 09:27:41 +00001102 void HandleFlags(const analyze_printf::FormatSpecifier &FS,
1103 llvm::StringRef flag, llvm::StringRef cspec,
1104 const char *startSpecifier, unsigned specifierLen);
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001105
Ted Kremenek0d277352010-01-29 01:06:55 +00001106 const Expr *getDataArg(unsigned i) const;
Ted Kremeneke0e53132010-01-28 23:39:18 +00001107};
1108}
1109
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001110SourceRange CheckPrintfHandler::getFormatStringRange() {
Ted Kremeneke0e53132010-01-28 23:39:18 +00001111 return OrigFormatExpr->getSourceRange();
1112}
1113
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001114SourceRange CheckPrintfHandler::
1115getFormatSpecifierRange(const char *startSpecifier, unsigned specifierLen) {
1116 return SourceRange(getLocationOfByte(startSpecifier),
Ted Kremenek0e5675d2010-02-10 02:16:30 +00001117 getLocationOfByte(startSpecifier+specifierLen-1));
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001118}
1119
Ted Kremeneke0e53132010-01-28 23:39:18 +00001120SourceLocation CheckPrintfHandler::getLocationOfByte(const char *x) {
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001121 return S.getLocationOfStringLiteralByte(FExpr, x - Beg);
Ted Kremeneke0e53132010-01-28 23:39:18 +00001122}
1123
Ted Kremenek26ac2e02010-01-29 02:40:24 +00001124void CheckPrintfHandler::
Ted Kremenek808015a2010-01-29 03:16:21 +00001125HandleIncompleteFormatSpecifier(const char *startSpecifier,
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001126 unsigned specifierLen) {
Ted Kremenek808015a2010-01-29 03:16:21 +00001127 SourceLocation Loc = getLocationOfByte(startSpecifier);
1128 S.Diag(Loc, diag::warn_printf_incomplete_specifier)
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001129 << getFormatSpecifierRange(startSpecifier, specifierLen);
Ted Kremenek808015a2010-01-29 03:16:21 +00001130}
1131
Ted Kremenekefaff192010-02-27 01:41:03 +00001132void
1133CheckPrintfHandler::HandleInvalidPosition(const char *startPos, unsigned posLen,
1134 analyze_printf::PositionContext p) {
1135 SourceLocation Loc = getLocationOfByte(startPos);
1136 S.Diag(Loc, diag::warn_printf_invalid_positional_specifier)
1137 << (unsigned) p << getFormatSpecifierRange(startPos, posLen);
1138}
1139
1140void CheckPrintfHandler::HandleZeroPosition(const char *startPos,
1141 unsigned posLen) {
1142 SourceLocation Loc = getLocationOfByte(startPos);
1143 S.Diag(Loc, diag::warn_printf_zero_positional_specifier)
1144 << getFormatSpecifierRange(startPos, posLen);
1145}
1146
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001147bool CheckPrintfHandler::
Ted Kremenek26ac2e02010-01-29 02:40:24 +00001148HandleInvalidConversionSpecifier(const analyze_printf::FormatSpecifier &FS,
1149 const char *startSpecifier,
1150 unsigned specifierLen) {
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001151
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001152 unsigned argIndex = FS.getArgIndex();
1153 bool keepGoing = true;
1154 if (argIndex < NumDataArgs) {
1155 // Consider the argument coverered, even though the specifier doesn't
1156 // make sense.
1157 CoveredArgs.set(argIndex);
1158 }
1159 else {
1160 // If argIndex exceeds the number of data arguments we
1161 // don't issue a warning because that is just a cascade of warnings (and
1162 // they may have intended '%%' anyway). We don't want to continue processing
1163 // the format string after this point, however, as we will like just get
1164 // gibberish when trying to match arguments.
1165 keepGoing = false;
1166 }
1167
Ted Kremenek808015a2010-01-29 03:16:21 +00001168 const analyze_printf::ConversionSpecifier &CS =
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001169 FS.getConversionSpecifier();
Ted Kremenek808015a2010-01-29 03:16:21 +00001170 SourceLocation Loc = getLocationOfByte(CS.getStart());
Ted Kremenek26ac2e02010-01-29 02:40:24 +00001171 S.Diag(Loc, diag::warn_printf_invalid_conversion)
Ted Kremenek808015a2010-01-29 03:16:21 +00001172 << llvm::StringRef(CS.getStart(), CS.getLength())
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001173 << getFormatSpecifierRange(startSpecifier, specifierLen);
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001174
1175 return keepGoing;
Ted Kremenek26ac2e02010-01-29 02:40:24 +00001176}
1177
Ted Kremeneke0e53132010-01-28 23:39:18 +00001178void CheckPrintfHandler::HandleNullChar(const char *nullCharacter) {
1179 // The presence of a null character is likely an error.
1180 S.Diag(getLocationOfByte(nullCharacter),
1181 diag::warn_printf_format_string_contains_null_char)
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001182 << getFormatStringRange();
Ted Kremeneke0e53132010-01-28 23:39:18 +00001183}
1184
Ted Kremenek0d277352010-01-29 01:06:55 +00001185const Expr *CheckPrintfHandler::getDataArg(unsigned i) const {
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001186 return TheCall->getArg(FormatIdx + i + 1);
Ted Kremenek0d277352010-01-29 01:06:55 +00001187}
1188
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001189
Ted Kremenekd635c5f2010-01-30 00:49:51 +00001190
Ted Kremenek5c41ee82010-02-11 09:27:41 +00001191void CheckPrintfHandler::HandleFlags(const analyze_printf::FormatSpecifier &FS,
1192 llvm::StringRef flag,
1193 llvm::StringRef cspec,
1194 const char *startSpecifier,
1195 unsigned specifierLen) {
1196 const analyze_printf::ConversionSpecifier &CS = FS.getConversionSpecifier();
1197 S.Diag(getLocationOfByte(CS.getStart()), diag::warn_printf_nonsensical_flag)
1198 << flag << cspec << getFormatSpecifierRange(startSpecifier, specifierLen);
1199}
1200
Ted Kremenek0d277352010-01-29 01:06:55 +00001201bool
1202CheckPrintfHandler::HandleAmount(const analyze_printf::OptionalAmount &Amt,
Ted Kremenekefaff192010-02-27 01:41:03 +00001203 unsigned k, const char *startSpecifier,
Ted Kremenek0e5675d2010-02-10 02:16:30 +00001204 unsigned specifierLen) {
Ted Kremenek0d277352010-01-29 01:06:55 +00001205
1206 if (Amt.hasDataArgument()) {
Ted Kremenek0d277352010-01-29 01:06:55 +00001207 if (!HasVAListArg) {
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001208 unsigned argIndex = Amt.getArgIndex();
1209 if (argIndex >= NumDataArgs) {
Ted Kremenekefaff192010-02-27 01:41:03 +00001210 S.Diag(getLocationOfByte(Amt.getStart()),
1211 diag::warn_printf_asterisk_missing_arg)
1212 << k << getFormatSpecifierRange(startSpecifier, specifierLen);
Ted Kremenek0d277352010-01-29 01:06:55 +00001213 // Don't do any more checking. We will just emit
1214 // spurious errors.
1215 return false;
1216 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001217
Ted Kremenek0d277352010-01-29 01:06:55 +00001218 // Type check the data argument. It should be an 'int'.
Ted Kremenek31f8e322010-01-29 23:32:22 +00001219 // Although not in conformance with C99, we also allow the argument to be
1220 // an 'unsigned int' as that is a reasonably safe case. GCC also
1221 // doesn't emit a warning for that case.
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001222 CoveredArgs.set(argIndex);
1223 const Expr *Arg = getDataArg(argIndex);
Ted Kremenek0d277352010-01-29 01:06:55 +00001224 QualType T = Arg->getType();
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001225
1226 const analyze_printf::ArgTypeResult &ATR = Amt.getArgType(S.Context);
1227 assert(ATR.isValid());
1228
1229 if (!ATR.matchesType(S.Context, T)) {
Ted Kremenekefaff192010-02-27 01:41:03 +00001230 S.Diag(getLocationOfByte(Amt.getStart()),
1231 diag::warn_printf_asterisk_wrong_type)
1232 << k
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001233 << ATR.getRepresentativeType(S.Context) << T
Ted Kremenekd635c5f2010-01-30 00:49:51 +00001234 << getFormatSpecifierRange(startSpecifier, specifierLen)
1235 << Arg->getSourceRange();
Ted Kremenek0d277352010-01-29 01:06:55 +00001236 // Don't do any more checking. We will just emit
1237 // spurious errors.
1238 return false;
1239 }
1240 }
1241 }
1242 return true;
1243}
Ted Kremenek0d277352010-01-29 01:06:55 +00001244
Ted Kremeneke0e53132010-01-28 23:39:18 +00001245bool
Ted Kremenek5c41ee82010-02-11 09:27:41 +00001246CheckPrintfHandler::HandleFormatSpecifier(const analyze_printf::FormatSpecifier
1247 &FS,
Ted Kremeneke0e53132010-01-28 23:39:18 +00001248 const char *startSpecifier,
1249 unsigned specifierLen) {
1250
Ted Kremenekefaff192010-02-27 01:41:03 +00001251 using namespace analyze_printf;
Ted Kremeneke0e53132010-01-28 23:39:18 +00001252 const ConversionSpecifier &CS = FS.getConversionSpecifier();
1253
Ted Kremenekefaff192010-02-27 01:41:03 +00001254 if (atFirstArg) {
1255 atFirstArg = false;
1256 usesPositionalArgs = FS.usesPositionalArg();
1257 }
1258 else if (usesPositionalArgs != FS.usesPositionalArg()) {
1259 // Cannot mix-and-match positional and non-positional arguments.
1260 S.Diag(getLocationOfByte(CS.getStart()),
1261 diag::warn_printf_mix_positional_nonpositional_args)
1262 << getFormatSpecifierRange(startSpecifier, specifierLen);
Ted Kremenek0d277352010-01-29 01:06:55 +00001263 return false;
1264 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001265
Ted Kremenekefaff192010-02-27 01:41:03 +00001266 // First check if the field width, precision, and conversion specifier
1267 // have matching data arguments.
1268 if (!HandleAmount(FS.getFieldWidth(), /* field width */ 0,
1269 startSpecifier, specifierLen)) {
1270 return false;
1271 }
1272
1273 if (!HandleAmount(FS.getPrecision(), /* precision */ 1,
1274 startSpecifier, specifierLen)) {
Ted Kremenek0d277352010-01-29 01:06:55 +00001275 return false;
1276 }
1277
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001278 if (!CS.consumesDataArgument()) {
1279 // FIXME: Technically specifying a precision or field width here
1280 // makes no sense. Worth issuing a warning at some point.
Ted Kremenek0e5675d2010-02-10 02:16:30 +00001281 return true;
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001282 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001283
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001284 // Consume the argument.
1285 unsigned argIndex = FS.getArgIndex();
Ted Kremeneke3fc5472010-02-27 08:34:51 +00001286 if (argIndex < NumDataArgs) {
1287 // The check to see if the argIndex is valid will come later.
1288 // We set the bit here because we may exit early from this
1289 // function if we encounter some other error.
1290 CoveredArgs.set(argIndex);
1291 }
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001292
1293 // Check for using an Objective-C specific conversion specifier
1294 // in a non-ObjC literal.
1295 if (!IsObjCLiteral && CS.isObjCArg()) {
1296 return HandleInvalidConversionSpecifier(FS, startSpecifier, specifierLen);
1297 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001298
Ted Kremeneke82d8042010-01-29 01:35:25 +00001299 // Are we using '%n'? Issue a warning about this being
1300 // a possible security issue.
1301 if (CS.getKind() == ConversionSpecifier::OutIntPtrArg) {
1302 S.Diag(getLocationOfByte(CS.getStart()), diag::warn_printf_write_back)
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001303 << getFormatSpecifierRange(startSpecifier, specifierLen);
Ted Kremeneke82d8042010-01-29 01:35:25 +00001304 // Continue checking the other format specifiers.
1305 return true;
1306 }
Ted Kremenek5c41ee82010-02-11 09:27:41 +00001307
1308 if (CS.getKind() == ConversionSpecifier::VoidPtrArg) {
1309 if (FS.getPrecision().getHowSpecified() != OptionalAmount::NotSpecified)
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001310 S.Diag(getLocationOfByte(CS.getStart()),
Ted Kremenek5c41ee82010-02-11 09:27:41 +00001311 diag::warn_printf_nonsensical_precision)
1312 << CS.getCharacters()
1313 << getFormatSpecifierRange(startSpecifier, specifierLen);
1314 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001315 if (CS.getKind() == ConversionSpecifier::VoidPtrArg ||
1316 CS.getKind() == ConversionSpecifier::CStrArg) {
Ted Kremenek5c41ee82010-02-11 09:27:41 +00001317 // FIXME: Instead of using "0", "+", etc., eventually get them from
1318 // the FormatSpecifier.
1319 if (FS.hasLeadingZeros())
1320 HandleFlags(FS, "0", CS.getCharacters(), startSpecifier, specifierLen);
1321 if (FS.hasPlusPrefix())
1322 HandleFlags(FS, "+", CS.getCharacters(), startSpecifier, specifierLen);
1323 if (FS.hasSpacePrefix())
1324 HandleFlags(FS, " ", CS.getCharacters(), startSpecifier, specifierLen);
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001325 }
1326
Ted Kremenekda51f0d2010-01-29 01:43:31 +00001327 // The remaining checks depend on the data arguments.
1328 if (HasVAListArg)
1329 return true;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001330
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001331 if (argIndex >= NumDataArgs) {
Ted Kremenekda51f0d2010-01-29 01:43:31 +00001332 S.Diag(getLocationOfByte(CS.getStart()),
1333 diag::warn_printf_insufficient_data_args)
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001334 << getFormatSpecifierRange(startSpecifier, specifierLen);
Ted Kremenekda51f0d2010-01-29 01:43:31 +00001335 // Don't do any more checking.
1336 return false;
1337 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001338
Ted Kremenekd635c5f2010-01-30 00:49:51 +00001339 // Now type check the data expression that matches the
1340 // format specifier.
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001341 const Expr *Ex = getDataArg(argIndex);
Ted Kremenekd635c5f2010-01-30 00:49:51 +00001342 const analyze_printf::ArgTypeResult &ATR = FS.getArgType(S.Context);
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001343 if (ATR.isValid() && !ATR.matchesType(S.Context, Ex->getType())) {
1344 // Check if we didn't match because of an implicit cast from a 'char'
1345 // or 'short' to an 'int'. This is done because printf is a varargs
1346 // function.
1347 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Ex))
1348 if (ICE->getType() == S.Context.IntTy)
1349 if (ATR.matchesType(S.Context, ICE->getSubExpr()->getType()))
1350 return true;
Ted Kremenek105d41c2010-02-01 19:38:10 +00001351
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001352 S.Diag(getLocationOfByte(CS.getStart()),
1353 diag::warn_printf_conversion_argument_type_mismatch)
1354 << ATR.getRepresentativeType(S.Context) << Ex->getType()
Ted Kremenek1497bff2010-02-11 19:37:25 +00001355 << getFormatSpecifierRange(startSpecifier, specifierLen)
1356 << Ex->getSourceRange();
Ted Kremenekd635c5f2010-01-30 00:49:51 +00001357 }
Ted Kremeneke0e53132010-01-28 23:39:18 +00001358
1359 return true;
1360}
1361
Ted Kremenek07d161f2010-01-29 01:50:07 +00001362void CheckPrintfHandler::DoneProcessing() {
1363 // Does the number of data arguments exceed the number of
1364 // format conversions in the format string?
Ted Kremenek7f70dc82010-02-26 19:18:41 +00001365 if (!HasVAListArg) {
1366 // Find any arguments that weren't covered.
1367 CoveredArgs.flip();
1368 signed notCoveredArg = CoveredArgs.find_first();
1369 if (notCoveredArg >= 0) {
1370 assert((unsigned)notCoveredArg < NumDataArgs);
1371 S.Diag(getDataArg((unsigned) notCoveredArg)->getLocStart(),
1372 diag::warn_printf_data_arg_not_used)
1373 << getFormatStringRange();
1374 }
1375 }
Ted Kremenek07d161f2010-01-29 01:50:07 +00001376}
Ted Kremeneke0e53132010-01-28 23:39:18 +00001377
Ted Kremenekf88c8e02010-01-29 20:55:36 +00001378void Sema::CheckPrintfString(const StringLiteral *FExpr,
Ted Kremenek0e5675d2010-02-10 02:16:30 +00001379 const Expr *OrigFormatExpr,
1380 const CallExpr *TheCall, bool HasVAListArg,
1381 unsigned format_idx, unsigned firstDataArg) {
1382
Ted Kremeneke0e53132010-01-28 23:39:18 +00001383 // CHECK: is the format string a wide literal?
1384 if (FExpr->isWide()) {
1385 Diag(FExpr->getLocStart(),
1386 diag::warn_printf_format_string_is_wide_literal)
1387 << OrigFormatExpr->getSourceRange();
1388 return;
1389 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001390
Ted Kremeneke0e53132010-01-28 23:39:18 +00001391 // Str - The format string. NOTE: this is NOT null-terminated!
1392 const char *Str = FExpr->getStrData();
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001393
Ted Kremeneke0e53132010-01-28 23:39:18 +00001394 // CHECK: empty format string?
1395 unsigned StrLen = FExpr->getByteLength();
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001396
Ted Kremeneke0e53132010-01-28 23:39:18 +00001397 if (StrLen == 0) {
1398 Diag(FExpr->getLocStart(), diag::warn_printf_empty_format_string)
1399 << OrigFormatExpr->getSourceRange();
1400 return;
1401 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001402
Ted Kremeneke0e53132010-01-28 23:39:18 +00001403 CheckPrintfHandler H(*this, FExpr, OrigFormatExpr,
1404 TheCall->getNumArgs() - firstDataArg,
Ted Kremenek0d277352010-01-29 01:06:55 +00001405 isa<ObjCStringLiteral>(OrigFormatExpr), Str,
1406 HasVAListArg, TheCall, format_idx);
Ted Kremeneke0e53132010-01-28 23:39:18 +00001407
Ted Kremenek74d56a12010-02-04 20:46:58 +00001408 if (!analyze_printf::ParseFormatString(H, Str, Str + StrLen))
Ted Kremenek808015a2010-01-29 03:16:21 +00001409 H.DoneProcessing();
Ted Kremenekce7024e2010-01-28 01:18:22 +00001410}
1411
Ted Kremenek06de2762007-08-17 16:46:58 +00001412//===--- CHECK: Return Address of Stack Variable --------------------------===//
1413
1414static DeclRefExpr* EvalVal(Expr *E);
1415static DeclRefExpr* EvalAddr(Expr* E);
1416
1417/// CheckReturnStackAddr - Check if a return statement returns the address
1418/// of a stack variable.
1419void
1420Sema::CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
1421 SourceLocation ReturnLoc) {
Mike Stump1eb44332009-09-09 15:08:12 +00001422
Ted Kremenek06de2762007-08-17 16:46:58 +00001423 // Perform checking for returned stack addresses.
Steve Naroffdd972f22008-09-05 22:11:13 +00001424 if (lhsType->isPointerType() || lhsType->isBlockPointerType()) {
Ted Kremenek06de2762007-08-17 16:46:58 +00001425 if (DeclRefExpr *DR = EvalAddr(RetValExp))
Chris Lattner3c73c412008-11-19 08:23:25 +00001426 Diag(DR->getLocStart(), diag::warn_ret_stack_addr)
Chris Lattner08631c52008-11-23 21:45:46 +00001427 << DR->getDecl()->getDeclName() << RetValExp->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +00001428
Steve Naroffc50a4a52008-09-16 22:25:10 +00001429 // Skip over implicit cast expressions when checking for block expressions.
Chris Lattner4ca606e2009-09-08 00:36:37 +00001430 RetValExp = RetValExp->IgnoreParenCasts();
Steve Naroffc50a4a52008-09-16 22:25:10 +00001431
Chris Lattner9e6b37a2009-10-30 04:01:58 +00001432 if (BlockExpr *C = dyn_cast<BlockExpr>(RetValExp))
Mike Stump397195b2009-04-17 00:09:41 +00001433 if (C->hasBlockDeclRefExprs())
1434 Diag(C->getLocStart(), diag::err_ret_local_block)
1435 << C->getSourceRange();
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001436
Chris Lattner9e6b37a2009-10-30 04:01:58 +00001437 if (AddrLabelExpr *ALE = dyn_cast<AddrLabelExpr>(RetValExp))
1438 Diag(ALE->getLocStart(), diag::warn_ret_addr_label)
1439 << ALE->getSourceRange();
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001440
Mike Stumpac5fc7c2009-08-04 21:02:39 +00001441 } else if (lhsType->isReferenceType()) {
1442 // Perform checking for stack values returned by reference.
Douglas Gregor49badde2008-10-27 19:41:14 +00001443 // Check for a reference to the stack
1444 if (DeclRefExpr *DR = EvalVal(RetValExp))
Chris Lattnerdcd5ef12008-11-19 05:27:50 +00001445 Diag(DR->getLocStart(), diag::warn_ret_stack_ref)
Chris Lattner08631c52008-11-23 21:45:46 +00001446 << DR->getDecl()->getDeclName() << RetValExp->getSourceRange();
Ted Kremenek06de2762007-08-17 16:46:58 +00001447 }
1448}
1449
1450/// EvalAddr - EvalAddr and EvalVal are mutually recursive functions that
1451/// check if the expression in a return statement evaluates to an address
1452/// to a location on the stack. The recursion is used to traverse the
1453/// AST of the return expression, with recursion backtracking when we
1454/// encounter a subexpression that (1) clearly does not lead to the address
1455/// of a stack variable or (2) is something we cannot determine leads to
1456/// the address of a stack variable based on such local checking.
1457///
Ted Kremeneke8c600f2007-08-28 17:02:55 +00001458/// EvalAddr processes expressions that are pointers that are used as
1459/// references (and not L-values). EvalVal handles all other values.
Mike Stump1eb44332009-09-09 15:08:12 +00001460/// At the base case of the recursion is a check for a DeclRefExpr* in
Ted Kremenek06de2762007-08-17 16:46:58 +00001461/// the refers to a stack variable.
1462///
1463/// This implementation handles:
1464///
1465/// * pointer-to-pointer casts
1466/// * implicit conversions from array references to pointers
1467/// * taking the address of fields
1468/// * arbitrary interplay between "&" and "*" operators
1469/// * pointer arithmetic from an address of a stack variable
1470/// * taking the address of an array element where the array is on the stack
1471static DeclRefExpr* EvalAddr(Expr *E) {
Ted Kremenek06de2762007-08-17 16:46:58 +00001472 // We should only be called for evaluating pointer expressions.
David Chisnall0f436562009-08-17 16:35:33 +00001473 assert((E->getType()->isAnyPointerType() ||
Steve Naroffdd972f22008-09-05 22:11:13 +00001474 E->getType()->isBlockPointerType() ||
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001475 E->getType()->isObjCQualifiedIdType()) &&
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001476 "EvalAddr only works on pointers");
Mike Stump1eb44332009-09-09 15:08:12 +00001477
Ted Kremenek06de2762007-08-17 16:46:58 +00001478 // Our "symbolic interpreter" is just a dispatch off the currently
1479 // viewed AST node. We then recursively traverse the AST by calling
1480 // EvalAddr and EvalVal appropriately.
1481 switch (E->getStmtClass()) {
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001482 case Stmt::ParenExprClass:
1483 // Ignore parentheses.
1484 return EvalAddr(cast<ParenExpr>(E)->getSubExpr());
Ted Kremenek06de2762007-08-17 16:46:58 +00001485
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001486 case Stmt::UnaryOperatorClass: {
1487 // The only unary operator that make sense to handle here
1488 // is AddrOf. All others don't make sense as pointers.
1489 UnaryOperator *U = cast<UnaryOperator>(E);
Mike Stump1eb44332009-09-09 15:08:12 +00001490
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001491 if (U->getOpcode() == UnaryOperator::AddrOf)
1492 return EvalVal(U->getSubExpr());
1493 else
Ted Kremenek06de2762007-08-17 16:46:58 +00001494 return NULL;
1495 }
Mike Stump1eb44332009-09-09 15:08:12 +00001496
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001497 case Stmt::BinaryOperatorClass: {
1498 // Handle pointer arithmetic. All other binary operators are not valid
1499 // in this context.
1500 BinaryOperator *B = cast<BinaryOperator>(E);
1501 BinaryOperator::Opcode op = B->getOpcode();
Mike Stump1eb44332009-09-09 15:08:12 +00001502
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001503 if (op != BinaryOperator::Add && op != BinaryOperator::Sub)
1504 return NULL;
Mike Stump1eb44332009-09-09 15:08:12 +00001505
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001506 Expr *Base = B->getLHS();
1507
1508 // Determine which argument is the real pointer base. It could be
1509 // the RHS argument instead of the LHS.
1510 if (!Base->getType()->isPointerType()) Base = B->getRHS();
Mike Stump1eb44332009-09-09 15:08:12 +00001511
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001512 assert (Base->getType()->isPointerType());
1513 return EvalAddr(Base);
1514 }
Steve Naroff61f40a22008-09-10 19:17:48 +00001515
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001516 // For conditional operators we need to see if either the LHS or RHS are
1517 // valid DeclRefExpr*s. If one of them is valid, we return it.
1518 case Stmt::ConditionalOperatorClass: {
1519 ConditionalOperator *C = cast<ConditionalOperator>(E);
Mike Stump1eb44332009-09-09 15:08:12 +00001520
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001521 // Handle the GNU extension for missing LHS.
1522 if (Expr *lhsExpr = C->getLHS())
1523 if (DeclRefExpr* LHS = EvalAddr(lhsExpr))
1524 return LHS;
1525
1526 return EvalAddr(C->getRHS());
1527 }
Mike Stump1eb44332009-09-09 15:08:12 +00001528
Ted Kremenek54b52742008-08-07 00:49:01 +00001529 // For casts, we need to handle conversions from arrays to
1530 // pointer values, and pointer-to-pointer conversions.
Douglas Gregor49badde2008-10-27 19:41:14 +00001531 case Stmt::ImplicitCastExprClass:
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001532 case Stmt::CStyleCastExprClass:
Douglas Gregor49badde2008-10-27 19:41:14 +00001533 case Stmt::CXXFunctionalCastExprClass: {
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +00001534 Expr* SubExpr = cast<CastExpr>(E)->getSubExpr();
Ted Kremenek54b52742008-08-07 00:49:01 +00001535 QualType T = SubExpr->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00001536
Steve Naroffdd972f22008-09-05 22:11:13 +00001537 if (SubExpr->getType()->isPointerType() ||
1538 SubExpr->getType()->isBlockPointerType() ||
1539 SubExpr->getType()->isObjCQualifiedIdType())
Ted Kremenek54b52742008-08-07 00:49:01 +00001540 return EvalAddr(SubExpr);
1541 else if (T->isArrayType())
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001542 return EvalVal(SubExpr);
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001543 else
Ted Kremenek54b52742008-08-07 00:49:01 +00001544 return 0;
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001545 }
Mike Stump1eb44332009-09-09 15:08:12 +00001546
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001547 // C++ casts. For dynamic casts, static casts, and const casts, we
1548 // are always converting from a pointer-to-pointer, so we just blow
Douglas Gregor49badde2008-10-27 19:41:14 +00001549 // through the cast. In the case the dynamic cast doesn't fail (and
1550 // return NULL), we take the conservative route and report cases
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001551 // where we return the address of a stack variable. For Reinterpre
Douglas Gregor49badde2008-10-27 19:41:14 +00001552 // FIXME: The comment about is wrong; we're not always converting
1553 // from pointer to pointer. I'm guessing that this code should also
Mike Stump1eb44332009-09-09 15:08:12 +00001554 // handle references to objects.
1555 case Stmt::CXXStaticCastExprClass:
1556 case Stmt::CXXDynamicCastExprClass:
Douglas Gregor49badde2008-10-27 19:41:14 +00001557 case Stmt::CXXConstCastExprClass:
1558 case Stmt::CXXReinterpretCastExprClass: {
1559 Expr *S = cast<CXXNamedCastExpr>(E)->getSubExpr();
Steve Naroffdd972f22008-09-05 22:11:13 +00001560 if (S->getType()->isPointerType() || S->getType()->isBlockPointerType())
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001561 return EvalAddr(S);
1562 else
1563 return NULL;
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001564 }
Mike Stump1eb44332009-09-09 15:08:12 +00001565
Chris Lattnerfae3f1f2007-12-28 05:31:15 +00001566 // Everything else: we simply don't reason about them.
1567 default:
1568 return NULL;
1569 }
Ted Kremenek06de2762007-08-17 16:46:58 +00001570}
Mike Stump1eb44332009-09-09 15:08:12 +00001571
Ted Kremenek06de2762007-08-17 16:46:58 +00001572
1573/// EvalVal - This function is complements EvalAddr in the mutual recursion.
1574/// See the comments for EvalAddr for more details.
1575static DeclRefExpr* EvalVal(Expr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +00001576
Ted Kremeneke8c600f2007-08-28 17:02:55 +00001577 // We should only be called for evaluating non-pointer expressions, or
1578 // expressions with a pointer type that are not used as references but instead
1579 // are l-values (e.g., DeclRefExpr with a pointer type).
Mike Stump1eb44332009-09-09 15:08:12 +00001580
Ted Kremenek06de2762007-08-17 16:46:58 +00001581 // Our "symbolic interpreter" is just a dispatch off the currently
1582 // viewed AST node. We then recursively traverse the AST by calling
1583 // EvalAddr and EvalVal appropriately.
1584 switch (E->getStmtClass()) {
Douglas Gregora2813ce2009-10-23 18:54:35 +00001585 case Stmt::DeclRefExprClass: {
Ted Kremenek06de2762007-08-17 16:46:58 +00001586 // DeclRefExpr: the base case. When we hit a DeclRefExpr we are looking
1587 // at code that refers to a variable's name. We check if it has local
1588 // storage within the function, and if so, return the expression.
1589 DeclRefExpr *DR = cast<DeclRefExpr>(E);
Mike Stump1eb44332009-09-09 15:08:12 +00001590
Ted Kremenek06de2762007-08-17 16:46:58 +00001591 if (VarDecl *V = dyn_cast<VarDecl>(DR->getDecl()))
Mike Stump1eb44332009-09-09 15:08:12 +00001592 if (V->hasLocalStorage() && !V->getType()->isReferenceType()) return DR;
1593
Ted Kremenek06de2762007-08-17 16:46:58 +00001594 return NULL;
1595 }
Mike Stump1eb44332009-09-09 15:08:12 +00001596
Ted Kremenek06de2762007-08-17 16:46:58 +00001597 case Stmt::ParenExprClass:
1598 // Ignore parentheses.
1599 return EvalVal(cast<ParenExpr>(E)->getSubExpr());
Mike Stump1eb44332009-09-09 15:08:12 +00001600
Ted Kremenek06de2762007-08-17 16:46:58 +00001601 case Stmt::UnaryOperatorClass: {
1602 // The only unary operator that make sense to handle here
1603 // is Deref. All others don't resolve to a "name." This includes
1604 // handling all sorts of rvalues passed to a unary operator.
1605 UnaryOperator *U = cast<UnaryOperator>(E);
Mike Stump1eb44332009-09-09 15:08:12 +00001606
Ted Kremenek06de2762007-08-17 16:46:58 +00001607 if (U->getOpcode() == UnaryOperator::Deref)
1608 return EvalAddr(U->getSubExpr());
1609
1610 return NULL;
1611 }
Mike Stump1eb44332009-09-09 15:08:12 +00001612
Ted Kremenek06de2762007-08-17 16:46:58 +00001613 case Stmt::ArraySubscriptExprClass: {
1614 // Array subscripts are potential references to data on the stack. We
1615 // retrieve the DeclRefExpr* for the array variable if it indeed
1616 // has local storage.
Ted Kremenek23245122007-08-20 16:18:38 +00001617 return EvalAddr(cast<ArraySubscriptExpr>(E)->getBase());
Ted Kremenek06de2762007-08-17 16:46:58 +00001618 }
Mike Stump1eb44332009-09-09 15:08:12 +00001619
Ted Kremenek06de2762007-08-17 16:46:58 +00001620 case Stmt::ConditionalOperatorClass: {
1621 // For conditional operators we need to see if either the LHS or RHS are
1622 // non-NULL DeclRefExpr's. If one is non-NULL, we return it.
1623 ConditionalOperator *C = cast<ConditionalOperator>(E);
1624
Anders Carlsson39073232007-11-30 19:04:31 +00001625 // Handle the GNU extension for missing LHS.
1626 if (Expr *lhsExpr = C->getLHS())
1627 if (DeclRefExpr *LHS = EvalVal(lhsExpr))
1628 return LHS;
1629
1630 return EvalVal(C->getRHS());
Ted Kremenek06de2762007-08-17 16:46:58 +00001631 }
Mike Stump1eb44332009-09-09 15:08:12 +00001632
Ted Kremenek06de2762007-08-17 16:46:58 +00001633 // Accesses to members are potential references to data on the stack.
Douglas Gregor83f6faf2009-08-31 23:41:50 +00001634 case Stmt::MemberExprClass: {
Ted Kremenek06de2762007-08-17 16:46:58 +00001635 MemberExpr *M = cast<MemberExpr>(E);
Mike Stump1eb44332009-09-09 15:08:12 +00001636
Ted Kremenek06de2762007-08-17 16:46:58 +00001637 // Check for indirect access. We only want direct field accesses.
1638 if (!M->isArrow())
1639 return EvalVal(M->getBase());
1640 else
1641 return NULL;
1642 }
Mike Stump1eb44332009-09-09 15:08:12 +00001643
Ted Kremenek06de2762007-08-17 16:46:58 +00001644 // Everything else: we simply don't reason about them.
1645 default:
1646 return NULL;
1647 }
1648}
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001649
1650//===--- CHECK: Floating-Point comparisons (-Wfloat-equal) ---------------===//
1651
1652/// Check for comparisons of floating point operands using != and ==.
1653/// Issue a warning if these are no self-comparisons, as they are not likely
1654/// to do what the programmer intended.
1655void Sema::CheckFloatComparison(SourceLocation loc, Expr* lex, Expr *rex) {
1656 bool EmitWarning = true;
Mike Stump1eb44332009-09-09 15:08:12 +00001657
Ted Kremenek4e99a5f2008-01-17 16:57:34 +00001658 Expr* LeftExprSansParen = lex->IgnoreParens();
Ted Kremenek32e97b62008-01-17 17:55:13 +00001659 Expr* RightExprSansParen = rex->IgnoreParens();
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001660
1661 // Special case: check for x == x (which is OK).
1662 // Do not emit warnings for such cases.
1663 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LeftExprSansParen))
1664 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RightExprSansParen))
1665 if (DRL->getDecl() == DRR->getDecl())
1666 EmitWarning = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001667
1668
Ted Kremenek1b500bb2007-11-29 00:59:04 +00001669 // Special case: check for comparisons against literals that can be exactly
1670 // represented by APFloat. In such cases, do not emit a warning. This
1671 // is a heuristic: often comparison against such literals are used to
1672 // detect if a value in a variable has not changed. This clearly can
1673 // lead to false negatives.
1674 if (EmitWarning) {
1675 if (FloatingLiteral* FLL = dyn_cast<FloatingLiteral>(LeftExprSansParen)) {
1676 if (FLL->isExact())
1677 EmitWarning = false;
Mike Stumpac5fc7c2009-08-04 21:02:39 +00001678 } else
Ted Kremenek1b500bb2007-11-29 00:59:04 +00001679 if (FloatingLiteral* FLR = dyn_cast<FloatingLiteral>(RightExprSansParen)){
1680 if (FLR->isExact())
1681 EmitWarning = false;
1682 }
1683 }
Mike Stump1eb44332009-09-09 15:08:12 +00001684
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001685 // Check for comparisons with builtin types.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001686 if (EmitWarning)
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001687 if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
Douglas Gregor3c385e52009-02-14 18:57:46 +00001688 if (CL->isBuiltinCall(Context))
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001689 EmitWarning = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001690
Sebastian Redl0eb23302009-01-19 00:08:26 +00001691 if (EmitWarning)
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001692 if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
Douglas Gregor3c385e52009-02-14 18:57:46 +00001693 if (CR->isBuiltinCall(Context))
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001694 EmitWarning = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001695
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001696 // Emit the diagnostic.
1697 if (EmitWarning)
Chris Lattnerfa25bbb2008-11-19 05:08:23 +00001698 Diag(loc, diag::warn_floatingpoint_eq)
1699 << lex->getSourceRange() << rex->getSourceRange();
Ted Kremenek588e5eb2007-11-25 00:58:00 +00001700}
John McCallba26e582010-01-04 23:21:16 +00001701
John McCallf2370c92010-01-06 05:24:50 +00001702//===--- CHECK: Integer mixed-sign comparisons (-Wsign-compare) --------===//
1703//===--- CHECK: Lossy implicit conversions (-Wconversion) --------------===//
John McCallba26e582010-01-04 23:21:16 +00001704
John McCallf2370c92010-01-06 05:24:50 +00001705namespace {
John McCallba26e582010-01-04 23:21:16 +00001706
John McCallf2370c92010-01-06 05:24:50 +00001707/// Structure recording the 'active' range of an integer-valued
1708/// expression.
1709struct IntRange {
1710 /// The number of bits active in the int.
1711 unsigned Width;
John McCallba26e582010-01-04 23:21:16 +00001712
John McCallf2370c92010-01-06 05:24:50 +00001713 /// True if the int is known not to have negative values.
1714 bool NonNegative;
John McCallba26e582010-01-04 23:21:16 +00001715
John McCallf2370c92010-01-06 05:24:50 +00001716 IntRange() {}
1717 IntRange(unsigned Width, bool NonNegative)
1718 : Width(Width), NonNegative(NonNegative)
1719 {}
John McCallba26e582010-01-04 23:21:16 +00001720
John McCallf2370c92010-01-06 05:24:50 +00001721 // Returns the range of the bool type.
1722 static IntRange forBoolType() {
1723 return IntRange(1, true);
John McCall51313c32010-01-04 23:31:57 +00001724 }
1725
John McCallf2370c92010-01-06 05:24:50 +00001726 // Returns the range of an integral type.
1727 static IntRange forType(ASTContext &C, QualType T) {
1728 return forCanonicalType(C, T->getCanonicalTypeInternal().getTypePtr());
John McCall51313c32010-01-04 23:31:57 +00001729 }
1730
John McCallf2370c92010-01-06 05:24:50 +00001731 // Returns the range of an integeral type based on its canonical
1732 // representation.
1733 static IntRange forCanonicalType(ASTContext &C, const Type *T) {
1734 assert(T->isCanonicalUnqualified());
1735
1736 if (const VectorType *VT = dyn_cast<VectorType>(T))
1737 T = VT->getElementType().getTypePtr();
1738 if (const ComplexType *CT = dyn_cast<ComplexType>(T))
1739 T = CT->getElementType().getTypePtr();
1740 if (const EnumType *ET = dyn_cast<EnumType>(T))
1741 T = ET->getDecl()->getIntegerType().getTypePtr();
1742
1743 const BuiltinType *BT = cast<BuiltinType>(T);
1744 assert(BT->isInteger());
1745
1746 return IntRange(C.getIntWidth(QualType(T, 0)), BT->isUnsignedInteger());
1747 }
1748
1749 // Returns the supremum of two ranges: i.e. their conservative merge.
John McCallc0cd21d2010-02-23 19:22:29 +00001750 static IntRange join(IntRange L, IntRange R) {
John McCallf2370c92010-01-06 05:24:50 +00001751 return IntRange(std::max(L.Width, R.Width),
John McCall60fad452010-01-06 22:07:33 +00001752 L.NonNegative && R.NonNegative);
1753 }
1754
1755 // Returns the infinum of two ranges: i.e. their aggressive merge.
John McCallc0cd21d2010-02-23 19:22:29 +00001756 static IntRange meet(IntRange L, IntRange R) {
John McCall60fad452010-01-06 22:07:33 +00001757 return IntRange(std::min(L.Width, R.Width),
1758 L.NonNegative || R.NonNegative);
John McCallf2370c92010-01-06 05:24:50 +00001759 }
1760};
1761
1762IntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth) {
1763 if (value.isSigned() && value.isNegative())
1764 return IntRange(value.getMinSignedBits(), false);
1765
1766 if (value.getBitWidth() > MaxWidth)
1767 value.trunc(MaxWidth);
1768
1769 // isNonNegative() just checks the sign bit without considering
1770 // signedness.
1771 return IntRange(value.getActiveBits(), true);
1772}
1773
John McCall0acc3112010-01-06 22:57:21 +00001774IntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty,
John McCallf2370c92010-01-06 05:24:50 +00001775 unsigned MaxWidth) {
1776 if (result.isInt())
1777 return GetValueRange(C, result.getInt(), MaxWidth);
1778
1779 if (result.isVector()) {
John McCall0acc3112010-01-06 22:57:21 +00001780 IntRange R = GetValueRange(C, result.getVectorElt(0), Ty, MaxWidth);
1781 for (unsigned i = 1, e = result.getVectorLength(); i != e; ++i) {
1782 IntRange El = GetValueRange(C, result.getVectorElt(i), Ty, MaxWidth);
1783 R = IntRange::join(R, El);
1784 }
John McCallf2370c92010-01-06 05:24:50 +00001785 return R;
1786 }
1787
1788 if (result.isComplexInt()) {
1789 IntRange R = GetValueRange(C, result.getComplexIntReal(), MaxWidth);
1790 IntRange I = GetValueRange(C, result.getComplexIntImag(), MaxWidth);
1791 return IntRange::join(R, I);
John McCall51313c32010-01-04 23:31:57 +00001792 }
1793
1794 // This can happen with lossless casts to intptr_t of "based" lvalues.
1795 // Assume it might use arbitrary bits.
John McCall0acc3112010-01-06 22:57:21 +00001796 // FIXME: The only reason we need to pass the type in here is to get
1797 // the sign right on this one case. It would be nice if APValue
1798 // preserved this.
John McCallf2370c92010-01-06 05:24:50 +00001799 assert(result.isLValue());
John McCall0acc3112010-01-06 22:57:21 +00001800 return IntRange(MaxWidth, Ty->isUnsignedIntegerType());
John McCall51313c32010-01-04 23:31:57 +00001801}
John McCallf2370c92010-01-06 05:24:50 +00001802
1803/// Pseudo-evaluate the given integer expression, estimating the
1804/// range of values it might take.
1805///
1806/// \param MaxWidth - the width to which the value will be truncated
1807IntRange GetExprRange(ASTContext &C, Expr *E, unsigned MaxWidth) {
1808 E = E->IgnoreParens();
1809
1810 // Try a full evaluation first.
1811 Expr::EvalResult result;
1812 if (E->Evaluate(result, C))
John McCall0acc3112010-01-06 22:57:21 +00001813 return GetValueRange(C, result.Val, E->getType(), MaxWidth);
John McCallf2370c92010-01-06 05:24:50 +00001814
1815 // I think we only want to look through implicit casts here; if the
1816 // user has an explicit widening cast, we should treat the value as
1817 // being of the new, wider type.
1818 if (ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) {
1819 if (CE->getCastKind() == CastExpr::CK_NoOp)
1820 return GetExprRange(C, CE->getSubExpr(), MaxWidth);
1821
1822 IntRange OutputTypeRange = IntRange::forType(C, CE->getType());
1823
John McCall60fad452010-01-06 22:07:33 +00001824 bool isIntegerCast = (CE->getCastKind() == CastExpr::CK_IntegralCast);
1825 if (!isIntegerCast && CE->getCastKind() == CastExpr::CK_Unknown)
1826 isIntegerCast = CE->getSubExpr()->getType()->isIntegerType();
1827
John McCallf2370c92010-01-06 05:24:50 +00001828 // Assume that non-integer casts can span the full range of the type.
John McCall60fad452010-01-06 22:07:33 +00001829 if (!isIntegerCast)
John McCallf2370c92010-01-06 05:24:50 +00001830 return OutputTypeRange;
1831
1832 IntRange SubRange
1833 = GetExprRange(C, CE->getSubExpr(),
1834 std::min(MaxWidth, OutputTypeRange.Width));
1835
1836 // Bail out if the subexpr's range is as wide as the cast type.
1837 if (SubRange.Width >= OutputTypeRange.Width)
1838 return OutputTypeRange;
1839
1840 // Otherwise, we take the smaller width, and we're non-negative if
1841 // either the output type or the subexpr is.
1842 return IntRange(SubRange.Width,
1843 SubRange.NonNegative || OutputTypeRange.NonNegative);
1844 }
1845
1846 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
1847 // If we can fold the condition, just take that operand.
1848 bool CondResult;
1849 if (CO->getCond()->EvaluateAsBooleanCondition(CondResult, C))
1850 return GetExprRange(C, CondResult ? CO->getTrueExpr()
1851 : CO->getFalseExpr(),
1852 MaxWidth);
1853
1854 // Otherwise, conservatively merge.
1855 IntRange L = GetExprRange(C, CO->getTrueExpr(), MaxWidth);
1856 IntRange R = GetExprRange(C, CO->getFalseExpr(), MaxWidth);
1857 return IntRange::join(L, R);
1858 }
1859
1860 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
1861 switch (BO->getOpcode()) {
1862
1863 // Boolean-valued operations are single-bit and positive.
1864 case BinaryOperator::LAnd:
1865 case BinaryOperator::LOr:
1866 case BinaryOperator::LT:
1867 case BinaryOperator::GT:
1868 case BinaryOperator::LE:
1869 case BinaryOperator::GE:
1870 case BinaryOperator::EQ:
1871 case BinaryOperator::NE:
1872 return IntRange::forBoolType();
1873
John McCallc0cd21d2010-02-23 19:22:29 +00001874 // The type of these compound assignments is the type of the LHS,
1875 // so the RHS is not necessarily an integer.
1876 case BinaryOperator::MulAssign:
1877 case BinaryOperator::DivAssign:
1878 case BinaryOperator::RemAssign:
1879 case BinaryOperator::AddAssign:
1880 case BinaryOperator::SubAssign:
1881 return IntRange::forType(C, E->getType());
1882
John McCallf2370c92010-01-06 05:24:50 +00001883 // Operations with opaque sources are black-listed.
1884 case BinaryOperator::PtrMemD:
1885 case BinaryOperator::PtrMemI:
1886 return IntRange::forType(C, E->getType());
1887
John McCall60fad452010-01-06 22:07:33 +00001888 // Bitwise-and uses the *infinum* of the two source ranges.
1889 case BinaryOperator::And:
John McCallc0cd21d2010-02-23 19:22:29 +00001890 case BinaryOperator::AndAssign:
John McCall60fad452010-01-06 22:07:33 +00001891 return IntRange::meet(GetExprRange(C, BO->getLHS(), MaxWidth),
1892 GetExprRange(C, BO->getRHS(), MaxWidth));
1893
John McCallf2370c92010-01-06 05:24:50 +00001894 // Left shift gets black-listed based on a judgement call.
1895 case BinaryOperator::Shl:
John McCallc0cd21d2010-02-23 19:22:29 +00001896 case BinaryOperator::ShlAssign:
John McCallf2370c92010-01-06 05:24:50 +00001897 return IntRange::forType(C, E->getType());
1898
John McCall60fad452010-01-06 22:07:33 +00001899 // Right shift by a constant can narrow its left argument.
John McCallc0cd21d2010-02-23 19:22:29 +00001900 case BinaryOperator::Shr:
1901 case BinaryOperator::ShrAssign: {
John McCall60fad452010-01-06 22:07:33 +00001902 IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth);
1903
1904 // If the shift amount is a positive constant, drop the width by
1905 // that much.
1906 llvm::APSInt shift;
1907 if (BO->getRHS()->isIntegerConstantExpr(shift, C) &&
1908 shift.isNonNegative()) {
1909 unsigned zext = shift.getZExtValue();
1910 if (zext >= L.Width)
1911 L.Width = (L.NonNegative ? 0 : 1);
1912 else
1913 L.Width -= zext;
1914 }
1915
1916 return L;
1917 }
1918
1919 // Comma acts as its right operand.
John McCallf2370c92010-01-06 05:24:50 +00001920 case BinaryOperator::Comma:
1921 return GetExprRange(C, BO->getRHS(), MaxWidth);
1922
John McCall60fad452010-01-06 22:07:33 +00001923 // Black-list pointer subtractions.
John McCallf2370c92010-01-06 05:24:50 +00001924 case BinaryOperator::Sub:
1925 if (BO->getLHS()->getType()->isPointerType())
1926 return IntRange::forType(C, E->getType());
1927 // fallthrough
Ted Kremenek4e4b30e2010-02-16 01:46:59 +00001928
John McCallf2370c92010-01-06 05:24:50 +00001929 default:
1930 break;
1931 }
1932
1933 // Treat every other operator as if it were closed on the
1934 // narrowest type that encompasses both operands.
1935 IntRange L = GetExprRange(C, BO->getLHS(), MaxWidth);
1936 IntRange R = GetExprRange(C, BO->getRHS(), MaxWidth);
1937 return IntRange::join(L, R);
1938 }
1939
1940 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
1941 switch (UO->getOpcode()) {
1942 // Boolean-valued operations are white-listed.
1943 case UnaryOperator::LNot:
1944 return IntRange::forBoolType();
1945
1946 // Operations with opaque sources are black-listed.
1947 case UnaryOperator::Deref:
1948 case UnaryOperator::AddrOf: // should be impossible
1949 case UnaryOperator::OffsetOf:
1950 return IntRange::forType(C, E->getType());
1951
1952 default:
1953 return GetExprRange(C, UO->getSubExpr(), MaxWidth);
1954 }
1955 }
1956
1957 FieldDecl *BitField = E->getBitField();
1958 if (BitField) {
1959 llvm::APSInt BitWidthAP = BitField->getBitWidth()->EvaluateAsInt(C);
1960 unsigned BitWidth = BitWidthAP.getZExtValue();
1961
1962 return IntRange(BitWidth, BitField->getType()->isUnsignedIntegerType());
1963 }
1964
1965 return IntRange::forType(C, E->getType());
1966}
John McCall51313c32010-01-04 23:31:57 +00001967
1968/// Checks whether the given value, which currently has the given
1969/// source semantics, has the same value when coerced through the
1970/// target semantics.
John McCallf2370c92010-01-06 05:24:50 +00001971bool IsSameFloatAfterCast(const llvm::APFloat &value,
1972 const llvm::fltSemantics &Src,
1973 const llvm::fltSemantics &Tgt) {
John McCall51313c32010-01-04 23:31:57 +00001974 llvm::APFloat truncated = value;
1975
1976 bool ignored;
1977 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored);
1978 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored);
1979
1980 return truncated.bitwiseIsEqual(value);
1981}
1982
1983/// Checks whether the given value, which currently has the given
1984/// source semantics, has the same value when coerced through the
1985/// target semantics.
1986///
1987/// The value might be a vector of floats (or a complex number).
John McCallf2370c92010-01-06 05:24:50 +00001988bool IsSameFloatAfterCast(const APValue &value,
1989 const llvm::fltSemantics &Src,
1990 const llvm::fltSemantics &Tgt) {
John McCall51313c32010-01-04 23:31:57 +00001991 if (value.isFloat())
1992 return IsSameFloatAfterCast(value.getFloat(), Src, Tgt);
1993
1994 if (value.isVector()) {
1995 for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i)
1996 if (!IsSameFloatAfterCast(value.getVectorElt(i), Src, Tgt))
1997 return false;
1998 return true;
1999 }
2000
2001 assert(value.isComplexFloat());
2002 return (IsSameFloatAfterCast(value.getComplexFloatReal(), Src, Tgt) &&
2003 IsSameFloatAfterCast(value.getComplexFloatImag(), Src, Tgt));
2004}
2005
John McCallf2370c92010-01-06 05:24:50 +00002006} // end anonymous namespace
John McCall51313c32010-01-04 23:31:57 +00002007
John McCallba26e582010-01-04 23:21:16 +00002008/// \brief Implements -Wsign-compare.
2009///
2010/// \param lex the left-hand expression
2011/// \param rex the right-hand expression
2012/// \param OpLoc the location of the joining operator
John McCalld1b47bf2010-03-11 19:43:18 +00002013/// \param BinOpc binary opcode or 0
John McCallba26e582010-01-04 23:21:16 +00002014void Sema::CheckSignCompare(Expr *lex, Expr *rex, SourceLocation OpLoc,
John McCalld1b47bf2010-03-11 19:43:18 +00002015 const BinaryOperator::Opcode* BinOpc) {
John McCallba26e582010-01-04 23:21:16 +00002016 // Don't warn if we're in an unevaluated context.
2017 if (ExprEvalContexts.back().Context == Unevaluated)
2018 return;
2019
John McCallf2370c92010-01-06 05:24:50 +00002020 // If either expression is value-dependent, don't warn. We'll get another
2021 // chance at instantiation time.
2022 if (lex->isValueDependent() || rex->isValueDependent())
2023 return;
2024
John McCallba26e582010-01-04 23:21:16 +00002025 QualType lt = lex->getType(), rt = rex->getType();
2026
2027 // Only warn if both operands are integral.
2028 if (!lt->isIntegerType() || !rt->isIntegerType())
2029 return;
2030
John McCallf2370c92010-01-06 05:24:50 +00002031 // In C, the width of a bitfield determines its type, and the
2032 // declared type only contributes the signedness. This duplicates
2033 // the work that will later be done by UsualUnaryConversions.
2034 // Eventually, this check will be reorganized in a way that avoids
2035 // this duplication.
2036 if (!getLangOptions().CPlusPlus) {
2037 QualType tmp;
2038 tmp = Context.isPromotableBitField(lex);
2039 if (!tmp.isNull()) lt = tmp;
2040 tmp = Context.isPromotableBitField(rex);
2041 if (!tmp.isNull()) rt = tmp;
2042 }
John McCallba26e582010-01-04 23:21:16 +00002043
John McCalla2936be2010-03-19 18:53:26 +00002044 if (const EnumType *E = lt->getAs<EnumType>())
2045 lt = E->getDecl()->getPromotionType();
2046 if (const EnumType *E = rt->getAs<EnumType>())
2047 rt = E->getDecl()->getPromotionType();
2048
John McCallba26e582010-01-04 23:21:16 +00002049 // The rule is that the signed operand becomes unsigned, so isolate the
2050 // signed operand.
John McCallf2370c92010-01-06 05:24:50 +00002051 Expr *signedOperand = lex, *unsignedOperand = rex;
2052 QualType signedType = lt, unsignedType = rt;
John McCallba26e582010-01-04 23:21:16 +00002053 if (lt->isSignedIntegerType()) {
2054 if (rt->isSignedIntegerType()) return;
John McCallba26e582010-01-04 23:21:16 +00002055 } else {
2056 if (!rt->isSignedIntegerType()) return;
John McCallf2370c92010-01-06 05:24:50 +00002057 std::swap(signedOperand, unsignedOperand);
2058 std::swap(signedType, unsignedType);
John McCallba26e582010-01-04 23:21:16 +00002059 }
2060
John McCallf2370c92010-01-06 05:24:50 +00002061 unsigned unsignedWidth = Context.getIntWidth(unsignedType);
2062 unsigned signedWidth = Context.getIntWidth(signedType);
2063
John McCallba26e582010-01-04 23:21:16 +00002064 // If the unsigned type is strictly smaller than the signed type,
2065 // then (1) the result type will be signed and (2) the unsigned
2066 // value will fit fully within the signed type, and thus the result
2067 // of the comparison will be exact.
John McCallf2370c92010-01-06 05:24:50 +00002068 if (signedWidth > unsignedWidth)
John McCallba26e582010-01-04 23:21:16 +00002069 return;
2070
John McCallf2370c92010-01-06 05:24:50 +00002071 // Otherwise, calculate the effective ranges.
2072 IntRange signedRange = GetExprRange(Context, signedOperand, signedWidth);
2073 IntRange unsignedRange = GetExprRange(Context, unsignedOperand, unsignedWidth);
2074
2075 // We should never be unable to prove that the unsigned operand is
2076 // non-negative.
2077 assert(unsignedRange.NonNegative && "unsigned range includes negative?");
2078
2079 // If the signed operand is non-negative, then the signed->unsigned
2080 // conversion won't change it.
John McCalld1b47bf2010-03-11 19:43:18 +00002081 if (signedRange.NonNegative) {
2082 // Emit warnings for comparisons of unsigned to integer constant 0.
2083 // always false: x < 0 (or 0 > x)
2084 // always true: x >= 0 (or 0 <= x)
2085 llvm::APSInt X;
2086 if (BinOpc && signedOperand->isIntegerConstantExpr(X, Context) && X == 0) {
2087 if (signedOperand != lex) {
2088 if (*BinOpc == BinaryOperator::LT) {
2089 Diag(OpLoc, diag::warn_lunsigned_always_true_comparison)
2090 << "< 0" << "false"
2091 << lex->getSourceRange() << rex->getSourceRange();
2092 }
2093 else if (*BinOpc == BinaryOperator::GE) {
2094 Diag(OpLoc, diag::warn_lunsigned_always_true_comparison)
2095 << ">= 0" << "true"
2096 << lex->getSourceRange() << rex->getSourceRange();
2097 }
2098 }
2099 else {
2100 if (*BinOpc == BinaryOperator::GT) {
2101 Diag(OpLoc, diag::warn_runsigned_always_true_comparison)
2102 << "0 >" << "false"
2103 << lex->getSourceRange() << rex->getSourceRange();
2104 }
2105 else if (*BinOpc == BinaryOperator::LE) {
2106 Diag(OpLoc, diag::warn_runsigned_always_true_comparison)
2107 << "0 <=" << "true"
2108 << lex->getSourceRange() << rex->getSourceRange();
2109 }
2110 }
2111 }
John McCallba26e582010-01-04 23:21:16 +00002112 return;
John McCalld1b47bf2010-03-11 19:43:18 +00002113 }
John McCallba26e582010-01-04 23:21:16 +00002114
2115 // For (in)equality comparisons, if the unsigned operand is a
2116 // constant which cannot collide with a overflowed signed operand,
2117 // then reinterpreting the signed operand as unsigned will not
2118 // change the result of the comparison.
John McCalld1b47bf2010-03-11 19:43:18 +00002119 if (BinOpc &&
2120 (*BinOpc == BinaryOperator::EQ || *BinOpc == BinaryOperator::NE) &&
2121 unsignedRange.Width < unsignedWidth)
John McCallba26e582010-01-04 23:21:16 +00002122 return;
2123
John McCalld1b47bf2010-03-11 19:43:18 +00002124 Diag(OpLoc, BinOpc ? diag::warn_mixed_sign_comparison
2125 : diag::warn_mixed_sign_conditional)
John McCallf2370c92010-01-06 05:24:50 +00002126 << lt << rt << lex->getSourceRange() << rex->getSourceRange();
John McCallba26e582010-01-04 23:21:16 +00002127}
2128
John McCall51313c32010-01-04 23:31:57 +00002129/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion.
2130static void DiagnoseImpCast(Sema &S, Expr *E, QualType T, unsigned diag) {
2131 S.Diag(E->getExprLoc(), diag) << E->getType() << T << E->getSourceRange();
2132}
2133
2134/// Implements -Wconversion.
2135void Sema::CheckImplicitConversion(Expr *E, QualType T) {
2136 // Don't diagnose in unevaluated contexts.
2137 if (ExprEvalContexts.back().Context == Sema::Unevaluated)
2138 return;
2139
2140 // Don't diagnose for value-dependent expressions.
2141 if (E->isValueDependent())
2142 return;
2143
2144 const Type *Source = Context.getCanonicalType(E->getType()).getTypePtr();
2145 const Type *Target = Context.getCanonicalType(T).getTypePtr();
2146
2147 // Never diagnose implicit casts to bool.
2148 if (Target->isSpecificBuiltinType(BuiltinType::Bool))
2149 return;
2150
2151 // Strip vector types.
2152 if (isa<VectorType>(Source)) {
2153 if (!isa<VectorType>(Target))
2154 return DiagnoseImpCast(*this, E, T, diag::warn_impcast_vector_scalar);
2155
2156 Source = cast<VectorType>(Source)->getElementType().getTypePtr();
2157 Target = cast<VectorType>(Target)->getElementType().getTypePtr();
2158 }
2159
2160 // Strip complex types.
2161 if (isa<ComplexType>(Source)) {
2162 if (!isa<ComplexType>(Target))
2163 return DiagnoseImpCast(*this, E, T, diag::warn_impcast_complex_scalar);
2164
2165 Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
2166 Target = cast<ComplexType>(Target)->getElementType().getTypePtr();
2167 }
2168
2169 const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
2170 const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target);
2171
2172 // If the source is floating point...
2173 if (SourceBT && SourceBT->isFloatingPoint()) {
2174 // ...and the target is floating point...
2175 if (TargetBT && TargetBT->isFloatingPoint()) {
2176 // ...then warn if we're dropping FP rank.
2177
2178 // Builtin FP kinds are ordered by increasing FP rank.
2179 if (SourceBT->getKind() > TargetBT->getKind()) {
2180 // Don't warn about float constants that are precisely
2181 // representable in the target type.
2182 Expr::EvalResult result;
2183 if (E->Evaluate(result, Context)) {
2184 // Value might be a float, a float vector, or a float complex.
2185 if (IsSameFloatAfterCast(result.Val,
2186 Context.getFloatTypeSemantics(QualType(TargetBT, 0)),
2187 Context.getFloatTypeSemantics(QualType(SourceBT, 0))))
2188 return;
2189 }
2190
2191 DiagnoseImpCast(*this, E, T, diag::warn_impcast_float_precision);
2192 }
2193 return;
2194 }
2195
2196 // If the target is integral, always warn.
2197 if ((TargetBT && TargetBT->isInteger()))
2198 // TODO: don't warn for integer values?
2199 return DiagnoseImpCast(*this, E, T, diag::warn_impcast_float_integer);
2200
2201 return;
2202 }
2203
John McCallf2370c92010-01-06 05:24:50 +00002204 if (!Source->isIntegerType() || !Target->isIntegerType())
John McCall51313c32010-01-04 23:31:57 +00002205 return;
2206
John McCallf2370c92010-01-06 05:24:50 +00002207 IntRange SourceRange = GetExprRange(Context, E, Context.getIntWidth(E->getType()));
2208 IntRange TargetRange = IntRange::forCanonicalType(Context, Target);
John McCall51313c32010-01-04 23:31:57 +00002209
John McCallf2370c92010-01-06 05:24:50 +00002210 // FIXME: also signed<->unsigned?
2211
2212 if (SourceRange.Width > TargetRange.Width) {
John McCall51313c32010-01-04 23:31:57 +00002213 // People want to build with -Wshorten-64-to-32 and not -Wconversion
2214 // and by god we'll let them.
John McCallf2370c92010-01-06 05:24:50 +00002215 if (SourceRange.Width == 64 && TargetRange.Width == 32)
John McCall51313c32010-01-04 23:31:57 +00002216 return DiagnoseImpCast(*this, E, T, diag::warn_impcast_integer_64_32);
2217 return DiagnoseImpCast(*this, E, T, diag::warn_impcast_integer_precision);
2218 }
2219
2220 return;
2221}
2222
Mike Stumpf8c49212010-01-21 03:59:47 +00002223/// CheckParmsForFunctionDef - Check that the parameters of the given
2224/// function are appropriate for the definition of a function. This
2225/// takes care of any checks that cannot be performed on the
2226/// declaration itself, e.g., that the types of each of the function
2227/// parameters are complete.
2228bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) {
2229 bool HasInvalidParm = false;
2230 for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
2231 ParmVarDecl *Param = FD->getParamDecl(p);
2232
2233 // C99 6.7.5.3p4: the parameters in a parameter type list in a
2234 // function declarator that is part of a function definition of
2235 // that function shall not have incomplete type.
2236 //
2237 // This is also C++ [dcl.fct]p6.
2238 if (!Param->isInvalidDecl() &&
2239 RequireCompleteType(Param->getLocation(), Param->getType(),
2240 diag::err_typecheck_decl_incomplete_type)) {
2241 Param->setInvalidDecl();
2242 HasInvalidParm = true;
2243 }
2244
2245 // C99 6.9.1p5: If the declarator includes a parameter type list, the
2246 // declaration of each parameter shall include an identifier.
2247 if (Param->getIdentifier() == 0 &&
2248 !Param->isImplicit() &&
2249 !getLangOptions().CPlusPlus)
2250 Diag(Param->getLocation(), diag::err_parameter_name_omitted);
Sam Weinigd17e3402010-02-01 05:02:49 +00002251
2252 // C99 6.7.5.3p12:
2253 // If the function declarator is not part of a definition of that
2254 // function, parameters may have incomplete type and may use the [*]
2255 // notation in their sequences of declarator specifiers to specify
2256 // variable length array types.
2257 QualType PType = Param->getOriginalType();
2258 if (const ArrayType *AT = Context.getAsArrayType(PType)) {
2259 if (AT->getSizeModifier() == ArrayType::Star) {
2260 // FIXME: This diagnosic should point the the '[*]' if source-location
2261 // information is added for it.
2262 Diag(Param->getLocation(), diag::err_array_star_in_function_definition);
2263 }
2264 }
John McCall4f9506a2010-02-02 08:45:54 +00002265
John McCall68c6c9a2010-02-02 09:10:11 +00002266 if (getLangOptions().CPlusPlus)
2267 if (const RecordType *RT = Param->getType()->getAs<RecordType>())
2268 FinalizeVarWithDestructor(Param, RT);
Mike Stumpf8c49212010-01-21 03:59:47 +00002269 }
2270
2271 return HasInvalidParm;
2272}