blob: 07428fdac7b9a3e2696978bae2a76384159bd73a [file] [log] [blame]
Chris Lattner4b009652007-07-25 00:24:17 +00001//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-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 Lattner4b009652007-07-25 00:24:17 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for expressions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "clang/AST/ASTContext.h"
Daniel Dunbar64789f82008-08-11 05:35:13 +000016#include "clang/AST/DeclObjC.h"
Chris Lattner3e254fb2008-04-08 04:40:51 +000017#include "clang/AST/ExprCXX.h"
Steve Naroff9ed3e772008-05-29 21:12:08 +000018#include "clang/AST/ExprObjC.h"
Chris Lattner4b009652007-07-25 00:24:17 +000019#include "clang/Lex/Preprocessor.h"
20#include "clang/Lex/LiteralSupport.h"
Daniel Dunbarcc7b1602008-08-11 03:45:03 +000021#include "clang/Basic/Diagnostic.h"
Chris Lattner4b009652007-07-25 00:24:17 +000022#include "clang/Basic/SourceManager.h"
Chris Lattner4b009652007-07-25 00:24:17 +000023#include "clang/Basic/TargetInfo.h"
Steve Naroff52a81c02008-09-03 18:15:37 +000024#include "clang/Parse/DeclSpec.h"
25#include "clang/Parse/Scope.h"
Chris Lattner4b009652007-07-25 00:24:17 +000026using namespace clang;
27
Chris Lattner299b8842008-07-25 21:10:04 +000028//===----------------------------------------------------------------------===//
29// Standard Promotions and Conversions
30//===----------------------------------------------------------------------===//
31
Chris Lattner299b8842008-07-25 21:10:04 +000032/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
33void Sema::DefaultFunctionArrayConversion(Expr *&E) {
34 QualType Ty = E->getType();
35 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
36
37 if (const ReferenceType *ref = Ty->getAsReferenceType()) {
38 ImpCastExprToType(E, ref->getPointeeType()); // C++ [expr]
39 Ty = E->getType();
40 }
41 if (Ty->isFunctionType())
42 ImpCastExprToType(E, Context.getPointerType(Ty));
Chris Lattner2aa68822008-07-25 21:33:13 +000043 else if (Ty->isArrayType()) {
44 // In C90 mode, arrays only promote to pointers if the array expression is
45 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
46 // type 'array of type' is converted to an expression that has type 'pointer
47 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
48 // that has type 'array of type' ...". The relevant change is "an lvalue"
49 // (C90) to "an expression" (C99).
Argiris Kirtzidisf580b4d2008-09-11 04:25:59 +000050 //
51 // C++ 4.2p1:
52 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
53 // T" can be converted to an rvalue of type "pointer to T".
54 //
55 if (getLangOptions().C99 || getLangOptions().CPlusPlus ||
56 E->isLvalue(Context) == Expr::LV_Valid)
Chris Lattner2aa68822008-07-25 21:33:13 +000057 ImpCastExprToType(E, Context.getArrayDecayedType(Ty));
58 }
Chris Lattner299b8842008-07-25 21:10:04 +000059}
60
61/// UsualUnaryConversions - Performs various conversions that are common to most
62/// operators (C99 6.3). The conversions of array and function types are
63/// sometimes surpressed. For example, the array->pointer conversion doesn't
64/// apply if the array is an argument to the sizeof or address (&) operators.
65/// In these instances, this routine should *not* be called.
66Expr *Sema::UsualUnaryConversions(Expr *&Expr) {
67 QualType Ty = Expr->getType();
68 assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
69
70 if (const ReferenceType *Ref = Ty->getAsReferenceType()) {
71 ImpCastExprToType(Expr, Ref->getPointeeType()); // C++ [expr]
72 Ty = Expr->getType();
73 }
74 if (Ty->isPromotableIntegerType()) // C99 6.3.1.1p2
75 ImpCastExprToType(Expr, Context.IntTy);
76 else
77 DefaultFunctionArrayConversion(Expr);
78
79 return Expr;
80}
81
Chris Lattner9305c3d2008-07-25 22:25:12 +000082/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
83/// do not have a prototype. Arguments that have type float are promoted to
84/// double. All other argument types are converted by UsualUnaryConversions().
85void Sema::DefaultArgumentPromotion(Expr *&Expr) {
86 QualType Ty = Expr->getType();
87 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
88
89 // If this is a 'float' (CVR qualified or typedef) promote to double.
90 if (const BuiltinType *BT = Ty->getAsBuiltinType())
91 if (BT->getKind() == BuiltinType::Float)
92 return ImpCastExprToType(Expr, Context.DoubleTy);
93
94 UsualUnaryConversions(Expr);
95}
96
Chris Lattner299b8842008-07-25 21:10:04 +000097/// UsualArithmeticConversions - Performs various conversions that are common to
98/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
99/// routine returns the first non-arithmetic type found. The client is
100/// responsible for emitting appropriate error diagnostics.
101/// FIXME: verify the conversion rules for "complex int" are consistent with
102/// GCC.
103QualType Sema::UsualArithmeticConversions(Expr *&lhsExpr, Expr *&rhsExpr,
104 bool isCompAssign) {
105 if (!isCompAssign) {
106 UsualUnaryConversions(lhsExpr);
107 UsualUnaryConversions(rhsExpr);
108 }
109 // For conversion purposes, we ignore any qualifiers.
110 // For example, "const float" and "float" are equivalent.
Chris Lattnerd5a56aa2008-07-26 22:17:49 +0000111 QualType lhs =
112 Context.getCanonicalType(lhsExpr->getType()).getUnqualifiedType();
113 QualType rhs =
114 Context.getCanonicalType(rhsExpr->getType()).getUnqualifiedType();
Chris Lattner299b8842008-07-25 21:10:04 +0000115
116 // If both types are identical, no conversion is needed.
117 if (lhs == rhs)
118 return lhs;
119
120 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
121 // The caller can deal with this (e.g. pointer + int).
122 if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
123 return lhs;
124
125 // At this point, we have two different arithmetic types.
126
127 // Handle complex types first (C99 6.3.1.8p1).
128 if (lhs->isComplexType() || rhs->isComplexType()) {
129 // if we have an integer operand, the result is the complex type.
130 if (rhs->isIntegerType() || rhs->isComplexIntegerType()) {
131 // convert the rhs to the lhs complex type.
132 if (!isCompAssign) ImpCastExprToType(rhsExpr, lhs);
133 return lhs;
134 }
135 if (lhs->isIntegerType() || lhs->isComplexIntegerType()) {
136 // convert the lhs to the rhs complex type.
137 if (!isCompAssign) ImpCastExprToType(lhsExpr, rhs);
138 return rhs;
139 }
140 // This handles complex/complex, complex/float, or float/complex.
141 // When both operands are complex, the shorter operand is converted to the
142 // type of the longer, and that is the type of the result. This corresponds
143 // to what is done when combining two real floating-point operands.
144 // The fun begins when size promotion occur across type domains.
145 // From H&S 6.3.4: When one operand is complex and the other is a real
146 // floating-point type, the less precise type is converted, within it's
147 // real or complex domain, to the precision of the other type. For example,
148 // when combining a "long double" with a "double _Complex", the
149 // "double _Complex" is promoted to "long double _Complex".
150 int result = Context.getFloatingTypeOrder(lhs, rhs);
151
152 if (result > 0) { // The left side is bigger, convert rhs.
153 rhs = Context.getFloatingTypeOfSizeWithinDomain(lhs, rhs);
154 if (!isCompAssign)
155 ImpCastExprToType(rhsExpr, rhs);
156 } else if (result < 0) { // The right side is bigger, convert lhs.
157 lhs = Context.getFloatingTypeOfSizeWithinDomain(rhs, lhs);
158 if (!isCompAssign)
159 ImpCastExprToType(lhsExpr, lhs);
160 }
161 // At this point, lhs and rhs have the same rank/size. Now, make sure the
162 // domains match. This is a requirement for our implementation, C99
163 // does not require this promotion.
164 if (lhs != rhs) { // Domains don't match, we have complex/float mix.
165 if (lhs->isRealFloatingType()) { // handle "double, _Complex double".
166 if (!isCompAssign)
167 ImpCastExprToType(lhsExpr, rhs);
168 return rhs;
169 } else { // handle "_Complex double, double".
170 if (!isCompAssign)
171 ImpCastExprToType(rhsExpr, lhs);
172 return lhs;
173 }
174 }
175 return lhs; // The domain/size match exactly.
176 }
177 // Now handle "real" floating types (i.e. float, double, long double).
178 if (lhs->isRealFloatingType() || rhs->isRealFloatingType()) {
179 // if we have an integer operand, the result is the real floating type.
180 if (rhs->isIntegerType() || rhs->isComplexIntegerType()) {
181 // convert rhs to the lhs floating point type.
182 if (!isCompAssign) ImpCastExprToType(rhsExpr, lhs);
183 return lhs;
184 }
185 if (lhs->isIntegerType() || lhs->isComplexIntegerType()) {
186 // convert lhs to the rhs floating point type.
187 if (!isCompAssign) ImpCastExprToType(lhsExpr, rhs);
188 return rhs;
189 }
190 // We have two real floating types, float/complex combos were handled above.
191 // Convert the smaller operand to the bigger result.
192 int result = Context.getFloatingTypeOrder(lhs, rhs);
193
194 if (result > 0) { // convert the rhs
195 if (!isCompAssign) ImpCastExprToType(rhsExpr, lhs);
196 return lhs;
197 }
198 if (result < 0) { // convert the lhs
199 if (!isCompAssign) ImpCastExprToType(lhsExpr, rhs); // convert the lhs
200 return rhs;
201 }
202 assert(0 && "Sema::UsualArithmeticConversions(): illegal float comparison");
203 }
204 if (lhs->isComplexIntegerType() || rhs->isComplexIntegerType()) {
205 // Handle GCC complex int extension.
206 const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType();
207 const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType();
208
209 if (lhsComplexInt && rhsComplexInt) {
210 if (Context.getIntegerTypeOrder(lhsComplexInt->getElementType(),
211 rhsComplexInt->getElementType()) >= 0) {
212 // convert the rhs
213 if (!isCompAssign) ImpCastExprToType(rhsExpr, lhs);
214 return lhs;
215 }
216 if (!isCompAssign)
217 ImpCastExprToType(lhsExpr, rhs); // convert the lhs
218 return rhs;
219 } else if (lhsComplexInt && rhs->isIntegerType()) {
220 // convert the rhs to the lhs complex type.
221 if (!isCompAssign) ImpCastExprToType(rhsExpr, lhs);
222 return lhs;
223 } else if (rhsComplexInt && lhs->isIntegerType()) {
224 // convert the lhs to the rhs complex type.
225 if (!isCompAssign) ImpCastExprToType(lhsExpr, rhs);
226 return rhs;
227 }
228 }
229 // Finally, we have two differing integer types.
230 // The rules for this case are in C99 6.3.1.8
231 int compare = Context.getIntegerTypeOrder(lhs, rhs);
232 bool lhsSigned = lhs->isSignedIntegerType(),
233 rhsSigned = rhs->isSignedIntegerType();
234 QualType destType;
235 if (lhsSigned == rhsSigned) {
236 // Same signedness; use the higher-ranked type
237 destType = compare >= 0 ? lhs : rhs;
238 } else if (compare != (lhsSigned ? 1 : -1)) {
239 // The unsigned type has greater than or equal rank to the
240 // signed type, so use the unsigned type
241 destType = lhsSigned ? rhs : lhs;
242 } else if (Context.getIntWidth(lhs) != Context.getIntWidth(rhs)) {
243 // The two types are different widths; if we are here, that
244 // means the signed type is larger than the unsigned type, so
245 // use the signed type.
246 destType = lhsSigned ? lhs : rhs;
247 } else {
248 // The signed type is higher-ranked than the unsigned type,
249 // but isn't actually any bigger (like unsigned int and long
250 // on most 32-bit systems). Use the unsigned type corresponding
251 // to the signed type.
252 destType = Context.getCorrespondingUnsignedType(lhsSigned ? lhs : rhs);
253 }
254 if (!isCompAssign) {
255 ImpCastExprToType(lhsExpr, destType);
256 ImpCastExprToType(rhsExpr, destType);
257 }
258 return destType;
259}
260
261//===----------------------------------------------------------------------===//
262// Semantic Analysis for various Expression Types
263//===----------------------------------------------------------------------===//
264
265
Steve Naroff87d58b42007-09-16 03:34:24 +0000266/// ActOnStringLiteral - The specified tokens were lexed as pasted string
Chris Lattner4b009652007-07-25 00:24:17 +0000267/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
268/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
269/// multiple tokens. However, the common case is that StringToks points to one
270/// string.
271///
272Action::ExprResult
Steve Naroff87d58b42007-09-16 03:34:24 +0000273Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) {
Chris Lattner4b009652007-07-25 00:24:17 +0000274 assert(NumStringToks && "Must have at least one string!");
275
276 StringLiteralParser Literal(StringToks, NumStringToks, PP, Context.Target);
277 if (Literal.hadError)
278 return ExprResult(true);
279
280 llvm::SmallVector<SourceLocation, 4> StringTokLocs;
281 for (unsigned i = 0; i != NumStringToks; ++i)
282 StringTokLocs.push_back(StringToks[i].getLocation());
Chris Lattnera6dcce32008-02-11 00:02:17 +0000283
284 // Verify that pascal strings aren't too large.
Anders Carlsson55bfe0d2007-10-15 02:50:23 +0000285 if (Literal.Pascal && Literal.GetStringLength() > 256)
286 return Diag(StringToks[0].getLocation(), diag::err_pascal_string_too_long,
287 SourceRange(StringToks[0].getLocation(),
288 StringToks[NumStringToks-1].getLocation()));
Chris Lattner4b009652007-07-25 00:24:17 +0000289
Chris Lattnera6dcce32008-02-11 00:02:17 +0000290 QualType StrTy = Context.CharTy;
Argiris Kirtzidis2a4e1162008-08-09 17:20:01 +0000291 if (Literal.AnyWide) StrTy = Context.getWCharType();
Chris Lattnera6dcce32008-02-11 00:02:17 +0000292 if (Literal.Pascal) StrTy = Context.UnsignedCharTy;
Douglas Gregor1815b3b2008-09-12 00:47:35 +0000293
294 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
295 if (getLangOptions().CPlusPlus)
296 StrTy.addConst();
Chris Lattnera6dcce32008-02-11 00:02:17 +0000297
298 // Get an array type for the string, according to C99 6.4.5. This includes
299 // the nul terminator character as well as the string length for pascal
300 // strings.
301 StrTy = Context.getConstantArrayType(StrTy,
302 llvm::APInt(32, Literal.GetStringLength()+1),
303 ArrayType::Normal, 0);
304
Chris Lattner4b009652007-07-25 00:24:17 +0000305 // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
306 return new StringLiteral(Literal.GetString(), Literal.GetStringLength(),
Chris Lattnera6dcce32008-02-11 00:02:17 +0000307 Literal.AnyWide, StrTy,
Anders Carlsson55bfe0d2007-10-15 02:50:23 +0000308 StringToks[0].getLocation(),
Chris Lattner4b009652007-07-25 00:24:17 +0000309 StringToks[NumStringToks-1].getLocation());
310}
311
Steve Naroffd6163f32008-09-05 22:11:13 +0000312/// DeclDefinedWithinScope - Return true if the specified decl is defined at or
313/// within the 'Within' scope. The current Scope is CurScope.
314///
Steve Naroff32fe5a92008-09-28 21:07:52 +0000315/// FIXME: This method is extremely inefficient (linear scan), this should not
316/// be used in common cases. Replace with the more modern DeclContext. We need
317/// to make sure both assignments below produce an error.
318///
319/// int main(int argc) {
320/// int xx;
321/// ^(int X) {
322/// xx = 4; // error (variable is not assignable)
323/// argc = 3; // no error.
324/// };
325/// }
Steve Naroffd6163f32008-09-05 22:11:13 +0000326///
327static bool DeclDefinedWithinScope(ScopedDecl *D, Scope *Within,
328 Scope *CurScope) {
329 while (1) {
330 assert(CurScope && "CurScope not nested within 'Within'?");
331
332 // Check this scope for the decl.
333 if (CurScope->isDeclScope(D)) return true;
334
335 if (CurScope == Within) return false;
336 CurScope = CurScope->getParent();
337 }
338}
Chris Lattner4b009652007-07-25 00:24:17 +0000339
Steve Naroff0acc9c92007-09-15 18:49:24 +0000340/// ActOnIdentifierExpr - The parser read an identifier in expression context,
Chris Lattner4b009652007-07-25 00:24:17 +0000341/// validate it per-C99 6.5.1. HasTrailingLParen indicates whether this
Steve Naroffe50e14c2008-03-19 23:46:26 +0000342/// identifier is used in a function call context.
Steve Naroff0acc9c92007-09-15 18:49:24 +0000343Sema::ExprResult Sema::ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
Chris Lattner4b009652007-07-25 00:24:17 +0000344 IdentifierInfo &II,
345 bool HasTrailingLParen) {
Chris Lattnerc72d22d2008-03-31 00:36:02 +0000346 // Could be enum-constant, value decl, instance variable, etc.
Steve Naroff6384a012008-04-02 14:35:35 +0000347 Decl *D = LookupDecl(&II, Decl::IDNS_Ordinary, S);
Chris Lattnerc72d22d2008-03-31 00:36:02 +0000348
349 // If this reference is in an Objective-C method, then ivar lookup happens as
350 // well.
Argiris Kirtzidis95256e62008-06-28 06:07:14 +0000351 if (getCurMethodDecl()) {
Steve Naroffe57c21a2008-04-01 23:04:06 +0000352 ScopedDecl *SD = dyn_cast_or_null<ScopedDecl>(D);
Chris Lattnerc72d22d2008-03-31 00:36:02 +0000353 // There are two cases to handle here. 1) scoped lookup could have failed,
354 // in which case we should look for an ivar. 2) scoped lookup could have
355 // found a decl, but that decl is outside the current method (i.e. a global
356 // variable). In these two cases, we do a lookup for an ivar with this
357 // name, if the lookup suceeds, we replace it our current decl.
Steve Naroffe57c21a2008-04-01 23:04:06 +0000358 if (SD == 0 || SD->isDefinedOutsideFunctionOrMethod()) {
Argiris Kirtzidis95256e62008-06-28 06:07:14 +0000359 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
Chris Lattnered94f762008-07-21 04:44:44 +0000360 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(&II)) {
Chris Lattnerc72d22d2008-03-31 00:36:02 +0000361 // FIXME: This should use a new expr for a direct reference, don't turn
362 // this into Self->ivar, just return a BareIVarExpr or something.
363 IdentifierInfo &II = Context.Idents.get("self");
364 ExprResult SelfExpr = ActOnIdentifierExpr(S, Loc, II, false);
365 return new ObjCIvarRefExpr(IV, IV->getType(), Loc,
366 static_cast<Expr*>(SelfExpr.Val), true, true);
367 }
368 }
Steve Naroff0ccfaa42008-08-10 19:10:41 +0000369 // Needed to implement property "super.method" notation.
Daniel Dunbar4837ae72008-08-14 22:04:54 +0000370 if (SD == 0 && &II == SuperID) {
Steve Naroff6f786252008-06-02 23:03:37 +0000371 QualType T = Context.getPointerType(Context.getObjCInterfaceType(
Argiris Kirtzidis95256e62008-06-28 06:07:14 +0000372 getCurMethodDecl()->getClassInterface()));
Steve Naroff0ccfaa42008-08-10 19:10:41 +0000373 return new PredefinedExpr(Loc, T, PredefinedExpr::ObjCSuper);
Steve Naroff6f786252008-06-02 23:03:37 +0000374 }
Chris Lattnerc72d22d2008-03-31 00:36:02 +0000375 }
Steve Naroff4d1b93d2008-09-10 18:33:00 +0000376 // If we are parsing a block, check the block parameter list.
377 if (CurBlock) {
Steve Naroffb6f23952008-09-28 00:13:36 +0000378 BlockSemaInfo *BLK = CurBlock;
379 do {
380 for (unsigned i = 0, e = BLK->Params.size(); i != e && D == 0; ++i)
381 if (BLK->Params[i]->getIdentifier() == &II)
382 D = BLK->Params[i];
383 if (D)
384 break; // Found!
385 } while ((BLK = BLK->PrevBlockInfo)); // Look through any enclosing blocks.
Steve Naroff4d1b93d2008-09-10 18:33:00 +0000386 }
Chris Lattner4b009652007-07-25 00:24:17 +0000387 if (D == 0) {
388 // Otherwise, this could be an implicitly declared function reference (legal
389 // in C90, extension in C99).
390 if (HasTrailingLParen &&
Chris Lattnerc72d22d2008-03-31 00:36:02 +0000391 !getLangOptions().CPlusPlus) // Not in C++.
Chris Lattner4b009652007-07-25 00:24:17 +0000392 D = ImplicitlyDefineFunction(Loc, II, S);
393 else {
394 // If this name wasn't predeclared and if this is not a function call,
395 // diagnose the problem.
396 return Diag(Loc, diag::err_undeclared_var_use, II.getName());
397 }
398 }
Chris Lattnerc72d22d2008-03-31 00:36:02 +0000399
Argiris Kirtzidis38f16712008-07-01 10:37:29 +0000400 if (CXXFieldDecl *FD = dyn_cast<CXXFieldDecl>(D)) {
401 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
402 if (MD->isStatic())
403 // "invalid use of member 'x' in static member function"
404 return Diag(Loc, diag::err_invalid_member_use_in_static_method,
405 FD->getName());
406 if (cast<CXXRecordDecl>(MD->getParent()) != FD->getParent())
407 // "invalid use of nonstatic data member 'x'"
408 return Diag(Loc, diag::err_invalid_non_static_member_use,
409 FD->getName());
410
411 if (FD->isInvalidDecl())
412 return true;
413
414 // FIXME: Use DeclRefExpr or a new Expr for a direct CXXField reference.
415 ExprResult ThisExpr = ActOnCXXThis(SourceLocation());
416 return new MemberExpr(static_cast<Expr*>(ThisExpr.Val),
417 true, FD, Loc, FD->getType());
418 }
419
420 return Diag(Loc, diag::err_invalid_non_static_member_use, FD->getName());
421 }
Chris Lattner4b009652007-07-25 00:24:17 +0000422 if (isa<TypedefDecl>(D))
423 return Diag(Loc, diag::err_unexpected_typedef, II.getName());
Ted Kremenek42730c52008-01-07 19:49:32 +0000424 if (isa<ObjCInterfaceDecl>(D))
Fariborz Jahanian3102df92007-12-05 18:16:33 +0000425 return Diag(Loc, diag::err_unexpected_interface, II.getName());
Argiris Kirtzidis03e6aaf2008-04-27 13:50:30 +0000426 if (isa<NamespaceDecl>(D))
427 return Diag(Loc, diag::err_unexpected_namespace, II.getName());
Chris Lattner4b009652007-07-25 00:24:17 +0000428
Steve Naroffd6163f32008-09-05 22:11:13 +0000429 // Make the DeclRefExpr or BlockDeclRefExpr for the decl.
430 ValueDecl *VD = cast<ValueDecl>(D);
431
432 // check if referencing an identifier with __attribute__((deprecated)).
433 if (VD->getAttr<DeprecatedAttr>())
434 Diag(Loc, diag::warn_deprecated, VD->getName());
435
436 // Only create DeclRefExpr's for valid Decl's.
437 if (VD->isInvalidDecl())
438 return true;
439
440 // If this reference is not in a block or if the referenced variable is
441 // within the block, create a normal DeclRefExpr.
442 //
443 // FIXME: This will create BlockDeclRefExprs for global variables,
Chris Lattner631b1352008-09-28 05:30:26 +0000444 // function references, etc which is suboptimal :) and breaks
Steve Naroffd6163f32008-09-05 22:11:13 +0000445 // things like "integer constant expression" tests.
446 //
Chris Lattner631b1352008-09-28 05:30:26 +0000447 if (!CurBlock || DeclDefinedWithinScope(VD, CurBlock->TheScope, S) ||
Steve Naroff91de7542008-09-28 14:02:55 +0000448 isa<EnumConstantDecl>(VD) || isa<ParmVarDecl>(VD))
Steve Naroffd6163f32008-09-05 22:11:13 +0000449 return new DeclRefExpr(VD, VD->getType(), Loc);
450
451 // If we are in a block and the variable is outside the current block,
452 // bind the variable reference with a BlockDeclRefExpr.
453
Steve Naroffcb6ad602008-09-22 15:31:56 +0000454 // The BlocksAttr indicates the variable is bound by-reference.
455 if (VD->getAttr<BlocksAttr>())
456 return new BlockDeclRefExpr(VD, VD->getType(), Loc, true);
Steve Naroffd6163f32008-09-05 22:11:13 +0000457
Steve Naroffcb6ad602008-09-22 15:31:56 +0000458 // Variable will be bound by-copy, make it const within the closure.
459 VD->getType().addConst();
Steve Naroffd6163f32008-09-05 22:11:13 +0000460 return new BlockDeclRefExpr(VD, VD->getType(), Loc, false);
Chris Lattner4b009652007-07-25 00:24:17 +0000461}
462
Chris Lattner69909292008-08-10 01:53:14 +0000463Sema::ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc,
Chris Lattner4b009652007-07-25 00:24:17 +0000464 tok::TokenKind Kind) {
Chris Lattner69909292008-08-10 01:53:14 +0000465 PredefinedExpr::IdentType IT;
Chris Lattner4b009652007-07-25 00:24:17 +0000466
467 switch (Kind) {
Chris Lattnere12ca5d2008-01-12 18:39:25 +0000468 default: assert(0 && "Unknown simple primary expr!");
Chris Lattner69909292008-08-10 01:53:14 +0000469 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
470 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
471 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
Chris Lattner4b009652007-07-25 00:24:17 +0000472 }
Chris Lattnere12ca5d2008-01-12 18:39:25 +0000473
474 // Verify that this is in a function context.
Argiris Kirtzidis95256e62008-06-28 06:07:14 +0000475 if (getCurFunctionDecl() == 0 && getCurMethodDecl() == 0)
Chris Lattnere12ca5d2008-01-12 18:39:25 +0000476 return Diag(Loc, diag::err_predef_outside_function);
Chris Lattner4b009652007-07-25 00:24:17 +0000477
Chris Lattner7e637512008-01-12 08:14:25 +0000478 // Pre-defined identifiers are of type char[x], where x is the length of the
479 // string.
Chris Lattnerfc9511c2008-01-12 19:32:28 +0000480 unsigned Length;
Argiris Kirtzidis95256e62008-06-28 06:07:14 +0000481 if (getCurFunctionDecl())
482 Length = getCurFunctionDecl()->getIdentifier()->getLength();
Chris Lattnerfc9511c2008-01-12 19:32:28 +0000483 else
Argiris Kirtzidis95256e62008-06-28 06:07:14 +0000484 Length = getCurMethodDecl()->getSynthesizedMethodSize();
Chris Lattnere12ca5d2008-01-12 18:39:25 +0000485
Chris Lattnerfc9511c2008-01-12 19:32:28 +0000486 llvm::APInt LengthI(32, Length + 1);
Chris Lattnere12ca5d2008-01-12 18:39:25 +0000487 QualType ResTy = Context.CharTy.getQualifiedType(QualType::Const);
Chris Lattnerfc9511c2008-01-12 19:32:28 +0000488 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0);
Chris Lattner69909292008-08-10 01:53:14 +0000489 return new PredefinedExpr(Loc, ResTy, IT);
Chris Lattner4b009652007-07-25 00:24:17 +0000490}
491
Steve Naroff87d58b42007-09-16 03:34:24 +0000492Sema::ExprResult Sema::ActOnCharacterConstant(const Token &Tok) {
Chris Lattner4b009652007-07-25 00:24:17 +0000493 llvm::SmallString<16> CharBuffer;
494 CharBuffer.resize(Tok.getLength());
495 const char *ThisTokBegin = &CharBuffer[0];
496 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
497
498 CharLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
499 Tok.getLocation(), PP);
500 if (Literal.hadError())
501 return ExprResult(true);
Chris Lattner6b22fb72008-03-01 08:32:21 +0000502
503 QualType type = getLangOptions().CPlusPlus ? Context.CharTy : Context.IntTy;
504
Chris Lattner1aaf71c2008-06-07 22:35:38 +0000505 return new CharacterLiteral(Literal.getValue(), Literal.isWide(), type,
506 Tok.getLocation());
Chris Lattner4b009652007-07-25 00:24:17 +0000507}
508
Steve Naroff87d58b42007-09-16 03:34:24 +0000509Action::ExprResult Sema::ActOnNumericConstant(const Token &Tok) {
Chris Lattner4b009652007-07-25 00:24:17 +0000510 // fast path for a single digit (which is quite common). A single digit
511 // cannot have a trigraph, escaped newline, radix prefix, or type suffix.
512 if (Tok.getLength() == 1) {
Chris Lattner48d7f382008-04-02 04:24:33 +0000513 const char *Ty = PP.getSourceManager().getCharacterData(Tok.getLocation());
Chris Lattner4b009652007-07-25 00:24:17 +0000514
Chris Lattner8cd0e932008-03-05 18:54:05 +0000515 unsigned IntSize =static_cast<unsigned>(Context.getTypeSize(Context.IntTy));
Chris Lattner48d7f382008-04-02 04:24:33 +0000516 return ExprResult(new IntegerLiteral(llvm::APInt(IntSize, *Ty-'0'),
Chris Lattner4b009652007-07-25 00:24:17 +0000517 Context.IntTy,
518 Tok.getLocation()));
519 }
520 llvm::SmallString<512> IntegerBuffer;
521 IntegerBuffer.resize(Tok.getLength());
522 const char *ThisTokBegin = &IntegerBuffer[0];
523
524 // Get the spelling of the token, which eliminates trigraphs, etc.
525 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
526 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
527 Tok.getLocation(), PP);
528 if (Literal.hadError)
529 return ExprResult(true);
530
Chris Lattner1de66eb2007-08-26 03:42:43 +0000531 Expr *Res;
532
533 if (Literal.isFloatingLiteral()) {
Chris Lattner858eece2007-09-22 18:29:59 +0000534 QualType Ty;
Chris Lattner2a674dc2008-06-30 18:32:54 +0000535 if (Literal.isFloat)
Chris Lattner858eece2007-09-22 18:29:59 +0000536 Ty = Context.FloatTy;
Chris Lattner2a674dc2008-06-30 18:32:54 +0000537 else if (!Literal.isLong)
Chris Lattner858eece2007-09-22 18:29:59 +0000538 Ty = Context.DoubleTy;
Chris Lattner2a674dc2008-06-30 18:32:54 +0000539 else
Chris Lattnerfc18dcc2008-03-08 08:52:55 +0000540 Ty = Context.LongDoubleTy;
Chris Lattner2a674dc2008-06-30 18:32:54 +0000541
542 const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty);
543
Ted Kremenekddedbe22007-11-29 00:56:49 +0000544 // isExact will be set by GetFloatValue().
545 bool isExact = false;
Chris Lattner2a674dc2008-06-30 18:32:54 +0000546 Res = new FloatingLiteral(Literal.GetFloatValue(Format, &isExact), &isExact,
Ted Kremenekddedbe22007-11-29 00:56:49 +0000547 Ty, Tok.getLocation());
548
Chris Lattner1de66eb2007-08-26 03:42:43 +0000549 } else if (!Literal.isIntegerLiteral()) {
550 return ExprResult(true);
551 } else {
Chris Lattner48d7f382008-04-02 04:24:33 +0000552 QualType Ty;
Chris Lattner4b009652007-07-25 00:24:17 +0000553
Neil Booth7421e9c2007-08-29 22:00:19 +0000554 // long long is a C99 feature.
555 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
Neil Booth9bd47082007-08-29 22:13:52 +0000556 Literal.isLongLong)
Neil Booth7421e9c2007-08-29 22:00:19 +0000557 Diag(Tok.getLocation(), diag::ext_longlong);
558
Chris Lattner4b009652007-07-25 00:24:17 +0000559 // Get the value in the widest-possible width.
Chris Lattner8cd0e932008-03-05 18:54:05 +0000560 llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0);
Chris Lattner4b009652007-07-25 00:24:17 +0000561
562 if (Literal.GetIntegerValue(ResultVal)) {
563 // If this value didn't fit into uintmax_t, warn and force to ull.
564 Diag(Tok.getLocation(), diag::warn_integer_too_large);
Chris Lattner48d7f382008-04-02 04:24:33 +0000565 Ty = Context.UnsignedLongLongTy;
566 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
Chris Lattner8cd0e932008-03-05 18:54:05 +0000567 "long long is not intmax_t?");
Chris Lattner4b009652007-07-25 00:24:17 +0000568 } else {
569 // If this value fits into a ULL, try to figure out what else it fits into
570 // according to the rules of C99 6.4.4.1p5.
571
572 // Octal, Hexadecimal, and integers with a U suffix are allowed to
573 // be an unsigned int.
574 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
575
576 // Check from smallest to largest, picking the smallest type we can.
Chris Lattnere4068872008-05-09 05:59:00 +0000577 unsigned Width = 0;
Chris Lattner98540b62007-08-23 21:58:08 +0000578 if (!Literal.isLong && !Literal.isLongLong) {
579 // Are int/unsigned possibilities?
Chris Lattnere4068872008-05-09 05:59:00 +0000580 unsigned IntSize = Context.Target.getIntWidth();
581
Chris Lattner4b009652007-07-25 00:24:17 +0000582 // Does it fit in a unsigned int?
583 if (ResultVal.isIntN(IntSize)) {
584 // Does it fit in a signed int?
585 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
Chris Lattner48d7f382008-04-02 04:24:33 +0000586 Ty = Context.IntTy;
Chris Lattner4b009652007-07-25 00:24:17 +0000587 else if (AllowUnsigned)
Chris Lattner48d7f382008-04-02 04:24:33 +0000588 Ty = Context.UnsignedIntTy;
Chris Lattnere4068872008-05-09 05:59:00 +0000589 Width = IntSize;
Chris Lattner4b009652007-07-25 00:24:17 +0000590 }
Chris Lattner4b009652007-07-25 00:24:17 +0000591 }
592
593 // Are long/unsigned long possibilities?
Chris Lattner48d7f382008-04-02 04:24:33 +0000594 if (Ty.isNull() && !Literal.isLongLong) {
Chris Lattnere4068872008-05-09 05:59:00 +0000595 unsigned LongSize = Context.Target.getLongWidth();
Chris Lattner4b009652007-07-25 00:24:17 +0000596
597 // Does it fit in a unsigned long?
598 if (ResultVal.isIntN(LongSize)) {
599 // Does it fit in a signed long?
600 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
Chris Lattner48d7f382008-04-02 04:24:33 +0000601 Ty = Context.LongTy;
Chris Lattner4b009652007-07-25 00:24:17 +0000602 else if (AllowUnsigned)
Chris Lattner48d7f382008-04-02 04:24:33 +0000603 Ty = Context.UnsignedLongTy;
Chris Lattnere4068872008-05-09 05:59:00 +0000604 Width = LongSize;
Chris Lattner4b009652007-07-25 00:24:17 +0000605 }
Chris Lattner4b009652007-07-25 00:24:17 +0000606 }
607
608 // Finally, check long long if needed.
Chris Lattner48d7f382008-04-02 04:24:33 +0000609 if (Ty.isNull()) {
Chris Lattnere4068872008-05-09 05:59:00 +0000610 unsigned LongLongSize = Context.Target.getLongLongWidth();
Chris Lattner4b009652007-07-25 00:24:17 +0000611
612 // Does it fit in a unsigned long long?
613 if (ResultVal.isIntN(LongLongSize)) {
614 // Does it fit in a signed long long?
615 if (!Literal.isUnsigned && ResultVal[LongLongSize-1] == 0)
Chris Lattner48d7f382008-04-02 04:24:33 +0000616 Ty = Context.LongLongTy;
Chris Lattner4b009652007-07-25 00:24:17 +0000617 else if (AllowUnsigned)
Chris Lattner48d7f382008-04-02 04:24:33 +0000618 Ty = Context.UnsignedLongLongTy;
Chris Lattnere4068872008-05-09 05:59:00 +0000619 Width = LongLongSize;
Chris Lattner4b009652007-07-25 00:24:17 +0000620 }
621 }
622
623 // If we still couldn't decide a type, we probably have something that
624 // does not fit in a signed long long, but has no U suffix.
Chris Lattner48d7f382008-04-02 04:24:33 +0000625 if (Ty.isNull()) {
Chris Lattner4b009652007-07-25 00:24:17 +0000626 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed);
Chris Lattner48d7f382008-04-02 04:24:33 +0000627 Ty = Context.UnsignedLongLongTy;
Chris Lattnere4068872008-05-09 05:59:00 +0000628 Width = Context.Target.getLongLongWidth();
Chris Lattner4b009652007-07-25 00:24:17 +0000629 }
Chris Lattnere4068872008-05-09 05:59:00 +0000630
631 if (ResultVal.getBitWidth() != Width)
632 ResultVal.trunc(Width);
Chris Lattner4b009652007-07-25 00:24:17 +0000633 }
634
Chris Lattner48d7f382008-04-02 04:24:33 +0000635 Res = new IntegerLiteral(ResultVal, Ty, Tok.getLocation());
Chris Lattner4b009652007-07-25 00:24:17 +0000636 }
Chris Lattner1de66eb2007-08-26 03:42:43 +0000637
638 // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
639 if (Literal.isImaginary)
640 Res = new ImaginaryLiteral(Res, Context.getComplexType(Res->getType()));
641
642 return Res;
Chris Lattner4b009652007-07-25 00:24:17 +0000643}
644
Steve Naroff87d58b42007-09-16 03:34:24 +0000645Action::ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R,
Chris Lattner4b009652007-07-25 00:24:17 +0000646 ExprTy *Val) {
Chris Lattner48d7f382008-04-02 04:24:33 +0000647 Expr *E = (Expr *)Val;
648 assert((E != 0) && "ActOnParenExpr() missing expr");
649 return new ParenExpr(L, R, E);
Chris Lattner4b009652007-07-25 00:24:17 +0000650}
651
652/// The UsualUnaryConversions() function is *not* called by this routine.
653/// See C99 6.3.2.1p[2-4] for more details.
654QualType Sema::CheckSizeOfAlignOfOperand(QualType exprType,
Chris Lattnerf814d882008-07-25 21:45:37 +0000655 SourceLocation OpLoc,
656 const SourceRange &ExprRange,
657 bool isSizeof) {
Chris Lattner4b009652007-07-25 00:24:17 +0000658 // C99 6.5.3.4p1:
659 if (isa<FunctionType>(exprType) && isSizeof)
660 // alignof(function) is allowed.
Chris Lattnerf814d882008-07-25 21:45:37 +0000661 Diag(OpLoc, diag::ext_sizeof_function_type, ExprRange);
Chris Lattner4b009652007-07-25 00:24:17 +0000662 else if (exprType->isVoidType())
Chris Lattnerf814d882008-07-25 21:45:37 +0000663 Diag(OpLoc, diag::ext_sizeof_void_type, isSizeof ? "sizeof" : "__alignof",
664 ExprRange);
Chris Lattner4b009652007-07-25 00:24:17 +0000665 else if (exprType->isIncompleteType()) {
666 Diag(OpLoc, isSizeof ? diag::err_sizeof_incomplete_type :
667 diag::err_alignof_incomplete_type,
Chris Lattnerf814d882008-07-25 21:45:37 +0000668 exprType.getAsString(), ExprRange);
Chris Lattner4b009652007-07-25 00:24:17 +0000669 return QualType(); // error
670 }
671 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
672 return Context.getSizeType();
673}
674
675Action::ExprResult Sema::
Steve Naroff87d58b42007-09-16 03:34:24 +0000676ActOnSizeOfAlignOfTypeExpr(SourceLocation OpLoc, bool isSizeof,
Chris Lattner4b009652007-07-25 00:24:17 +0000677 SourceLocation LPLoc, TypeTy *Ty,
678 SourceLocation RPLoc) {
679 // If error parsing type, ignore.
680 if (Ty == 0) return true;
681
682 // Verify that this is a valid expression.
683 QualType ArgTy = QualType::getFromOpaquePtr(Ty);
684
Chris Lattnerf814d882008-07-25 21:45:37 +0000685 QualType resultType =
686 CheckSizeOfAlignOfOperand(ArgTy, OpLoc, SourceRange(LPLoc, RPLoc),isSizeof);
Chris Lattner4b009652007-07-25 00:24:17 +0000687
688 if (resultType.isNull())
689 return true;
690 return new SizeOfAlignOfTypeExpr(isSizeof, ArgTy, resultType, OpLoc, RPLoc);
691}
692
Chris Lattner5110ad52007-08-24 21:41:10 +0000693QualType Sema::CheckRealImagOperand(Expr *&V, SourceLocation Loc) {
Chris Lattner03931a72007-08-24 21:16:53 +0000694 DefaultFunctionArrayConversion(V);
695
Chris Lattnera16e42d2007-08-26 05:39:26 +0000696 // These operators return the element type of a complex type.
Chris Lattner03931a72007-08-24 21:16:53 +0000697 if (const ComplexType *CT = V->getType()->getAsComplexType())
698 return CT->getElementType();
Chris Lattnera16e42d2007-08-26 05:39:26 +0000699
700 // Otherwise they pass through real integer and floating point types here.
701 if (V->getType()->isArithmeticType())
702 return V->getType();
703
704 // Reject anything else.
705 Diag(Loc, diag::err_realimag_invalid_type, V->getType().getAsString());
706 return QualType();
Chris Lattner03931a72007-08-24 21:16:53 +0000707}
708
709
Chris Lattner4b009652007-07-25 00:24:17 +0000710
Steve Naroff87d58b42007-09-16 03:34:24 +0000711Action::ExprResult Sema::ActOnPostfixUnaryOp(SourceLocation OpLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000712 tok::TokenKind Kind,
713 ExprTy *Input) {
714 UnaryOperator::Opcode Opc;
715 switch (Kind) {
716 default: assert(0 && "Unknown unary op!");
717 case tok::plusplus: Opc = UnaryOperator::PostInc; break;
718 case tok::minusminus: Opc = UnaryOperator::PostDec; break;
719 }
720 QualType result = CheckIncrementDecrementOperand((Expr *)Input, OpLoc);
721 if (result.isNull())
722 return true;
723 return new UnaryOperator((Expr *)Input, Opc, result, OpLoc);
724}
725
726Action::ExprResult Sema::
Steve Naroff87d58b42007-09-16 03:34:24 +0000727ActOnArraySubscriptExpr(ExprTy *Base, SourceLocation LLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000728 ExprTy *Idx, SourceLocation RLoc) {
729 Expr *LHSExp = static_cast<Expr*>(Base), *RHSExp = static_cast<Expr*>(Idx);
730
731 // Perform default conversions.
732 DefaultFunctionArrayConversion(LHSExp);
733 DefaultFunctionArrayConversion(RHSExp);
734
735 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
736
737 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
Chris Lattner0d9bcea2007-08-30 17:45:32 +0000738 // to the expression *((e1)+(e2)). This means the array "Base" may actually be
Chris Lattner4b009652007-07-25 00:24:17 +0000739 // in the subscript position. As a result, we need to derive the array base
740 // and index from the expression types.
741 Expr *BaseExpr, *IndexExpr;
742 QualType ResultType;
Chris Lattner7931f4a2007-07-31 16:53:04 +0000743 if (const PointerType *PTy = LHSTy->getAsPointerType()) {
Chris Lattner4b009652007-07-25 00:24:17 +0000744 BaseExpr = LHSExp;
745 IndexExpr = RHSExp;
746 // FIXME: need to deal with const...
747 ResultType = PTy->getPointeeType();
Chris Lattner7931f4a2007-07-31 16:53:04 +0000748 } else if (const PointerType *PTy = RHSTy->getAsPointerType()) {
Chris Lattner4b009652007-07-25 00:24:17 +0000749 // Handle the uncommon case of "123[Ptr]".
750 BaseExpr = RHSExp;
751 IndexExpr = LHSExp;
752 // FIXME: need to deal with const...
753 ResultType = PTy->getPointeeType();
Chris Lattnere35a1042007-07-31 19:29:30 +0000754 } else if (const VectorType *VTy = LHSTy->getAsVectorType()) {
755 BaseExpr = LHSExp; // vectors: V[123]
Chris Lattner4b009652007-07-25 00:24:17 +0000756 IndexExpr = RHSExp;
Steve Naroff89345522007-08-03 22:40:33 +0000757
758 // Component access limited to variables (reject vec4.rg[1]).
Nate Begemanc8e51f82008-05-09 06:41:27 +0000759 if (!isa<DeclRefExpr>(BaseExpr) && !isa<ArraySubscriptExpr>(BaseExpr) &&
760 !isa<ExtVectorElementExpr>(BaseExpr))
Nate Begemanaf6ed502008-04-18 23:10:10 +0000761 return Diag(LLoc, diag::err_ext_vector_component_access,
Steve Naroff89345522007-08-03 22:40:33 +0000762 SourceRange(LLoc, RLoc));
Chris Lattner4b009652007-07-25 00:24:17 +0000763 // FIXME: need to deal with const...
764 ResultType = VTy->getElementType();
765 } else {
766 return Diag(LHSExp->getLocStart(), diag::err_typecheck_subscript_value,
767 RHSExp->getSourceRange());
768 }
769 // C99 6.5.2.1p1
770 if (!IndexExpr->getType()->isIntegerType())
771 return Diag(IndexExpr->getLocStart(), diag::err_typecheck_subscript,
772 IndexExpr->getSourceRange());
773
774 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". In practice,
775 // the following check catches trying to index a pointer to a function (e.g.
Chris Lattner9db553e2008-04-02 06:59:01 +0000776 // void (*)(int)) and pointers to incomplete types. Functions are not
777 // objects in C99.
Chris Lattner4b009652007-07-25 00:24:17 +0000778 if (!ResultType->isObjectType())
779 return Diag(BaseExpr->getLocStart(),
780 diag::err_typecheck_subscript_not_object,
781 BaseExpr->getType().getAsString(), BaseExpr->getSourceRange());
782
783 return new ArraySubscriptExpr(LHSExp, RHSExp, ResultType, RLoc);
784}
785
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000786QualType Sema::
Nate Begemanaf6ed502008-04-18 23:10:10 +0000787CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000788 IdentifierInfo &CompName, SourceLocation CompLoc) {
Nate Begemanaf6ed502008-04-18 23:10:10 +0000789 const ExtVectorType *vecType = baseType->getAsExtVectorType();
Nate Begemanc8e51f82008-05-09 06:41:27 +0000790
791 // This flag determines whether or not the component is to be treated as a
792 // special name, or a regular GLSL-style component access.
793 bool SpecialComponent = false;
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000794
795 // The vector accessor can't exceed the number of elements.
796 const char *compStr = CompName.getName();
797 if (strlen(compStr) > vecType->getNumElements()) {
Nate Begemanaf6ed502008-04-18 23:10:10 +0000798 Diag(OpLoc, diag::err_ext_vector_component_exceeds_length,
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000799 baseType.getAsString(), SourceRange(CompLoc));
800 return QualType();
801 }
Nate Begemanc8e51f82008-05-09 06:41:27 +0000802
803 // Check that we've found one of the special components, or that the component
804 // names must come from the same set.
805 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
806 !strcmp(compStr, "e") || !strcmp(compStr, "o")) {
807 SpecialComponent = true;
808 } else if (vecType->getPointAccessorIdx(*compStr) != -1) {
Chris Lattner9096b792007-08-02 22:33:49 +0000809 do
810 compStr++;
811 while (*compStr && vecType->getPointAccessorIdx(*compStr) != -1);
812 } else if (vecType->getColorAccessorIdx(*compStr) != -1) {
813 do
814 compStr++;
815 while (*compStr && vecType->getColorAccessorIdx(*compStr) != -1);
816 } else if (vecType->getTextureAccessorIdx(*compStr) != -1) {
817 do
818 compStr++;
819 while (*compStr && vecType->getTextureAccessorIdx(*compStr) != -1);
820 }
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000821
Nate Begemanc8e51f82008-05-09 06:41:27 +0000822 if (!SpecialComponent && *compStr) {
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000823 // We didn't get to the end of the string. This means the component names
824 // didn't come from the same set *or* we encountered an illegal name.
Nate Begemanaf6ed502008-04-18 23:10:10 +0000825 Diag(OpLoc, diag::err_ext_vector_component_name_illegal,
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000826 std::string(compStr,compStr+1), SourceRange(CompLoc));
827 return QualType();
828 }
829 // Each component accessor can't exceed the vector type.
830 compStr = CompName.getName();
831 while (*compStr) {
832 if (vecType->isAccessorWithinNumElements(*compStr))
833 compStr++;
834 else
835 break;
836 }
Nate Begemanc8e51f82008-05-09 06:41:27 +0000837 if (!SpecialComponent && *compStr) {
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000838 // We didn't get to the end of the string. This means a component accessor
839 // exceeds the number of elements in the vector.
Nate Begemanaf6ed502008-04-18 23:10:10 +0000840 Diag(OpLoc, diag::err_ext_vector_component_exceeds_length,
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000841 baseType.getAsString(), SourceRange(CompLoc));
842 return QualType();
843 }
Nate Begemanc8e51f82008-05-09 06:41:27 +0000844
845 // If we have a special component name, verify that the current vector length
846 // is an even number, since all special component names return exactly half
847 // the elements.
848 if (SpecialComponent && (vecType->getNumElements() & 1U)) {
Daniel Dunbar45a91802008-09-30 17:22:47 +0000849 Diag(OpLoc, diag::err_ext_vector_component_requires_even,
850 baseType.getAsString(), SourceRange(CompLoc));
Nate Begemanc8e51f82008-05-09 06:41:27 +0000851 return QualType();
852 }
853
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000854 // The component accessor looks fine - now we need to compute the actual type.
855 // The vector type is implied by the component accessor. For example,
856 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
Nate Begemanc8e51f82008-05-09 06:41:27 +0000857 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
858 unsigned CompSize = SpecialComponent ? vecType->getNumElements() / 2
859 : strlen(CompName.getName());
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000860 if (CompSize == 1)
861 return vecType->getElementType();
Steve Naroff82113e32007-07-29 16:33:31 +0000862
Nate Begemanaf6ed502008-04-18 23:10:10 +0000863 QualType VT = Context.getExtVectorType(vecType->getElementType(), CompSize);
Steve Naroff82113e32007-07-29 16:33:31 +0000864 // Now look up the TypeDefDecl from the vector type. Without this,
Nate Begemanaf6ed502008-04-18 23:10:10 +0000865 // diagostics look bad. We want extended vector types to appear built-in.
866 for (unsigned i = 0, E = ExtVectorDecls.size(); i != E; ++i) {
867 if (ExtVectorDecls[i]->getUnderlyingType() == VT)
868 return Context.getTypedefType(ExtVectorDecls[i]);
Steve Naroff82113e32007-07-29 16:33:31 +0000869 }
870 return VT; // should never get here (a typedef type should always be found).
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000871}
872
Daniel Dunbar60e8b162008-09-03 01:05:41 +0000873/// constructSetterName - Return the setter name for the given
874/// identifier, i.e. "set" + Name where the initial character of Name
875/// has been capitalized.
876// FIXME: Merge with same routine in Parser. But where should this
877// live?
878static IdentifierInfo *constructSetterName(IdentifierTable &Idents,
879 const IdentifierInfo *Name) {
880 unsigned N = Name->getLength();
881 char *SelectorName = new char[3 + N];
882 memcpy(SelectorName, "set", 3);
883 memcpy(&SelectorName[3], Name->getName(), N);
884 SelectorName[3] = toupper(SelectorName[3]);
885
886 IdentifierInfo *Setter =
887 &Idents.get(SelectorName, &SelectorName[3 + N]);
888 delete[] SelectorName;
889 return Setter;
890}
891
Chris Lattner4b009652007-07-25 00:24:17 +0000892Action::ExprResult Sema::
Steve Naroff87d58b42007-09-16 03:34:24 +0000893ActOnMemberReferenceExpr(ExprTy *Base, SourceLocation OpLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000894 tok::TokenKind OpKind, SourceLocation MemberLoc,
895 IdentifierInfo &Member) {
Steve Naroff2cb66382007-07-26 03:11:44 +0000896 Expr *BaseExpr = static_cast<Expr *>(Base);
897 assert(BaseExpr && "no record expression");
Steve Naroff137e11d2007-12-16 21:42:28 +0000898
899 // Perform default conversions.
900 DefaultFunctionArrayConversion(BaseExpr);
Chris Lattner4b009652007-07-25 00:24:17 +0000901
Steve Naroff2cb66382007-07-26 03:11:44 +0000902 QualType BaseType = BaseExpr->getType();
903 assert(!BaseType.isNull() && "no type for member expression");
Chris Lattner4b009652007-07-25 00:24:17 +0000904
Chris Lattnerb2b9da72008-07-21 04:36:39 +0000905 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
906 // must have pointer type, and the accessed type is the pointee.
Chris Lattner4b009652007-07-25 00:24:17 +0000907 if (OpKind == tok::arrow) {
Chris Lattner7931f4a2007-07-31 16:53:04 +0000908 if (const PointerType *PT = BaseType->getAsPointerType())
Steve Naroff2cb66382007-07-26 03:11:44 +0000909 BaseType = PT->getPointeeType();
910 else
Chris Lattner7d5a8762008-07-21 05:35:34 +0000911 return Diag(MemberLoc, diag::err_typecheck_member_reference_arrow,
912 BaseType.getAsString(), BaseExpr->getSourceRange());
Chris Lattner4b009652007-07-25 00:24:17 +0000913 }
Chris Lattnera57cf472008-07-21 04:28:12 +0000914
Chris Lattnerb2b9da72008-07-21 04:36:39 +0000915 // Handle field access to simple records. This also handles access to fields
916 // of the ObjC 'id' struct.
Chris Lattnere35a1042007-07-31 19:29:30 +0000917 if (const RecordType *RTy = BaseType->getAsRecordType()) {
Steve Naroff2cb66382007-07-26 03:11:44 +0000918 RecordDecl *RDecl = RTy->getDecl();
919 if (RTy->isIncompleteType())
920 return Diag(OpLoc, diag::err_typecheck_incomplete_tag, RDecl->getName(),
921 BaseExpr->getSourceRange());
922 // The record definition is complete, now make sure the member is valid.
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000923 FieldDecl *MemberDecl = RDecl->getMember(&Member);
924 if (!MemberDecl)
Chris Lattner7d5a8762008-07-21 05:35:34 +0000925 return Diag(MemberLoc, diag::err_typecheck_no_member, Member.getName(),
926 BaseExpr->getSourceRange());
Eli Friedman76b49832008-02-06 22:48:16 +0000927
928 // Figure out the type of the member; see C99 6.5.2.3p3
Eli Friedmanaedabcf2008-02-07 05:24:51 +0000929 // FIXME: Handle address space modifiers
Eli Friedman76b49832008-02-06 22:48:16 +0000930 QualType MemberType = MemberDecl->getType();
931 unsigned combinedQualifiers =
Chris Lattner35fef522008-02-20 20:55:12 +0000932 MemberType.getCVRQualifiers() | BaseType.getCVRQualifiers();
Eli Friedman76b49832008-02-06 22:48:16 +0000933 MemberType = MemberType.getQualifiedType(combinedQualifiers);
934
Chris Lattnerb2b9da72008-07-21 04:36:39 +0000935 return new MemberExpr(BaseExpr, OpKind == tok::arrow, MemberDecl,
Eli Friedman76b49832008-02-06 22:48:16 +0000936 MemberLoc, MemberType);
Chris Lattnera57cf472008-07-21 04:28:12 +0000937 }
938
Chris Lattnere9d71612008-07-21 04:59:05 +0000939 // Handle access to Objective-C instance variables, such as "Obj->ivar" and
940 // (*Obj).ivar.
Chris Lattnerb2b9da72008-07-21 04:36:39 +0000941 if (const ObjCInterfaceType *IFTy = BaseType->getAsObjCInterfaceType()) {
942 if (ObjCIvarDecl *IV = IFTy->getDecl()->lookupInstanceVariable(&Member))
Fariborz Jahanian4af72492007-11-12 22:29:28 +0000943 return new ObjCIvarRefExpr(IV, IV->getType(), MemberLoc, BaseExpr,
Chris Lattnera57cf472008-07-21 04:28:12 +0000944 OpKind == tok::arrow);
Chris Lattner7d5a8762008-07-21 05:35:34 +0000945 return Diag(MemberLoc, diag::err_typecheck_member_reference_ivar,
Chris Lattner52292be2008-07-21 04:42:08 +0000946 IFTy->getDecl()->getName(), Member.getName(),
Chris Lattner7d5a8762008-07-21 05:35:34 +0000947 BaseExpr->getSourceRange());
Chris Lattnera57cf472008-07-21 04:28:12 +0000948 }
949
Chris Lattnere9d71612008-07-21 04:59:05 +0000950 // Handle Objective-C property access, which is "Obj.property" where Obj is a
951 // pointer to a (potentially qualified) interface type.
952 const PointerType *PTy;
953 const ObjCInterfaceType *IFTy;
954 if (OpKind == tok::period && (PTy = BaseType->getAsPointerType()) &&
955 (IFTy = PTy->getPointeeType()->getAsObjCInterfaceType())) {
956 ObjCInterfaceDecl *IFace = IFTy->getDecl();
Daniel Dunbardd851282008-08-30 05:35:15 +0000957
Daniel Dunbar60e8b162008-09-03 01:05:41 +0000958 // Search for a declared property first.
Chris Lattnere9d71612008-07-21 04:59:05 +0000959 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(&Member))
960 return new ObjCPropertyRefExpr(PD, PD->getType(), MemberLoc, BaseExpr);
961
Daniel Dunbar60e8b162008-09-03 01:05:41 +0000962 // Check protocols on qualified interfaces.
Chris Lattnerd5f81792008-07-21 05:20:01 +0000963 for (ObjCInterfaceType::qual_iterator I = IFTy->qual_begin(),
964 E = IFTy->qual_end(); I != E; ++I)
965 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(&Member))
966 return new ObjCPropertyRefExpr(PD, PD->getType(), MemberLoc, BaseExpr);
Daniel Dunbar60e8b162008-09-03 01:05:41 +0000967
968 // If that failed, look for an "implicit" property by seeing if the nullary
969 // selector is implemented.
970
971 // FIXME: The logic for looking up nullary and unary selectors should be
972 // shared with the code in ActOnInstanceMessage.
973
974 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
975 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
976
977 // If this reference is in an @implementation, check for 'private' methods.
978 if (!Getter)
979 if (ObjCMethodDecl *CurMeth = getCurMethodDecl())
980 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
981 if (ObjCImplementationDecl *ImpDecl =
982 ObjCImplementations[ClassDecl->getIdentifier()])
983 Getter = ImpDecl->getInstanceMethod(Sel);
984
985 if (Getter) {
986 // If we found a getter then this may be a valid dot-reference, we
987 // need to also look for the matching setter.
988 IdentifierInfo *SetterName = constructSetterName(PP.getIdentifierTable(),
989 &Member);
990 Selector SetterSel = PP.getSelectorTable().getUnarySelector(SetterName);
991 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
992
993 if (!Setter) {
994 if (ObjCMethodDecl *CurMeth = getCurMethodDecl())
995 if (ObjCInterfaceDecl *ClassDecl = CurMeth->getClassInterface())
996 if (ObjCImplementationDecl *ImpDecl =
997 ObjCImplementations[ClassDecl->getIdentifier()])
998 Setter = ImpDecl->getInstanceMethod(SetterSel);
999 }
1000
1001 // FIXME: There are some issues here. First, we are not
1002 // diagnosing accesses to read-only properties because we do not
1003 // know if this is a getter or setter yet. Second, we are
1004 // checking that the type of the setter matches the type we
1005 // expect.
1006 return new ObjCPropertyRefExpr(Getter, Setter, Getter->getResultType(),
1007 MemberLoc, BaseExpr);
1008 }
Fariborz Jahanian4af72492007-11-12 22:29:28 +00001009 }
Chris Lattnera57cf472008-07-21 04:28:12 +00001010
1011 // Handle 'field access' to vectors, such as 'V.xx'.
1012 if (BaseType->isExtVectorType() && OpKind == tok::period) {
1013 // Component access limited to variables (reject vec4.rg.g).
1014 if (!isa<DeclRefExpr>(BaseExpr) && !isa<ArraySubscriptExpr>(BaseExpr) &&
1015 !isa<ExtVectorElementExpr>(BaseExpr))
Chris Lattner7d5a8762008-07-21 05:35:34 +00001016 return Diag(MemberLoc, diag::err_ext_vector_component_access,
1017 BaseExpr->getSourceRange());
Chris Lattnera57cf472008-07-21 04:28:12 +00001018 QualType ret = CheckExtVectorComponent(BaseType, OpLoc, Member, MemberLoc);
1019 if (ret.isNull())
1020 return true;
1021 return new ExtVectorElementExpr(ret, BaseExpr, Member, MemberLoc);
1022 }
1023
Chris Lattner7d5a8762008-07-21 05:35:34 +00001024 return Diag(MemberLoc, diag::err_typecheck_member_reference_struct_union,
1025 BaseType.getAsString(), BaseExpr->getSourceRange());
Chris Lattner4b009652007-07-25 00:24:17 +00001026}
1027
Steve Naroff87d58b42007-09-16 03:34:24 +00001028/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Chris Lattner4b009652007-07-25 00:24:17 +00001029/// This provides the location of the left/right parens and a list of comma
1030/// locations.
1031Action::ExprResult Sema::
Steve Naroff87d58b42007-09-16 03:34:24 +00001032ActOnCallExpr(ExprTy *fn, SourceLocation LParenLoc,
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001033 ExprTy **args, unsigned NumArgs,
Chris Lattner4b009652007-07-25 00:24:17 +00001034 SourceLocation *CommaLocs, SourceLocation RParenLoc) {
1035 Expr *Fn = static_cast<Expr *>(fn);
1036 Expr **Args = reinterpret_cast<Expr**>(args);
1037 assert(Fn && "no function call expression");
Chris Lattner3e254fb2008-04-08 04:40:51 +00001038 FunctionDecl *FDecl = NULL;
Chris Lattner3e254fb2008-04-08 04:40:51 +00001039
1040 // Promote the function operand.
1041 UsualUnaryConversions(Fn);
1042
1043 // If we're directly calling a function, get the declaration for
1044 // that function.
1045 if (ImplicitCastExpr *IcExpr = dyn_cast<ImplicitCastExpr>(Fn))
1046 if (DeclRefExpr *DRExpr = dyn_cast<DeclRefExpr>(IcExpr->getSubExpr()))
1047 FDecl = dyn_cast<FunctionDecl>(DRExpr->getDecl());
1048
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001049 // Make the call expr early, before semantic checks. This guarantees cleanup
1050 // of arguments and function on error.
Chris Lattner97316c02008-04-10 02:22:51 +00001051 llvm::OwningPtr<CallExpr> TheCall(new CallExpr(Fn, Args, NumArgs,
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001052 Context.BoolTy, RParenLoc));
Steve Naroffd6163f32008-09-05 22:11:13 +00001053 const FunctionType *FuncT;
1054 if (!Fn->getType()->isBlockPointerType()) {
1055 // C99 6.5.2.2p1 - "The expression that denotes the called function shall
1056 // have type pointer to function".
1057 const PointerType *PT = Fn->getType()->getAsPointerType();
1058 if (PT == 0)
1059 return Diag(LParenLoc, diag::err_typecheck_call_not_function,
1060 Fn->getSourceRange());
1061 FuncT = PT->getPointeeType()->getAsFunctionType();
1062 } else { // This is a block call.
1063 FuncT = Fn->getType()->getAsBlockPointerType()->getPointeeType()->
1064 getAsFunctionType();
1065 }
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001066 if (FuncT == 0)
Chris Lattner61000b12008-08-14 04:33:24 +00001067 return Diag(LParenLoc, diag::err_typecheck_call_not_function,
1068 Fn->getSourceRange());
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001069
1070 // We know the result type of the call, set it.
1071 TheCall->setType(FuncT->getResultType());
Chris Lattner4b009652007-07-25 00:24:17 +00001072
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001073 if (const FunctionTypeProto *Proto = dyn_cast<FunctionTypeProto>(FuncT)) {
Chris Lattner4b009652007-07-25 00:24:17 +00001074 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
1075 // assignment, to the types of the corresponding parameter, ...
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001076 unsigned NumArgsInProto = Proto->getNumArgs();
1077 unsigned NumArgsToCheck = NumArgs;
Chris Lattner4b009652007-07-25 00:24:17 +00001078
Chris Lattner3e254fb2008-04-08 04:40:51 +00001079 // If too few arguments are available (and we don't have default
1080 // arguments for the remaining parameters), don't make the call.
1081 if (NumArgs < NumArgsInProto) {
Chris Lattner97316c02008-04-10 02:22:51 +00001082 if (FDecl && NumArgs >= FDecl->getMinRequiredArguments()) {
Chris Lattner3e254fb2008-04-08 04:40:51 +00001083 // Use default arguments for missing arguments
1084 NumArgsToCheck = NumArgsInProto;
Chris Lattner97316c02008-04-10 02:22:51 +00001085 TheCall->setNumArgs(NumArgsInProto);
Chris Lattner3e254fb2008-04-08 04:40:51 +00001086 } else
Steve Naroffd6163f32008-09-05 22:11:13 +00001087 return Diag(RParenLoc,
1088 !Fn->getType()->isBlockPointerType()
1089 ? diag::err_typecheck_call_too_few_args
1090 : diag::err_typecheck_block_too_few_args,
Chris Lattner3e254fb2008-04-08 04:40:51 +00001091 Fn->getSourceRange());
1092 }
1093
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001094 // If too many are passed and not variadic, error on the extras and drop
1095 // them.
1096 if (NumArgs > NumArgsInProto) {
1097 if (!Proto->isVariadic()) {
Chris Lattner4b009652007-07-25 00:24:17 +00001098 Diag(Args[NumArgsInProto]->getLocStart(),
Steve Naroffd6163f32008-09-05 22:11:13 +00001099 !Fn->getType()->isBlockPointerType()
1100 ? diag::err_typecheck_call_too_many_args
1101 : diag::err_typecheck_block_too_many_args,
1102 Fn->getSourceRange(),
Chris Lattner4b009652007-07-25 00:24:17 +00001103 SourceRange(Args[NumArgsInProto]->getLocStart(),
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001104 Args[NumArgs-1]->getLocEnd()));
1105 // This deletes the extra arguments.
1106 TheCall->setNumArgs(NumArgsInProto);
Chris Lattner4b009652007-07-25 00:24:17 +00001107 }
1108 NumArgsToCheck = NumArgsInProto;
1109 }
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001110
Chris Lattner4b009652007-07-25 00:24:17 +00001111 // Continue to check argument types (even if we have too few/many args).
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001112 for (unsigned i = 0; i != NumArgsToCheck; i++) {
Chris Lattner005ed752008-01-04 18:04:52 +00001113 QualType ProtoArgType = Proto->getArgType(i);
Chris Lattner3e254fb2008-04-08 04:40:51 +00001114
1115 Expr *Arg;
1116 if (i < NumArgs)
1117 Arg = Args[i];
1118 else
1119 Arg = new CXXDefaultArgExpr(FDecl->getParamDecl(i));
Chris Lattner005ed752008-01-04 18:04:52 +00001120 QualType ArgType = Arg->getType();
Chris Lattner4b009652007-07-25 00:24:17 +00001121
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001122 // Compute implicit casts from the operand to the formal argument type.
Chris Lattner005ed752008-01-04 18:04:52 +00001123 AssignConvertType ConvTy =
1124 CheckSingleAssignmentConstraints(ProtoArgType, Arg);
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001125 TheCall->setArg(i, Arg);
Eli Friedman583c31e2008-09-02 05:09:35 +00001126
Chris Lattner005ed752008-01-04 18:04:52 +00001127 if (DiagnoseAssignmentResult(ConvTy, Arg->getLocStart(), ProtoArgType,
1128 ArgType, Arg, "passing"))
1129 return true;
Chris Lattner4b009652007-07-25 00:24:17 +00001130 }
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001131
1132 // If this is a variadic call, handle args passed through "...".
1133 if (Proto->isVariadic()) {
Steve Naroffdb65e052007-08-28 23:30:39 +00001134 // Promote the arguments (C99 6.5.2.2p7).
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001135 for (unsigned i = NumArgsInProto; i != NumArgs; i++) {
1136 Expr *Arg = Args[i];
1137 DefaultArgumentPromotion(Arg);
1138 TheCall->setArg(i, Arg);
Steve Naroffdb65e052007-08-28 23:30:39 +00001139 }
Steve Naroffdb65e052007-08-28 23:30:39 +00001140 }
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001141 } else {
1142 assert(isa<FunctionTypeNoProto>(FuncT) && "Unknown FunctionType!");
1143
Steve Naroffdb65e052007-08-28 23:30:39 +00001144 // Promote the arguments (C99 6.5.2.2p6).
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001145 for (unsigned i = 0; i != NumArgs; i++) {
1146 Expr *Arg = Args[i];
1147 DefaultArgumentPromotion(Arg);
1148 TheCall->setArg(i, Arg);
Steve Naroffdb65e052007-08-28 23:30:39 +00001149 }
Chris Lattner4b009652007-07-25 00:24:17 +00001150 }
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001151
Chris Lattner2e64c072007-08-10 20:18:51 +00001152 // Do special checking on direct calls to functions.
Eli Friedmand0e9d092008-05-14 19:38:39 +00001153 if (FDecl)
1154 return CheckFunctionCall(FDecl, TheCall.take());
Chris Lattner2e64c072007-08-10 20:18:51 +00001155
Chris Lattner83bd5eb2007-12-28 05:29:59 +00001156 return TheCall.take();
Chris Lattner4b009652007-07-25 00:24:17 +00001157}
1158
1159Action::ExprResult Sema::
Steve Naroff87d58b42007-09-16 03:34:24 +00001160ActOnCompoundLiteral(SourceLocation LParenLoc, TypeTy *Ty,
Chris Lattner4b009652007-07-25 00:24:17 +00001161 SourceLocation RParenLoc, ExprTy *InitExpr) {
Steve Naroff87d58b42007-09-16 03:34:24 +00001162 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type");
Chris Lattner4b009652007-07-25 00:24:17 +00001163 QualType literalType = QualType::getFromOpaquePtr(Ty);
1164 // FIXME: put back this assert when initializers are worked out.
Steve Naroff87d58b42007-09-16 03:34:24 +00001165 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
Chris Lattner4b009652007-07-25 00:24:17 +00001166 Expr *literalExpr = static_cast<Expr*>(InitExpr);
Anders Carlsson9374b852007-12-05 07:24:19 +00001167
Eli Friedman8c2173d2008-05-20 05:22:08 +00001168 if (literalType->isArrayType()) {
Chris Lattnera1923f62008-08-04 07:31:14 +00001169 if (literalType->isVariableArrayType())
Eli Friedman8c2173d2008-05-20 05:22:08 +00001170 return Diag(LParenLoc,
1171 diag::err_variable_object_no_init,
1172 SourceRange(LParenLoc,
1173 literalExpr->getSourceRange().getEnd()));
1174 } else if (literalType->isIncompleteType()) {
1175 return Diag(LParenLoc,
1176 diag::err_typecheck_decl_incomplete_type,
1177 literalType.getAsString(),
1178 SourceRange(LParenLoc,
1179 literalExpr->getSourceRange().getEnd()));
1180 }
1181
Steve Narofff0b23542008-01-10 22:15:12 +00001182 if (CheckInitializerTypes(literalExpr, literalType))
Steve Naroff92590f92008-01-09 20:58:06 +00001183 return true;
Steve Naroffbe37fc02008-01-14 18:19:28 +00001184
Argiris Kirtzidis95256e62008-06-28 06:07:14 +00001185 bool isFileScope = !getCurFunctionDecl() && !getCurMethodDecl();
Steve Naroffbe37fc02008-01-14 18:19:28 +00001186 if (isFileScope) { // 6.5.2.5p3
Steve Narofff0b23542008-01-10 22:15:12 +00001187 if (CheckForConstantInitializer(literalExpr, literalType))
1188 return true;
1189 }
Steve Naroffbe37fc02008-01-14 18:19:28 +00001190 return new CompoundLiteralExpr(LParenLoc, literalType, literalExpr, isFileScope);
Chris Lattner4b009652007-07-25 00:24:17 +00001191}
1192
1193Action::ExprResult Sema::
Steve Naroff87d58b42007-09-16 03:34:24 +00001194ActOnInitList(SourceLocation LBraceLoc, ExprTy **initlist, unsigned NumInit,
Anders Carlsson762b7c72007-08-31 04:56:16 +00001195 SourceLocation RBraceLoc) {
Steve Naroffe14e5542007-09-02 02:04:30 +00001196 Expr **InitList = reinterpret_cast<Expr**>(initlist);
Anders Carlsson762b7c72007-08-31 04:56:16 +00001197
Steve Naroff0acc9c92007-09-15 18:49:24 +00001198 // Semantic analysis for initializers is done by ActOnDeclarator() and
Steve Naroff1c9de712007-09-03 01:24:23 +00001199 // CheckInitializer() - it requires knowledge of the object being intialized.
Anders Carlsson762b7c72007-08-31 04:56:16 +00001200
Chris Lattner48d7f382008-04-02 04:24:33 +00001201 InitListExpr *E = new InitListExpr(LBraceLoc, InitList, NumInit, RBraceLoc);
1202 E->setType(Context.VoidTy); // FIXME: just a place holder for now.
1203 return E;
Chris Lattner4b009652007-07-25 00:24:17 +00001204}
1205
Argiris Kirtzidis95de23a2008-08-16 20:27:34 +00001206/// CheckCastTypes - Check type constraints for casting between types.
Daniel Dunbar5ad49de2008-08-20 03:55:42 +00001207bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr) {
Argiris Kirtzidis95de23a2008-08-16 20:27:34 +00001208 UsualUnaryConversions(castExpr);
1209
1210 // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
1211 // type needs to be scalar.
1212 if (castType->isVoidType()) {
1213 // Cast to void allows any expr type.
1214 } else if (!castType->isScalarType() && !castType->isVectorType()) {
1215 // GCC struct/union extension: allow cast to self.
1216 if (Context.getCanonicalType(castType) !=
1217 Context.getCanonicalType(castExpr->getType()) ||
1218 (!castType->isStructureType() && !castType->isUnionType())) {
1219 // Reject any other conversions to non-scalar types.
1220 return Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar,
1221 castType.getAsString(), castExpr->getSourceRange());
1222 }
1223
1224 // accept this, but emit an ext-warn.
1225 Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar,
1226 castType.getAsString(), castExpr->getSourceRange());
1227 } else if (!castExpr->getType()->isScalarType() &&
1228 !castExpr->getType()->isVectorType()) {
1229 return Diag(castExpr->getLocStart(),
1230 diag::err_typecheck_expect_scalar_operand,
1231 castExpr->getType().getAsString(),castExpr->getSourceRange());
1232 } else if (castExpr->getType()->isVectorType()) {
1233 if (CheckVectorCast(TyR, castExpr->getType(), castType))
1234 return true;
1235 } else if (castType->isVectorType()) {
1236 if (CheckVectorCast(TyR, castType, castExpr->getType()))
1237 return true;
1238 }
1239 return false;
1240}
1241
Chris Lattnerd1f26b32007-12-20 00:44:32 +00001242bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty) {
Anders Carlssonf257b4c2007-11-27 05:51:55 +00001243 assert(VectorTy->isVectorType() && "Not a vector type!");
1244
1245 if (Ty->isVectorType() || Ty->isIntegerType()) {
Chris Lattner8cd0e932008-03-05 18:54:05 +00001246 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty))
Anders Carlssonf257b4c2007-11-27 05:51:55 +00001247 return Diag(R.getBegin(),
1248 Ty->isVectorType() ?
1249 diag::err_invalid_conversion_between_vectors :
1250 diag::err_invalid_conversion_between_vector_and_integer,
1251 VectorTy.getAsString().c_str(),
1252 Ty.getAsString().c_str(), R);
1253 } else
1254 return Diag(R.getBegin(),
1255 diag::err_invalid_conversion_between_vector_and_scalar,
1256 VectorTy.getAsString().c_str(),
1257 Ty.getAsString().c_str(), R);
1258
1259 return false;
1260}
1261
Chris Lattner4b009652007-07-25 00:24:17 +00001262Action::ExprResult Sema::
Steve Naroff87d58b42007-09-16 03:34:24 +00001263ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
Chris Lattner4b009652007-07-25 00:24:17 +00001264 SourceLocation RParenLoc, ExprTy *Op) {
Steve Naroff87d58b42007-09-16 03:34:24 +00001265 assert((Ty != 0) && (Op != 0) && "ActOnCastExpr(): missing type or expr");
Chris Lattner4b009652007-07-25 00:24:17 +00001266
1267 Expr *castExpr = static_cast<Expr*>(Op);
1268 QualType castType = QualType::getFromOpaquePtr(Ty);
1269
Argiris Kirtzidis95de23a2008-08-16 20:27:34 +00001270 if (CheckCastTypes(SourceRange(LParenLoc, RParenLoc), castType, castExpr))
1271 return true;
Argiris Kirtzidisc45e2fb2008-08-18 23:01:59 +00001272 return new ExplicitCastExpr(castType, castExpr, LParenLoc);
Chris Lattner4b009652007-07-25 00:24:17 +00001273}
1274
Chris Lattner98a425c2007-11-26 01:40:58 +00001275/// Note that lex is not null here, even if this is the gnu "x ?: y" extension.
1276/// In that case, lex = cond.
Chris Lattner4b009652007-07-25 00:24:17 +00001277inline QualType Sema::CheckConditionalOperands( // C99 6.5.15
1278 Expr *&cond, Expr *&lex, Expr *&rex, SourceLocation questionLoc) {
1279 UsualUnaryConversions(cond);
1280 UsualUnaryConversions(lex);
1281 UsualUnaryConversions(rex);
1282 QualType condT = cond->getType();
1283 QualType lexT = lex->getType();
1284 QualType rexT = rex->getType();
1285
1286 // first, check the condition.
1287 if (!condT->isScalarType()) { // C99 6.5.15p2
1288 Diag(cond->getLocStart(), diag::err_typecheck_cond_expect_scalar,
1289 condT.getAsString());
1290 return QualType();
1291 }
Chris Lattner992ae932008-01-06 22:42:25 +00001292
1293 // Now check the two expressions.
1294
1295 // If both operands have arithmetic type, do the usual arithmetic conversions
1296 // to find a common type: C99 6.5.15p3,5.
1297 if (lexT->isArithmeticType() && rexT->isArithmeticType()) {
Chris Lattner4b009652007-07-25 00:24:17 +00001298 UsualArithmeticConversions(lex, rex);
1299 return lex->getType();
1300 }
Chris Lattner992ae932008-01-06 22:42:25 +00001301
1302 // If both operands are the same structure or union type, the result is that
1303 // type.
Chris Lattner71225142007-07-31 21:27:01 +00001304 if (const RecordType *LHSRT = lexT->getAsRecordType()) { // C99 6.5.15p3
Chris Lattner992ae932008-01-06 22:42:25 +00001305 if (const RecordType *RHSRT = rexT->getAsRecordType())
Chris Lattner98a425c2007-11-26 01:40:58 +00001306 if (LHSRT->getDecl() == RHSRT->getDecl())
Chris Lattner992ae932008-01-06 22:42:25 +00001307 // "If both the operands have structure or union type, the result has
1308 // that type." This implies that CV qualifiers are dropped.
1309 return lexT.getUnqualifiedType();
Chris Lattner4b009652007-07-25 00:24:17 +00001310 }
Chris Lattner992ae932008-01-06 22:42:25 +00001311
1312 // C99 6.5.15p5: "If both operands have void type, the result has void type."
Steve Naroff95cb3892008-05-12 21:44:38 +00001313 // The following || allows only one side to be void (a GCC-ism).
1314 if (lexT->isVoidType() || rexT->isVoidType()) {
Eli Friedmanf025aac2008-06-04 19:47:51 +00001315 if (!lexT->isVoidType())
Steve Naroff95cb3892008-05-12 21:44:38 +00001316 Diag(rex->getLocStart(), diag::ext_typecheck_cond_one_void,
1317 rex->getSourceRange());
1318 if (!rexT->isVoidType())
1319 Diag(lex->getLocStart(), diag::ext_typecheck_cond_one_void,
Nuno Lopes4ba41fd2008-06-04 19:14:12 +00001320 lex->getSourceRange());
Eli Friedmanf025aac2008-06-04 19:47:51 +00001321 ImpCastExprToType(lex, Context.VoidTy);
1322 ImpCastExprToType(rex, Context.VoidTy);
1323 return Context.VoidTy;
Steve Naroff95cb3892008-05-12 21:44:38 +00001324 }
Steve Naroff12ebf272008-01-08 01:11:38 +00001325 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
1326 // the type of the other operand."
Daniel Dunbara7b5fb92008-09-11 23:12:46 +00001327 if ((lexT->isPointerType() || lexT->isBlockPointerType() ||
1328 Context.isObjCObjectPointerType(lexT)) &&
Steve Naroff3eac7692008-09-10 19:17:48 +00001329 rex->isNullPointerConstant(Context)) {
Chris Lattnere992d6c2008-01-16 19:17:22 +00001330 ImpCastExprToType(rex, lexT); // promote the null to a pointer.
Steve Naroff12ebf272008-01-08 01:11:38 +00001331 return lexT;
1332 }
Daniel Dunbara7b5fb92008-09-11 23:12:46 +00001333 if ((rexT->isPointerType() || rexT->isBlockPointerType() ||
1334 Context.isObjCObjectPointerType(rexT)) &&
Steve Naroff3eac7692008-09-10 19:17:48 +00001335 lex->isNullPointerConstant(Context)) {
Chris Lattnere992d6c2008-01-16 19:17:22 +00001336 ImpCastExprToType(lex, rexT); // promote the null to a pointer.
Steve Naroff12ebf272008-01-08 01:11:38 +00001337 return rexT;
1338 }
Chris Lattner0ac51632008-01-06 22:50:31 +00001339 // Handle the case where both operands are pointers before we handle null
1340 // pointer constants in case both operands are null pointer constants.
Chris Lattner71225142007-07-31 21:27:01 +00001341 if (const PointerType *LHSPT = lexT->getAsPointerType()) { // C99 6.5.15p3,6
1342 if (const PointerType *RHSPT = rexT->getAsPointerType()) {
1343 // get the "pointed to" types
1344 QualType lhptee = LHSPT->getPointeeType();
1345 QualType rhptee = RHSPT->getPointeeType();
Chris Lattner4b009652007-07-25 00:24:17 +00001346
Chris Lattner71225142007-07-31 21:27:01 +00001347 // ignore qualifiers on void (C99 6.5.15p3, clause 6)
1348 if (lhptee->isVoidType() &&
Chris Lattner9db553e2008-04-02 06:59:01 +00001349 rhptee->isIncompleteOrObjectType()) {
Chris Lattner35fef522008-02-20 20:55:12 +00001350 // Figure out necessary qualifiers (C99 6.5.15p6)
1351 QualType destPointee=lhptee.getQualifiedType(rhptee.getCVRQualifiers());
Eli Friedmanca07c902008-02-10 22:59:36 +00001352 QualType destType = Context.getPointerType(destPointee);
1353 ImpCastExprToType(lex, destType); // add qualifiers if necessary
1354 ImpCastExprToType(rex, destType); // promote to void*
1355 return destType;
1356 }
Chris Lattner9db553e2008-04-02 06:59:01 +00001357 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
Chris Lattner35fef522008-02-20 20:55:12 +00001358 QualType destPointee=rhptee.getQualifiedType(lhptee.getCVRQualifiers());
Eli Friedmanca07c902008-02-10 22:59:36 +00001359 QualType destType = Context.getPointerType(destPointee);
1360 ImpCastExprToType(lex, destType); // add qualifiers if necessary
1361 ImpCastExprToType(rex, destType); // promote to void*
1362 return destType;
1363 }
Chris Lattner4b009652007-07-25 00:24:17 +00001364
Daniel Dunbara7b5fb92008-09-11 23:12:46 +00001365 QualType compositeType = lexT;
1366
1367 // If either type is an Objective-C object type then check
1368 // compatibility according to Objective-C.
1369 if (Context.isObjCObjectPointerType(lexT) ||
1370 Context.isObjCObjectPointerType(rexT)) {
1371 // If both operands are interfaces and either operand can be
1372 // assigned to the other, use that type as the composite
1373 // type. This allows
1374 // xxx ? (A*) a : (B*) b
1375 // where B is a subclass of A.
1376 //
1377 // Additionally, as for assignment, if either type is 'id'
1378 // allow silent coercion. Finally, if the types are
1379 // incompatible then make sure to use 'id' as the composite
1380 // type so the result is acceptable for sending messages to.
1381
1382 // FIXME: This code should not be localized to here. Also this
1383 // should use a compatible check instead of abusing the
1384 // canAssignObjCInterfaces code.
1385 const ObjCInterfaceType* LHSIface = lhptee->getAsObjCInterfaceType();
1386 const ObjCInterfaceType* RHSIface = rhptee->getAsObjCInterfaceType();
1387 if (LHSIface && RHSIface &&
1388 Context.canAssignObjCInterfaces(LHSIface, RHSIface)) {
1389 compositeType = lexT;
1390 } else if (LHSIface && RHSIface &&
1391 Context.canAssignObjCInterfaces(LHSIface, RHSIface)) {
1392 compositeType = rexT;
1393 } else if (Context.isObjCIdType(lhptee) ||
1394 Context.isObjCIdType(rhptee)) {
1395 // FIXME: This code looks wrong, because isObjCIdType checks
1396 // the struct but getObjCIdType returns the pointer to
1397 // struct. This is horrible and should be fixed.
1398 compositeType = Context.getObjCIdType();
1399 } else {
1400 QualType incompatTy = Context.getObjCIdType();
1401 ImpCastExprToType(lex, incompatTy);
1402 ImpCastExprToType(rex, incompatTy);
1403 return incompatTy;
1404 }
1405 } else if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(),
1406 rhptee.getUnqualifiedType())) {
Steve Naroff232324e2008-02-01 22:44:48 +00001407 Diag(questionLoc, diag::warn_typecheck_cond_incompatible_pointers,
Chris Lattner71225142007-07-31 21:27:01 +00001408 lexT.getAsString(), rexT.getAsString(),
1409 lex->getSourceRange(), rex->getSourceRange());
Daniel Dunbara7b5fb92008-09-11 23:12:46 +00001410 // In this situation, we assume void* type. No especially good
1411 // reason, but this is what gcc does, and we do have to pick
1412 // to get a consistent AST.
1413 QualType incompatTy = Context.getPointerType(Context.VoidTy);
Daniel Dunbarcd23bb22008-08-26 00:41:39 +00001414 ImpCastExprToType(lex, incompatTy);
1415 ImpCastExprToType(rex, incompatTy);
1416 return incompatTy;
Chris Lattner71225142007-07-31 21:27:01 +00001417 }
1418 // The pointer types are compatible.
Chris Lattner0d9bcea2007-08-30 17:45:32 +00001419 // C99 6.5.15p6: If both operands are pointers to compatible types *or* to
1420 // differently qualified versions of compatible types, the result type is
1421 // a pointer to an appropriately qualified version of the *composite*
1422 // type.
Eli Friedmane38150e2008-05-16 20:37:07 +00001423 // FIXME: Need to calculate the composite type.
Eli Friedmanca07c902008-02-10 22:59:36 +00001424 // FIXME: Need to add qualifiers
Eli Friedmane38150e2008-05-16 20:37:07 +00001425 ImpCastExprToType(lex, compositeType);
1426 ImpCastExprToType(rex, compositeType);
1427 return compositeType;
Chris Lattner4b009652007-07-25 00:24:17 +00001428 }
Chris Lattner4b009652007-07-25 00:24:17 +00001429 }
Daniel Dunbara7b5fb92008-09-11 23:12:46 +00001430 // Need to handle "id<xx>" explicitly. Unlike "id", whose canonical type
1431 // evaluates to "struct objc_object *" (and is handled above when comparing
1432 // id with statically typed objects).
1433 if (lexT->isObjCQualifiedIdType() || rexT->isObjCQualifiedIdType()) {
1434 // GCC allows qualified id and any Objective-C type to devolve to
1435 // id. Currently localizing to here until clear this should be
1436 // part of ObjCQualifiedIdTypesAreCompatible.
1437 if (ObjCQualifiedIdTypesAreCompatible(lexT, rexT, true) ||
1438 (lexT->isObjCQualifiedIdType() &&
1439 Context.isObjCObjectPointerType(rexT)) ||
1440 (rexT->isObjCQualifiedIdType() &&
1441 Context.isObjCObjectPointerType(lexT))) {
1442 // FIXME: This is not the correct composite type. This only
1443 // happens to work because id can more or less be used anywhere,
1444 // however this may change the type of method sends.
1445 // FIXME: gcc adds some type-checking of the arguments and emits
1446 // (confusing) incompatible comparison warnings in some
1447 // cases. Investigate.
1448 QualType compositeType = Context.getObjCIdType();
1449 ImpCastExprToType(lex, compositeType);
1450 ImpCastExprToType(rex, compositeType);
1451 return compositeType;
1452 }
1453 }
1454
Steve Naroff3eac7692008-09-10 19:17:48 +00001455 // Selection between block pointer types is ok as long as they are the same.
1456 if (lexT->isBlockPointerType() && rexT->isBlockPointerType() &&
1457 Context.getCanonicalType(lexT) == Context.getCanonicalType(rexT))
1458 return lexT;
1459
Chris Lattner992ae932008-01-06 22:42:25 +00001460 // Otherwise, the operands are not compatible.
Chris Lattner4b009652007-07-25 00:24:17 +00001461 Diag(questionLoc, diag::err_typecheck_cond_incompatible_operands,
1462 lexT.getAsString(), rexT.getAsString(),
1463 lex->getSourceRange(), rex->getSourceRange());
1464 return QualType();
1465}
1466
Steve Naroff87d58b42007-09-16 03:34:24 +00001467/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Chris Lattner4b009652007-07-25 00:24:17 +00001468/// in the case of a the GNU conditional expr extension.
Steve Naroff87d58b42007-09-16 03:34:24 +00001469Action::ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
Chris Lattner4b009652007-07-25 00:24:17 +00001470 SourceLocation ColonLoc,
1471 ExprTy *Cond, ExprTy *LHS,
1472 ExprTy *RHS) {
1473 Expr *CondExpr = (Expr *) Cond;
1474 Expr *LHSExpr = (Expr *) LHS, *RHSExpr = (Expr *) RHS;
Chris Lattner98a425c2007-11-26 01:40:58 +00001475
1476 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
1477 // was the condition.
1478 bool isLHSNull = LHSExpr == 0;
1479 if (isLHSNull)
1480 LHSExpr = CondExpr;
1481
Chris Lattner4b009652007-07-25 00:24:17 +00001482 QualType result = CheckConditionalOperands(CondExpr, LHSExpr,
1483 RHSExpr, QuestionLoc);
1484 if (result.isNull())
1485 return true;
Chris Lattner98a425c2007-11-26 01:40:58 +00001486 return new ConditionalOperator(CondExpr, isLHSNull ? 0 : LHSExpr,
1487 RHSExpr, result);
Chris Lattner4b009652007-07-25 00:24:17 +00001488}
1489
Chris Lattner4b009652007-07-25 00:24:17 +00001490
1491// CheckPointerTypesForAssignment - This is a very tricky routine (despite
1492// being closely modeled after the C99 spec:-). The odd characteristic of this
1493// routine is it effectively iqnores the qualifiers on the top level pointee.
1494// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
1495// FIXME: add a couple examples in this comment.
Chris Lattner005ed752008-01-04 18:04:52 +00001496Sema::AssignConvertType
Chris Lattner4b009652007-07-25 00:24:17 +00001497Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) {
1498 QualType lhptee, rhptee;
1499
1500 // get the "pointed to" type (ignoring qualifiers at the top level)
Chris Lattner71225142007-07-31 21:27:01 +00001501 lhptee = lhsType->getAsPointerType()->getPointeeType();
1502 rhptee = rhsType->getAsPointerType()->getPointeeType();
Chris Lattner4b009652007-07-25 00:24:17 +00001503
1504 // make sure we operate on the canonical type
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00001505 lhptee = Context.getCanonicalType(lhptee);
1506 rhptee = Context.getCanonicalType(rhptee);
Chris Lattner4b009652007-07-25 00:24:17 +00001507
Chris Lattner005ed752008-01-04 18:04:52 +00001508 AssignConvertType ConvTy = Compatible;
Chris Lattner4b009652007-07-25 00:24:17 +00001509
1510 // C99 6.5.16.1p1: This following citation is common to constraints
1511 // 3 & 4 (below). ...and the type *pointed to* by the left has all the
1512 // qualifiers of the type *pointed to* by the right;
Chris Lattner35fef522008-02-20 20:55:12 +00001513 // FIXME: Handle ASQualType
1514 if ((lhptee.getCVRQualifiers() & rhptee.getCVRQualifiers()) !=
1515 rhptee.getCVRQualifiers())
Chris Lattner005ed752008-01-04 18:04:52 +00001516 ConvTy = CompatiblePointerDiscardsQualifiers;
Chris Lattner4b009652007-07-25 00:24:17 +00001517
1518 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
1519 // incomplete type and the other is a pointer to a qualified or unqualified
1520 // version of void...
Chris Lattner4ca3d772008-01-03 22:56:36 +00001521 if (lhptee->isVoidType()) {
Chris Lattner9db553e2008-04-02 06:59:01 +00001522 if (rhptee->isIncompleteOrObjectType())
Chris Lattner005ed752008-01-04 18:04:52 +00001523 return ConvTy;
Chris Lattner4ca3d772008-01-03 22:56:36 +00001524
1525 // As an extension, we allow cast to/from void* to function pointer.
Chris Lattner9db553e2008-04-02 06:59:01 +00001526 assert(rhptee->isFunctionType());
1527 return FunctionVoidPointer;
Chris Lattner4ca3d772008-01-03 22:56:36 +00001528 }
1529
1530 if (rhptee->isVoidType()) {
Chris Lattner9db553e2008-04-02 06:59:01 +00001531 if (lhptee->isIncompleteOrObjectType())
Chris Lattner005ed752008-01-04 18:04:52 +00001532 return ConvTy;
Chris Lattner4ca3d772008-01-03 22:56:36 +00001533
1534 // As an extension, we allow cast to/from void* to function pointer.
Chris Lattner9db553e2008-04-02 06:59:01 +00001535 assert(lhptee->isFunctionType());
1536 return FunctionVoidPointer;
Chris Lattner4ca3d772008-01-03 22:56:36 +00001537 }
Eli Friedman0d9549b2008-08-22 00:56:42 +00001538
1539 // Check for ObjC interfaces
1540 const ObjCInterfaceType* LHSIface = lhptee->getAsObjCInterfaceType();
1541 const ObjCInterfaceType* RHSIface = rhptee->getAsObjCInterfaceType();
1542 if (LHSIface && RHSIface &&
1543 Context.canAssignObjCInterfaces(LHSIface, RHSIface))
1544 return ConvTy;
1545
1546 // ID acts sort of like void* for ObjC interfaces
1547 if (LHSIface && Context.isObjCIdType(rhptee))
1548 return ConvTy;
1549 if (RHSIface && Context.isObjCIdType(lhptee))
1550 return ConvTy;
1551
Chris Lattner4b009652007-07-25 00:24:17 +00001552 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
1553 // unqualified versions of compatible types, ...
Chris Lattner4ca3d772008-01-03 22:56:36 +00001554 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(),
1555 rhptee.getUnqualifiedType()))
1556 return IncompatiblePointer; // this "trumps" PointerAssignDiscardsQualifiers
Chris Lattner005ed752008-01-04 18:04:52 +00001557 return ConvTy;
Chris Lattner4b009652007-07-25 00:24:17 +00001558}
1559
Steve Naroff3454b6c2008-09-04 15:10:53 +00001560/// CheckBlockPointerTypesForAssignment - This routine determines whether two
1561/// block pointer types are compatible or whether a block and normal pointer
1562/// are compatible. It is more restrict than comparing two function pointer
1563// types.
1564Sema::AssignConvertType
1565Sema::CheckBlockPointerTypesForAssignment(QualType lhsType,
1566 QualType rhsType) {
1567 QualType lhptee, rhptee;
1568
1569 // get the "pointed to" type (ignoring qualifiers at the top level)
1570 lhptee = lhsType->getAsBlockPointerType()->getPointeeType();
1571 rhptee = rhsType->getAsBlockPointerType()->getPointeeType();
1572
1573 // make sure we operate on the canonical type
1574 lhptee = Context.getCanonicalType(lhptee);
1575 rhptee = Context.getCanonicalType(rhptee);
1576
1577 AssignConvertType ConvTy = Compatible;
1578
1579 // For blocks we enforce that qualifiers are identical.
1580 if (lhptee.getCVRQualifiers() != rhptee.getCVRQualifiers())
1581 ConvTy = CompatiblePointerDiscardsQualifiers;
1582
1583 if (!Context.typesAreBlockCompatible(lhptee, rhptee))
1584 return IncompatibleBlockPointer;
1585 return ConvTy;
1586}
1587
Chris Lattner4b009652007-07-25 00:24:17 +00001588/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
1589/// has code to accommodate several GCC extensions when type checking
1590/// pointers. Here are some objectionable examples that GCC considers warnings:
1591///
1592/// int a, *pint;
1593/// short *pshort;
1594/// struct foo *pfoo;
1595///
1596/// pint = pshort; // warning: assignment from incompatible pointer type
1597/// a = pint; // warning: assignment makes integer from pointer without a cast
1598/// pint = a; // warning: assignment makes pointer from integer without a cast
1599/// pint = pfoo; // warning: assignment from incompatible pointer type
1600///
1601/// As a result, the code for dealing with pointers is more complex than the
1602/// C99 spec dictates.
Chris Lattner4b009652007-07-25 00:24:17 +00001603///
Chris Lattner005ed752008-01-04 18:04:52 +00001604Sema::AssignConvertType
Chris Lattner4b009652007-07-25 00:24:17 +00001605Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) {
Chris Lattner1853da22008-01-04 23:18:45 +00001606 // Get canonical types. We're not formatting these types, just comparing
1607 // them.
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00001608 lhsType = Context.getCanonicalType(lhsType).getUnqualifiedType();
1609 rhsType = Context.getCanonicalType(rhsType).getUnqualifiedType();
Eli Friedman48d0bb02008-05-30 18:07:22 +00001610
1611 if (lhsType == rhsType)
Chris Lattnerfdd96d72008-01-07 17:51:46 +00001612 return Compatible; // Common case: fast path an exact match.
Chris Lattner4b009652007-07-25 00:24:17 +00001613
Anders Carlssoncebb8d62007-10-12 23:56:29 +00001614 if (lhsType->isReferenceType() || rhsType->isReferenceType()) {
Chris Lattnere1577e22008-04-07 06:52:53 +00001615 if (Context.typesAreCompatible(lhsType, rhsType))
Anders Carlssoncebb8d62007-10-12 23:56:29 +00001616 return Compatible;
Chris Lattner1853da22008-01-04 23:18:45 +00001617 return Incompatible;
Fariborz Jahanian957442d2007-12-19 17:45:58 +00001618 }
Eli Friedman48d0bb02008-05-30 18:07:22 +00001619
Chris Lattnerfe1f4032008-04-07 05:30:13 +00001620 if (lhsType->isObjCQualifiedIdType() || rhsType->isObjCQualifiedIdType()) {
1621 if (ObjCQualifiedIdTypesAreCompatible(lhsType, rhsType, false))
Fariborz Jahanian957442d2007-12-19 17:45:58 +00001622 return Compatible;
Steve Naroff936c4362008-06-03 14:04:54 +00001623 // Relax integer conversions like we do for pointers below.
1624 if (rhsType->isIntegerType())
1625 return IntToPointer;
1626 if (lhsType->isIntegerType())
1627 return PointerToInt;
Chris Lattner1853da22008-01-04 23:18:45 +00001628 return Incompatible;
Fariborz Jahanian957442d2007-12-19 17:45:58 +00001629 }
Chris Lattnerdb22bf42008-01-04 23:32:24 +00001630
Nate Begemanc5f0f652008-07-14 18:02:46 +00001631 if (lhsType->isVectorType() || rhsType->isVectorType()) {
Nate Begemanaf6ed502008-04-18 23:10:10 +00001632 // For ExtVector, allow vector splats; float -> <n x float>
Nate Begemanc5f0f652008-07-14 18:02:46 +00001633 if (const ExtVectorType *LV = lhsType->getAsExtVectorType())
1634 if (LV->getElementType() == rhsType)
Chris Lattnerdb22bf42008-01-04 23:32:24 +00001635 return Compatible;
Eli Friedman48d0bb02008-05-30 18:07:22 +00001636
Nate Begemanc5f0f652008-07-14 18:02:46 +00001637 // If we are allowing lax vector conversions, and LHS and RHS are both
1638 // vectors, the total size only needs to be the same. This is a bitcast;
1639 // no bits are changed but the result type is different.
Chris Lattnerdb22bf42008-01-04 23:32:24 +00001640 if (getLangOptions().LaxVectorConversions &&
1641 lhsType->isVectorType() && rhsType->isVectorType()) {
Nate Begemanc5f0f652008-07-14 18:02:46 +00001642 if (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType))
1643 return Compatible;
Chris Lattnerdb22bf42008-01-04 23:32:24 +00001644 }
1645 return Incompatible;
1646 }
Eli Friedman48d0bb02008-05-30 18:07:22 +00001647
Chris Lattnerdb22bf42008-01-04 23:32:24 +00001648 if (lhsType->isArithmeticType() && rhsType->isArithmeticType())
Chris Lattner4b009652007-07-25 00:24:17 +00001649 return Compatible;
Eli Friedman48d0bb02008-05-30 18:07:22 +00001650
Chris Lattner390564e2008-04-07 06:49:41 +00001651 if (isa<PointerType>(lhsType)) {
Chris Lattner4b009652007-07-25 00:24:17 +00001652 if (rhsType->isIntegerType())
Chris Lattnerd951b7b2008-01-04 18:22:42 +00001653 return IntToPointer;
Eli Friedman48d0bb02008-05-30 18:07:22 +00001654
Chris Lattner390564e2008-04-07 06:49:41 +00001655 if (isa<PointerType>(rhsType))
Chris Lattner4b009652007-07-25 00:24:17 +00001656 return CheckPointerTypesForAssignment(lhsType, rhsType);
Steve Naroff3454b6c2008-09-04 15:10:53 +00001657
Steve Naroffa982c712008-09-29 18:10:17 +00001658 if (rhsType->getAsBlockPointerType()) {
Steve Naroffd6163f32008-09-05 22:11:13 +00001659 if (lhsType->getAsPointerType()->getPointeeType()->isVoidType())
Steve Naroff3454b6c2008-09-04 15:10:53 +00001660 return BlockVoidPointer;
Steve Naroffa982c712008-09-29 18:10:17 +00001661
1662 // Treat block pointers as objects.
1663 if (getLangOptions().ObjC1 &&
1664 lhsType == Context.getCanonicalType(Context.getObjCIdType()))
1665 return Compatible;
1666 }
Steve Naroff3454b6c2008-09-04 15:10:53 +00001667 return Incompatible;
1668 }
1669
1670 if (isa<BlockPointerType>(lhsType)) {
1671 if (rhsType->isIntegerType())
1672 return IntToPointer;
1673
Steve Naroffa982c712008-09-29 18:10:17 +00001674 // Treat block pointers as objects.
1675 if (getLangOptions().ObjC1 &&
1676 rhsType == Context.getCanonicalType(Context.getObjCIdType()))
1677 return Compatible;
1678
Steve Naroff3454b6c2008-09-04 15:10:53 +00001679 if (rhsType->isBlockPointerType())
1680 return CheckBlockPointerTypesForAssignment(lhsType, rhsType);
1681
1682 if (const PointerType *RHSPT = rhsType->getAsPointerType()) {
1683 if (RHSPT->getPointeeType()->isVoidType())
1684 return BlockVoidPointer;
1685 }
Chris Lattner1853da22008-01-04 23:18:45 +00001686 return Incompatible;
1687 }
1688
Chris Lattner390564e2008-04-07 06:49:41 +00001689 if (isa<PointerType>(rhsType)) {
Chris Lattner4b009652007-07-25 00:24:17 +00001690 // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer.
Eli Friedman48d0bb02008-05-30 18:07:22 +00001691 if (lhsType == Context.BoolTy)
1692 return Compatible;
1693
1694 if (lhsType->isIntegerType())
Chris Lattnerd951b7b2008-01-04 18:22:42 +00001695 return PointerToInt;
Chris Lattner4b009652007-07-25 00:24:17 +00001696
Chris Lattner390564e2008-04-07 06:49:41 +00001697 if (isa<PointerType>(lhsType))
Chris Lattner4b009652007-07-25 00:24:17 +00001698 return CheckPointerTypesForAssignment(lhsType, rhsType);
Steve Naroff3454b6c2008-09-04 15:10:53 +00001699
1700 if (isa<BlockPointerType>(lhsType) &&
1701 rhsType->getAsPointerType()->getPointeeType()->isVoidType())
1702 return BlockVoidPointer;
Chris Lattner1853da22008-01-04 23:18:45 +00001703 return Incompatible;
Chris Lattner1853da22008-01-04 23:18:45 +00001704 }
Eli Friedman48d0bb02008-05-30 18:07:22 +00001705
Chris Lattner1853da22008-01-04 23:18:45 +00001706 if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) {
Chris Lattner390564e2008-04-07 06:49:41 +00001707 if (Context.typesAreCompatible(lhsType, rhsType))
Chris Lattner4b009652007-07-25 00:24:17 +00001708 return Compatible;
Chris Lattner4b009652007-07-25 00:24:17 +00001709 }
1710 return Incompatible;
1711}
1712
Chris Lattner005ed752008-01-04 18:04:52 +00001713Sema::AssignConvertType
Chris Lattner4b009652007-07-25 00:24:17 +00001714Sema::CheckSingleAssignmentConstraints(QualType lhsType, Expr *&rExpr) {
Steve Naroffcdee22d2007-11-27 17:58:44 +00001715 // C99 6.5.16.1p1: the left operand is a pointer and the right is
1716 // a null pointer constant.
Steve Naroff4fea7b62008-09-04 16:56:14 +00001717 if ((lhsType->isPointerType() || lhsType->isObjCQualifiedIdType() ||
1718 lhsType->isBlockPointerType())
Fariborz Jahaniana13effb2008-01-03 18:46:52 +00001719 && rExpr->isNullPointerConstant(Context)) {
Chris Lattnere992d6c2008-01-16 19:17:22 +00001720 ImpCastExprToType(rExpr, lhsType);
Steve Naroffcdee22d2007-11-27 17:58:44 +00001721 return Compatible;
1722 }
Steve Naroff3454b6c2008-09-04 15:10:53 +00001723
1724 // We don't allow conversion of non-null-pointer constants to integers.
1725 if (lhsType->isBlockPointerType() && rExpr->getType()->isIntegerType())
1726 return IntToBlockPointer;
1727
Chris Lattner5f505bf2007-10-16 02:55:40 +00001728 // This check seems unnatural, however it is necessary to ensure the proper
Chris Lattner4b009652007-07-25 00:24:17 +00001729 // conversion of functions/arrays. If the conversion were done for all
Steve Naroff0acc9c92007-09-15 18:49:24 +00001730 // DeclExpr's (created by ActOnIdentifierExpr), it would mess up the unary
Chris Lattner4b009652007-07-25 00:24:17 +00001731 // expressions that surpress this implicit conversion (&, sizeof).
Chris Lattner5f505bf2007-10-16 02:55:40 +00001732 //
1733 // Suppress this for references: C99 8.5.3p5. FIXME: revisit when references
1734 // are better understood.
1735 if (!lhsType->isReferenceType())
1736 DefaultFunctionArrayConversion(rExpr);
Steve Naroff0f32f432007-08-24 22:33:52 +00001737
Chris Lattner005ed752008-01-04 18:04:52 +00001738 Sema::AssignConvertType result =
1739 CheckAssignmentConstraints(lhsType, rExpr->getType());
Steve Naroff0f32f432007-08-24 22:33:52 +00001740
1741 // C99 6.5.16.1p2: The value of the right operand is converted to the
1742 // type of the assignment expression.
1743 if (rExpr->getType() != lhsType)
Chris Lattnere992d6c2008-01-16 19:17:22 +00001744 ImpCastExprToType(rExpr, lhsType);
Steve Naroff0f32f432007-08-24 22:33:52 +00001745 return result;
Chris Lattner4b009652007-07-25 00:24:17 +00001746}
1747
Chris Lattner005ed752008-01-04 18:04:52 +00001748Sema::AssignConvertType
Chris Lattner4b009652007-07-25 00:24:17 +00001749Sema::CheckCompoundAssignmentConstraints(QualType lhsType, QualType rhsType) {
1750 return CheckAssignmentConstraints(lhsType, rhsType);
1751}
1752
Chris Lattner2c8bff72007-12-12 05:47:28 +00001753QualType Sema::InvalidOperands(SourceLocation loc, Expr *&lex, Expr *&rex) {
Chris Lattner4b009652007-07-25 00:24:17 +00001754 Diag(loc, diag::err_typecheck_invalid_operands,
1755 lex->getType().getAsString(), rex->getType().getAsString(),
1756 lex->getSourceRange(), rex->getSourceRange());
Chris Lattner2c8bff72007-12-12 05:47:28 +00001757 return QualType();
Chris Lattner4b009652007-07-25 00:24:17 +00001758}
1759
1760inline QualType Sema::CheckVectorOperands(SourceLocation loc, Expr *&lex,
1761 Expr *&rex) {
Nate Begeman03105572008-04-04 01:30:25 +00001762 // For conversion purposes, we ignore any qualifiers.
1763 // For example, "const float" and "float" are equivalent.
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00001764 QualType lhsType =
1765 Context.getCanonicalType(lex->getType()).getUnqualifiedType();
1766 QualType rhsType =
1767 Context.getCanonicalType(rex->getType()).getUnqualifiedType();
Chris Lattner4b009652007-07-25 00:24:17 +00001768
Nate Begemanc5f0f652008-07-14 18:02:46 +00001769 // If the vector types are identical, return.
Nate Begeman03105572008-04-04 01:30:25 +00001770 if (lhsType == rhsType)
Chris Lattner4b009652007-07-25 00:24:17 +00001771 return lhsType;
Nate Begemanec2d1062007-12-30 02:59:45 +00001772
Nate Begemanc5f0f652008-07-14 18:02:46 +00001773 // Handle the case of a vector & extvector type of the same size and element
1774 // type. It would be nice if we only had one vector type someday.
1775 if (getLangOptions().LaxVectorConversions)
1776 if (const VectorType *LV = lhsType->getAsVectorType())
1777 if (const VectorType *RV = rhsType->getAsVectorType())
1778 if (LV->getElementType() == RV->getElementType() &&
1779 LV->getNumElements() == RV->getNumElements())
1780 return lhsType->isExtVectorType() ? lhsType : rhsType;
1781
1782 // If the lhs is an extended vector and the rhs is a scalar of the same type
1783 // or a literal, promote the rhs to the vector type.
Nate Begemanaf6ed502008-04-18 23:10:10 +00001784 if (const ExtVectorType *V = lhsType->getAsExtVectorType()) {
Nate Begemanc5f0f652008-07-14 18:02:46 +00001785 QualType eltType = V->getElementType();
1786
1787 if ((eltType->getAsBuiltinType() == rhsType->getAsBuiltinType()) ||
1788 (eltType->isIntegerType() && isa<IntegerLiteral>(rex)) ||
1789 (eltType->isFloatingType() && isa<FloatingLiteral>(rex))) {
Chris Lattnere992d6c2008-01-16 19:17:22 +00001790 ImpCastExprToType(rex, lhsType);
Nate Begemanec2d1062007-12-30 02:59:45 +00001791 return lhsType;
1792 }
1793 }
1794
Nate Begemanc5f0f652008-07-14 18:02:46 +00001795 // If the rhs is an extended vector and the lhs is a scalar of the same type,
Nate Begemanec2d1062007-12-30 02:59:45 +00001796 // promote the lhs to the vector type.
Nate Begemanaf6ed502008-04-18 23:10:10 +00001797 if (const ExtVectorType *V = rhsType->getAsExtVectorType()) {
Nate Begemanc5f0f652008-07-14 18:02:46 +00001798 QualType eltType = V->getElementType();
1799
1800 if ((eltType->getAsBuiltinType() == lhsType->getAsBuiltinType()) ||
1801 (eltType->isIntegerType() && isa<IntegerLiteral>(lex)) ||
1802 (eltType->isFloatingType() && isa<FloatingLiteral>(lex))) {
Chris Lattnere992d6c2008-01-16 19:17:22 +00001803 ImpCastExprToType(lex, rhsType);
Nate Begemanec2d1062007-12-30 02:59:45 +00001804 return rhsType;
1805 }
1806 }
1807
Chris Lattner4b009652007-07-25 00:24:17 +00001808 // You cannot convert between vector values of different size.
1809 Diag(loc, diag::err_typecheck_vector_not_convertable,
1810 lex->getType().getAsString(), rex->getType().getAsString(),
1811 lex->getSourceRange(), rex->getSourceRange());
1812 return QualType();
1813}
1814
1815inline QualType Sema::CheckMultiplyDivideOperands(
Steve Naroff8f708362007-08-24 19:07:16 +00001816 Expr *&lex, Expr *&rex, SourceLocation loc, bool isCompAssign)
Chris Lattner4b009652007-07-25 00:24:17 +00001817{
1818 QualType lhsType = lex->getType(), rhsType = rex->getType();
1819
1820 if (lhsType->isVectorType() || rhsType->isVectorType())
1821 return CheckVectorOperands(loc, lex, rex);
1822
Steve Naroff8f708362007-08-24 19:07:16 +00001823 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Chris Lattner4b009652007-07-25 00:24:17 +00001824
Chris Lattner4b009652007-07-25 00:24:17 +00001825 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
Steve Naroff8f708362007-08-24 19:07:16 +00001826 return compType;
Chris Lattner2c8bff72007-12-12 05:47:28 +00001827 return InvalidOperands(loc, lex, rex);
Chris Lattner4b009652007-07-25 00:24:17 +00001828}
1829
1830inline QualType Sema::CheckRemainderOperands(
Steve Naroff8f708362007-08-24 19:07:16 +00001831 Expr *&lex, Expr *&rex, SourceLocation loc, bool isCompAssign)
Chris Lattner4b009652007-07-25 00:24:17 +00001832{
1833 QualType lhsType = lex->getType(), rhsType = rex->getType();
1834
Steve Naroff8f708362007-08-24 19:07:16 +00001835 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Chris Lattner4b009652007-07-25 00:24:17 +00001836
Chris Lattner4b009652007-07-25 00:24:17 +00001837 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
Steve Naroff8f708362007-08-24 19:07:16 +00001838 return compType;
Chris Lattner2c8bff72007-12-12 05:47:28 +00001839 return InvalidOperands(loc, lex, rex);
Chris Lattner4b009652007-07-25 00:24:17 +00001840}
1841
1842inline QualType Sema::CheckAdditionOperands( // C99 6.5.6
Steve Naroff8f708362007-08-24 19:07:16 +00001843 Expr *&lex, Expr *&rex, SourceLocation loc, bool isCompAssign)
Chris Lattner4b009652007-07-25 00:24:17 +00001844{
1845 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
1846 return CheckVectorOperands(loc, lex, rex);
1847
Steve Naroff8f708362007-08-24 19:07:16 +00001848 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Eli Friedmand9b1fec2008-05-18 18:08:51 +00001849
Chris Lattner4b009652007-07-25 00:24:17 +00001850 // handle the common case first (both operands are arithmetic).
1851 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
Steve Naroff8f708362007-08-24 19:07:16 +00001852 return compType;
Chris Lattner4b009652007-07-25 00:24:17 +00001853
Eli Friedmand9b1fec2008-05-18 18:08:51 +00001854 // Put any potential pointer into PExp
1855 Expr* PExp = lex, *IExp = rex;
1856 if (IExp->getType()->isPointerType())
1857 std::swap(PExp, IExp);
1858
1859 if (const PointerType* PTy = PExp->getType()->getAsPointerType()) {
1860 if (IExp->getType()->isIntegerType()) {
1861 // Check for arithmetic on pointers to incomplete types
1862 if (!PTy->getPointeeType()->isObjectType()) {
1863 if (PTy->getPointeeType()->isVoidType()) {
1864 Diag(loc, diag::ext_gnu_void_ptr,
1865 lex->getSourceRange(), rex->getSourceRange());
1866 } else {
1867 Diag(loc, diag::err_typecheck_arithmetic_incomplete_type,
1868 lex->getType().getAsString(), lex->getSourceRange());
1869 return QualType();
1870 }
1871 }
1872 return PExp->getType();
1873 }
1874 }
1875
Chris Lattner2c8bff72007-12-12 05:47:28 +00001876 return InvalidOperands(loc, lex, rex);
Chris Lattner4b009652007-07-25 00:24:17 +00001877}
1878
Chris Lattnerfe1f4032008-04-07 05:30:13 +00001879// C99 6.5.6
1880QualType Sema::CheckSubtractionOperands(Expr *&lex, Expr *&rex,
1881 SourceLocation loc, bool isCompAssign) {
Chris Lattner4b009652007-07-25 00:24:17 +00001882 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
1883 return CheckVectorOperands(loc, lex, rex);
1884
Steve Naroff8f708362007-08-24 19:07:16 +00001885 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Chris Lattner4b009652007-07-25 00:24:17 +00001886
Chris Lattnerf6da2912007-12-09 21:53:25 +00001887 // Enforce type constraints: C99 6.5.6p3.
1888
1889 // Handle the common case first (both operands are arithmetic).
Chris Lattner4b009652007-07-25 00:24:17 +00001890 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
Steve Naroff8f708362007-08-24 19:07:16 +00001891 return compType;
Chris Lattnerf6da2912007-12-09 21:53:25 +00001892
1893 // Either ptr - int or ptr - ptr.
1894 if (const PointerType *LHSPTy = lex->getType()->getAsPointerType()) {
Steve Naroff577f9722008-01-29 18:58:14 +00001895 QualType lpointee = LHSPTy->getPointeeType();
Eli Friedman50727042008-02-08 01:19:44 +00001896
Chris Lattnerf6da2912007-12-09 21:53:25 +00001897 // The LHS must be an object type, not incomplete, function, etc.
Steve Naroff577f9722008-01-29 18:58:14 +00001898 if (!lpointee->isObjectType()) {
Chris Lattnerf6da2912007-12-09 21:53:25 +00001899 // Handle the GNU void* extension.
Steve Naroff577f9722008-01-29 18:58:14 +00001900 if (lpointee->isVoidType()) {
Chris Lattnerf6da2912007-12-09 21:53:25 +00001901 Diag(loc, diag::ext_gnu_void_ptr,
1902 lex->getSourceRange(), rex->getSourceRange());
1903 } else {
1904 Diag(loc, diag::err_typecheck_sub_ptr_object,
1905 lex->getType().getAsString(), lex->getSourceRange());
1906 return QualType();
1907 }
1908 }
1909
1910 // The result type of a pointer-int computation is the pointer type.
1911 if (rex->getType()->isIntegerType())
1912 return lex->getType();
Chris Lattner4b009652007-07-25 00:24:17 +00001913
Chris Lattnerf6da2912007-12-09 21:53:25 +00001914 // Handle pointer-pointer subtractions.
1915 if (const PointerType *RHSPTy = rex->getType()->getAsPointerType()) {
Eli Friedman50727042008-02-08 01:19:44 +00001916 QualType rpointee = RHSPTy->getPointeeType();
1917
Chris Lattnerf6da2912007-12-09 21:53:25 +00001918 // RHS must be an object type, unless void (GNU).
Steve Naroff577f9722008-01-29 18:58:14 +00001919 if (!rpointee->isObjectType()) {
Chris Lattnerf6da2912007-12-09 21:53:25 +00001920 // Handle the GNU void* extension.
Steve Naroff577f9722008-01-29 18:58:14 +00001921 if (rpointee->isVoidType()) {
1922 if (!lpointee->isVoidType())
Chris Lattnerf6da2912007-12-09 21:53:25 +00001923 Diag(loc, diag::ext_gnu_void_ptr,
1924 lex->getSourceRange(), rex->getSourceRange());
1925 } else {
1926 Diag(loc, diag::err_typecheck_sub_ptr_object,
1927 rex->getType().getAsString(), rex->getSourceRange());
1928 return QualType();
1929 }
1930 }
1931
1932 // Pointee types must be compatible.
Eli Friedman583c31e2008-09-02 05:09:35 +00001933 if (!Context.typesAreCompatible(
1934 Context.getCanonicalType(lpointee).getUnqualifiedType(),
1935 Context.getCanonicalType(rpointee).getUnqualifiedType())) {
Chris Lattnerf6da2912007-12-09 21:53:25 +00001936 Diag(loc, diag::err_typecheck_sub_ptr_compatible,
1937 lex->getType().getAsString(), rex->getType().getAsString(),
1938 lex->getSourceRange(), rex->getSourceRange());
1939 return QualType();
1940 }
1941
1942 return Context.getPointerDiffType();
1943 }
1944 }
1945
Chris Lattner2c8bff72007-12-12 05:47:28 +00001946 return InvalidOperands(loc, lex, rex);
Chris Lattner4b009652007-07-25 00:24:17 +00001947}
1948
Chris Lattnerfe1f4032008-04-07 05:30:13 +00001949// C99 6.5.7
1950QualType Sema::CheckShiftOperands(Expr *&lex, Expr *&rex, SourceLocation loc,
1951 bool isCompAssign) {
Chris Lattner2c8bff72007-12-12 05:47:28 +00001952 // C99 6.5.7p2: Each of the operands shall have integer type.
1953 if (!lex->getType()->isIntegerType() || !rex->getType()->isIntegerType())
1954 return InvalidOperands(loc, lex, rex);
Chris Lattner4b009652007-07-25 00:24:17 +00001955
Chris Lattner2c8bff72007-12-12 05:47:28 +00001956 // Shifts don't perform usual arithmetic conversions, they just do integer
1957 // promotions on each operand. C99 6.5.7p3
Chris Lattnerbb19bc42007-12-13 07:28:16 +00001958 if (!isCompAssign)
1959 UsualUnaryConversions(lex);
Chris Lattner2c8bff72007-12-12 05:47:28 +00001960 UsualUnaryConversions(rex);
1961
1962 // "The type of the result is that of the promoted left operand."
1963 return lex->getType();
Chris Lattner4b009652007-07-25 00:24:17 +00001964}
1965
Eli Friedman0d9549b2008-08-22 00:56:42 +00001966static bool areComparableObjCInterfaces(QualType LHS, QualType RHS,
1967 ASTContext& Context) {
1968 const ObjCInterfaceType* LHSIface = LHS->getAsObjCInterfaceType();
1969 const ObjCInterfaceType* RHSIface = RHS->getAsObjCInterfaceType();
1970 // ID acts sort of like void* for ObjC interfaces
1971 if (LHSIface && Context.isObjCIdType(RHS))
1972 return true;
1973 if (RHSIface && Context.isObjCIdType(LHS))
1974 return true;
1975 if (!LHSIface || !RHSIface)
1976 return false;
1977 return Context.canAssignObjCInterfaces(LHSIface, RHSIface) ||
1978 Context.canAssignObjCInterfaces(RHSIface, LHSIface);
1979}
1980
Chris Lattnerfe1f4032008-04-07 05:30:13 +00001981// C99 6.5.8
1982QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation loc,
1983 bool isRelational) {
Nate Begemanc5f0f652008-07-14 18:02:46 +00001984 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
1985 return CheckVectorCompareOperands(lex, rex, loc, isRelational);
1986
Chris Lattner254f3bc2007-08-26 01:18:55 +00001987 // C99 6.5.8p3 / C99 6.5.9p4
Steve Naroffecc4fa12007-08-10 18:26:40 +00001988 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
1989 UsualArithmeticConversions(lex, rex);
1990 else {
1991 UsualUnaryConversions(lex);
1992 UsualUnaryConversions(rex);
1993 }
Chris Lattner4b009652007-07-25 00:24:17 +00001994 QualType lType = lex->getType();
1995 QualType rType = rex->getType();
1996
Ted Kremenek486509e2007-10-29 17:13:39 +00001997 // For non-floating point types, check for self-comparisons of the form
1998 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
1999 // often indicate logic errors in the program.
Ted Kremenekcf8b77d2007-10-29 16:58:49 +00002000 if (!lType->isFloatingType()) {
Ted Kremenek87e30c52008-01-17 16:57:34 +00002001 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex->IgnoreParens()))
2002 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex->IgnoreParens()))
Ted Kremenekcf8b77d2007-10-29 16:58:49 +00002003 if (DRL->getDecl() == DRR->getDecl())
2004 Diag(loc, diag::warn_selfcomparison);
2005 }
2006
Chris Lattner254f3bc2007-08-26 01:18:55 +00002007 if (isRelational) {
2008 if (lType->isRealType() && rType->isRealType())
2009 return Context.IntTy;
2010 } else {
Ted Kremenek486509e2007-10-29 17:13:39 +00002011 // Check for comparisons of floating point operands using != and ==.
Ted Kremenek486509e2007-10-29 17:13:39 +00002012 if (lType->isFloatingType()) {
2013 assert (rType->isFloatingType());
Ted Kremenek30c66752007-11-25 00:58:00 +00002014 CheckFloatComparison(loc,lex,rex);
Ted Kremenek75439142007-10-29 16:40:01 +00002015 }
2016
Chris Lattner254f3bc2007-08-26 01:18:55 +00002017 if (lType->isArithmeticType() && rType->isArithmeticType())
2018 return Context.IntTy;
2019 }
Chris Lattner4b009652007-07-25 00:24:17 +00002020
Chris Lattner22be8422007-08-26 01:10:14 +00002021 bool LHSIsNull = lex->isNullPointerConstant(Context);
2022 bool RHSIsNull = rex->isNullPointerConstant(Context);
2023
Chris Lattner254f3bc2007-08-26 01:18:55 +00002024 // All of the following pointer related warnings are GCC extensions, except
2025 // when handling null pointer constants. One day, we can consider making them
2026 // errors (when -pedantic-errors is enabled).
Steve Naroffc33c0602007-08-27 04:08:11 +00002027 if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2
Chris Lattner56a5cd62008-04-03 05:07:25 +00002028 QualType LCanPointeeTy =
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00002029 Context.getCanonicalType(lType->getAsPointerType()->getPointeeType());
Chris Lattner56a5cd62008-04-03 05:07:25 +00002030 QualType RCanPointeeTy =
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00002031 Context.getCanonicalType(rType->getAsPointerType()->getPointeeType());
Eli Friedman50727042008-02-08 01:19:44 +00002032
Steve Naroff3b435622007-11-13 14:57:38 +00002033 if (!LHSIsNull && !RHSIsNull && // C99 6.5.9p2
Chris Lattner56a5cd62008-04-03 05:07:25 +00002034 !LCanPointeeTy->isVoidType() && !RCanPointeeTy->isVoidType() &&
2035 !Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
Eli Friedman0d9549b2008-08-22 00:56:42 +00002036 RCanPointeeTy.getUnqualifiedType()) &&
2037 !areComparableObjCInterfaces(LCanPointeeTy, RCanPointeeTy, Context)) {
Steve Naroff4462cb02007-08-16 21:48:38 +00002038 Diag(loc, diag::ext_typecheck_comparison_of_distinct_pointers,
2039 lType.getAsString(), rType.getAsString(),
2040 lex->getSourceRange(), rex->getSourceRange());
Chris Lattner4b009652007-07-25 00:24:17 +00002041 }
Chris Lattnere992d6c2008-01-16 19:17:22 +00002042 ImpCastExprToType(rex, lType); // promote the pointer to pointer
Steve Naroff4462cb02007-08-16 21:48:38 +00002043 return Context.IntTy;
2044 }
Steve Naroff3454b6c2008-09-04 15:10:53 +00002045 // Handle block pointer types.
2046 if (lType->isBlockPointerType() && rType->isBlockPointerType()) {
2047 QualType lpointee = lType->getAsBlockPointerType()->getPointeeType();
2048 QualType rpointee = rType->getAsBlockPointerType()->getPointeeType();
2049
2050 if (!LHSIsNull && !RHSIsNull &&
2051 !Context.typesAreBlockCompatible(lpointee, rpointee)) {
2052 Diag(loc, diag::err_typecheck_comparison_of_distinct_blocks,
2053 lType.getAsString(), rType.getAsString(),
2054 lex->getSourceRange(), rex->getSourceRange());
2055 }
2056 ImpCastExprToType(rex, lType); // promote the pointer to pointer
2057 return Context.IntTy;
2058 }
Steve Narofff85d66c2008-09-28 01:11:11 +00002059 // Allow block pointers to be compared with null pointer constants.
2060 if ((lType->isBlockPointerType() && rType->isPointerType()) ||
2061 (lType->isPointerType() && rType->isBlockPointerType())) {
2062 if (!LHSIsNull && !RHSIsNull) {
2063 Diag(loc, diag::err_typecheck_comparison_of_distinct_blocks,
2064 lType.getAsString(), rType.getAsString(),
2065 lex->getSourceRange(), rex->getSourceRange());
2066 }
2067 ImpCastExprToType(rex, lType); // promote the pointer to pointer
2068 return Context.IntTy;
2069 }
Steve Naroff3454b6c2008-09-04 15:10:53 +00002070
Steve Naroff936c4362008-06-03 14:04:54 +00002071 if ((lType->isObjCQualifiedIdType() || rType->isObjCQualifiedIdType())) {
2072 if (ObjCQualifiedIdTypesAreCompatible(lType, rType, true)) {
2073 ImpCastExprToType(rex, lType);
2074 return Context.IntTy;
2075 }
Fariborz Jahanian5319d9c2007-12-20 01:06:58 +00002076 }
Steve Naroff936c4362008-06-03 14:04:54 +00002077 if ((lType->isPointerType() || lType->isObjCQualifiedIdType()) &&
2078 rType->isIntegerType()) {
Chris Lattner22be8422007-08-26 01:10:14 +00002079 if (!RHSIsNull)
Steve Naroff4462cb02007-08-16 21:48:38 +00002080 Diag(loc, diag::ext_typecheck_comparison_of_pointer_integer,
2081 lType.getAsString(), rType.getAsString(),
2082 lex->getSourceRange(), rex->getSourceRange());
Chris Lattnere992d6c2008-01-16 19:17:22 +00002083 ImpCastExprToType(rex, lType); // promote the integer to pointer
Steve Naroff4462cb02007-08-16 21:48:38 +00002084 return Context.IntTy;
2085 }
Steve Naroff936c4362008-06-03 14:04:54 +00002086 if (lType->isIntegerType() &&
2087 (rType->isPointerType() || rType->isObjCQualifiedIdType())) {
Chris Lattner22be8422007-08-26 01:10:14 +00002088 if (!LHSIsNull)
Steve Naroff4462cb02007-08-16 21:48:38 +00002089 Diag(loc, diag::ext_typecheck_comparison_of_pointer_integer,
2090 lType.getAsString(), rType.getAsString(),
2091 lex->getSourceRange(), rex->getSourceRange());
Chris Lattnere992d6c2008-01-16 19:17:22 +00002092 ImpCastExprToType(lex, rType); // promote the integer to pointer
Steve Naroff4462cb02007-08-16 21:48:38 +00002093 return Context.IntTy;
Chris Lattner4b009652007-07-25 00:24:17 +00002094 }
Steve Naroff4fea7b62008-09-04 16:56:14 +00002095 // Handle block pointers.
2096 if (lType->isBlockPointerType() && rType->isIntegerType()) {
2097 if (!RHSIsNull)
2098 Diag(loc, diag::ext_typecheck_comparison_of_pointer_integer,
2099 lType.getAsString(), rType.getAsString(),
2100 lex->getSourceRange(), rex->getSourceRange());
2101 ImpCastExprToType(rex, lType); // promote the integer to pointer
2102 return Context.IntTy;
2103 }
2104 if (lType->isIntegerType() && rType->isBlockPointerType()) {
2105 if (!LHSIsNull)
2106 Diag(loc, diag::ext_typecheck_comparison_of_pointer_integer,
2107 lType.getAsString(), rType.getAsString(),
2108 lex->getSourceRange(), rex->getSourceRange());
2109 ImpCastExprToType(lex, rType); // promote the integer to pointer
2110 return Context.IntTy;
2111 }
Chris Lattner2c8bff72007-12-12 05:47:28 +00002112 return InvalidOperands(loc, lex, rex);
Chris Lattner4b009652007-07-25 00:24:17 +00002113}
2114
Nate Begemanc5f0f652008-07-14 18:02:46 +00002115/// CheckVectorCompareOperands - vector comparisons are a clang extension that
2116/// operates on extended vector types. Instead of producing an IntTy result,
2117/// like a scalar comparison, a vector comparison produces a vector of integer
2118/// types.
2119QualType Sema::CheckVectorCompareOperands(Expr *&lex, Expr *&rex,
2120 SourceLocation loc,
2121 bool isRelational) {
2122 // Check to make sure we're operating on vectors of the same type and width,
2123 // Allowing one side to be a scalar of element type.
2124 QualType vType = CheckVectorOperands(loc, lex, rex);
2125 if (vType.isNull())
2126 return vType;
2127
2128 QualType lType = lex->getType();
2129 QualType rType = rex->getType();
2130
2131 // For non-floating point types, check for self-comparisons of the form
2132 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
2133 // often indicate logic errors in the program.
2134 if (!lType->isFloatingType()) {
2135 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex->IgnoreParens()))
2136 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex->IgnoreParens()))
2137 if (DRL->getDecl() == DRR->getDecl())
2138 Diag(loc, diag::warn_selfcomparison);
2139 }
2140
2141 // Check for comparisons of floating point operands using != and ==.
2142 if (!isRelational && lType->isFloatingType()) {
2143 assert (rType->isFloatingType());
2144 CheckFloatComparison(loc,lex,rex);
2145 }
2146
2147 // Return the type for the comparison, which is the same as vector type for
2148 // integer vectors, or an integer type of identical size and number of
2149 // elements for floating point vectors.
2150 if (lType->isIntegerType())
2151 return lType;
2152
2153 const VectorType *VTy = lType->getAsVectorType();
2154
2155 // FIXME: need to deal with non-32b int / non-64b long long
2156 unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
2157 if (TypeSize == 32) {
2158 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
2159 }
2160 assert(TypeSize == 64 && "Unhandled vector element size in vector compare");
2161 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
2162}
2163
Chris Lattner4b009652007-07-25 00:24:17 +00002164inline QualType Sema::CheckBitwiseOperands(
Steve Naroff8f708362007-08-24 19:07:16 +00002165 Expr *&lex, Expr *&rex, SourceLocation loc, bool isCompAssign)
Chris Lattner4b009652007-07-25 00:24:17 +00002166{
2167 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
2168 return CheckVectorOperands(loc, lex, rex);
2169
Steve Naroff8f708362007-08-24 19:07:16 +00002170 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
Chris Lattner4b009652007-07-25 00:24:17 +00002171
2172 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
Steve Naroff8f708362007-08-24 19:07:16 +00002173 return compType;
Chris Lattner2c8bff72007-12-12 05:47:28 +00002174 return InvalidOperands(loc, lex, rex);
Chris Lattner4b009652007-07-25 00:24:17 +00002175}
2176
2177inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14]
2178 Expr *&lex, Expr *&rex, SourceLocation loc)
2179{
2180 UsualUnaryConversions(lex);
2181 UsualUnaryConversions(rex);
2182
Eli Friedmanbea3f842008-05-13 20:16:47 +00002183 if (lex->getType()->isScalarType() && rex->getType()->isScalarType())
Chris Lattner4b009652007-07-25 00:24:17 +00002184 return Context.IntTy;
Chris Lattner2c8bff72007-12-12 05:47:28 +00002185 return InvalidOperands(loc, lex, rex);
Chris Lattner4b009652007-07-25 00:24:17 +00002186}
2187
2188inline QualType Sema::CheckAssignmentOperands( // C99 6.5.16.1
Steve Naroff0f32f432007-08-24 22:33:52 +00002189 Expr *lex, Expr *&rex, SourceLocation loc, QualType compoundType)
Chris Lattner4b009652007-07-25 00:24:17 +00002190{
2191 QualType lhsType = lex->getType();
2192 QualType rhsType = compoundType.isNull() ? rex->getType() : compoundType;
Chris Lattner25168a52008-07-26 21:30:36 +00002193 Expr::isModifiableLvalueResult mlval = lex->isModifiableLvalue(Context);
Chris Lattner4b009652007-07-25 00:24:17 +00002194
2195 switch (mlval) { // C99 6.5.16p2
Chris Lattner005ed752008-01-04 18:04:52 +00002196 case Expr::MLV_Valid:
2197 break;
2198 case Expr::MLV_ConstQualified:
2199 Diag(loc, diag::err_typecheck_assign_const, lex->getSourceRange());
2200 return QualType();
2201 case Expr::MLV_ArrayType:
2202 Diag(loc, diag::err_typecheck_array_not_modifiable_lvalue,
2203 lhsType.getAsString(), lex->getSourceRange());
2204 return QualType();
2205 case Expr::MLV_NotObjectType:
2206 Diag(loc, diag::err_typecheck_non_object_not_modifiable_lvalue,
2207 lhsType.getAsString(), lex->getSourceRange());
2208 return QualType();
2209 case Expr::MLV_InvalidExpression:
2210 Diag(loc, diag::err_typecheck_expression_not_modifiable_lvalue,
2211 lex->getSourceRange());
2212 return QualType();
2213 case Expr::MLV_IncompleteType:
2214 case Expr::MLV_IncompleteVoidType:
2215 Diag(loc, diag::err_typecheck_incomplete_type_not_modifiable_lvalue,
2216 lhsType.getAsString(), lex->getSourceRange());
2217 return QualType();
2218 case Expr::MLV_DuplicateVectorComponents:
2219 Diag(loc, diag::err_typecheck_duplicate_vector_components_not_mlvalue,
2220 lex->getSourceRange());
2221 return QualType();
Steve Naroff076d6cb2008-09-26 14:41:28 +00002222 case Expr::MLV_NotBlockQualified:
2223 Diag(loc, diag::err_block_decl_ref_not_modifiable_lvalue,
2224 lex->getSourceRange());
2225 return QualType();
Chris Lattner4b009652007-07-25 00:24:17 +00002226 }
Steve Naroff7cbb1462007-07-31 12:34:36 +00002227
Chris Lattner005ed752008-01-04 18:04:52 +00002228 AssignConvertType ConvTy;
Chris Lattner34c85082008-08-21 18:04:13 +00002229 if (compoundType.isNull()) {
2230 // Simple assignment "x = y".
Chris Lattner005ed752008-01-04 18:04:52 +00002231 ConvTy = CheckSingleAssignmentConstraints(lhsType, rex);
Chris Lattner34c85082008-08-21 18:04:13 +00002232
2233 // If the RHS is a unary plus or minus, check to see if they = and + are
2234 // right next to each other. If so, the user may have typo'd "x =+ 4"
2235 // instead of "x += 4".
2236 Expr *RHSCheck = rex;
2237 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
2238 RHSCheck = ICE->getSubExpr();
2239 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
2240 if ((UO->getOpcode() == UnaryOperator::Plus ||
2241 UO->getOpcode() == UnaryOperator::Minus) &&
2242 loc.isFileID() && UO->getOperatorLoc().isFileID() &&
2243 // Only if the two operators are exactly adjacent.
2244 loc.getFileLocWithOffset(1) == UO->getOperatorLoc())
2245 Diag(loc, diag::warn_not_compound_assign,
2246 UO->getOpcode() == UnaryOperator::Plus ? "+" : "-",
2247 SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()));
2248 }
2249 } else {
2250 // Compound assignment "x += y"
Chris Lattner005ed752008-01-04 18:04:52 +00002251 ConvTy = CheckCompoundAssignmentConstraints(lhsType, rhsType);
Chris Lattner34c85082008-08-21 18:04:13 +00002252 }
Chris Lattner005ed752008-01-04 18:04:52 +00002253
2254 if (DiagnoseAssignmentResult(ConvTy, loc, lhsType, rhsType,
2255 rex, "assigning"))
2256 return QualType();
2257
Chris Lattner4b009652007-07-25 00:24:17 +00002258 // C99 6.5.16p3: The type of an assignment expression is the type of the
2259 // left operand unless the left operand has qualified type, in which case
2260 // it is the unqualified version of the type of the left operand.
2261 // C99 6.5.16.1p2: In simple assignment, the value of the right operand
2262 // is converted to the type of the assignment expression (above).
Chris Lattner0d9bcea2007-08-30 17:45:32 +00002263 // C++ 5.17p1: the type of the assignment expression is that of its left
2264 // oprdu.
Chris Lattner005ed752008-01-04 18:04:52 +00002265 return lhsType.getUnqualifiedType();
Chris Lattner4b009652007-07-25 00:24:17 +00002266}
2267
2268inline QualType Sema::CheckCommaOperands( // C99 6.5.17
2269 Expr *&lex, Expr *&rex, SourceLocation loc) {
Chris Lattner03c430f2008-07-25 20:54:07 +00002270
2271 // Comma performs lvalue conversion (C99 6.3.2.1), but not unary conversions.
2272 DefaultFunctionArrayConversion(rex);
Chris Lattner4b009652007-07-25 00:24:17 +00002273 return rex->getType();
2274}
2275
2276/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
2277/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
2278QualType Sema::CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc) {
2279 QualType resType = op->getType();
2280 assert(!resType.isNull() && "no type for increment/decrement expression");
2281
Steve Naroffd30e1932007-08-24 17:20:07 +00002282 // C99 6.5.2.4p1: We allow complex as a GCC extension.
Steve Naroffce827582007-11-11 14:15:57 +00002283 if (const PointerType *pt = resType->getAsPointerType()) {
Eli Friedmand9b1fec2008-05-18 18:08:51 +00002284 if (pt->getPointeeType()->isVoidType()) {
2285 Diag(OpLoc, diag::ext_gnu_void_ptr, op->getSourceRange());
2286 } else if (!pt->getPointeeType()->isObjectType()) {
2287 // C99 6.5.2.4p2, 6.5.6p2
Chris Lattner4b009652007-07-25 00:24:17 +00002288 Diag(OpLoc, diag::err_typecheck_arithmetic_incomplete_type,
2289 resType.getAsString(), op->getSourceRange());
2290 return QualType();
2291 }
Steve Naroffd30e1932007-08-24 17:20:07 +00002292 } else if (!resType->isRealType()) {
2293 if (resType->isComplexType())
2294 // C99 does not support ++/-- on complex types.
2295 Diag(OpLoc, diag::ext_integer_increment_complex,
2296 resType.getAsString(), op->getSourceRange());
2297 else {
2298 Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement,
2299 resType.getAsString(), op->getSourceRange());
2300 return QualType();
2301 }
Chris Lattner4b009652007-07-25 00:24:17 +00002302 }
Steve Naroff6acc0f42007-08-23 21:37:33 +00002303 // At this point, we know we have a real, complex or pointer type.
2304 // Now make sure the operand is a modifiable lvalue.
Chris Lattner25168a52008-07-26 21:30:36 +00002305 Expr::isModifiableLvalueResult mlval = op->isModifiableLvalue(Context);
Chris Lattner4b009652007-07-25 00:24:17 +00002306 if (mlval != Expr::MLV_Valid) {
2307 // FIXME: emit a more precise diagnostic...
2308 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_incr_decr,
2309 op->getSourceRange());
2310 return QualType();
2311 }
2312 return resType;
2313}
2314
Anders Carlsson4b3db2b2008-02-01 07:15:58 +00002315/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
Chris Lattner4b009652007-07-25 00:24:17 +00002316/// This routine allows us to typecheck complex/recursive expressions
Daniel Dunbarb45f75c2008-08-04 20:02:37 +00002317/// where the declaration is needed for type checking. We only need to
2318/// handle cases when the expression references a function designator
2319/// or is an lvalue. Here are some examples:
2320/// - &(x) => x
2321/// - &*****f => f for f a function designator.
2322/// - &s.xx => s
2323/// - &s.zz[1].yy -> s, if zz is an array
2324/// - *(x + 1) -> x, if x is an array
2325/// - &"123"[2] -> 0
2326/// - & __real__ x -> x
Chris Lattner48d7f382008-04-02 04:24:33 +00002327static ValueDecl *getPrimaryDecl(Expr *E) {
2328 switch (E->getStmtClass()) {
Chris Lattner4b009652007-07-25 00:24:17 +00002329 case Stmt::DeclRefExprClass:
Chris Lattner48d7f382008-04-02 04:24:33 +00002330 return cast<DeclRefExpr>(E)->getDecl();
Chris Lattner4b009652007-07-25 00:24:17 +00002331 case Stmt::MemberExprClass:
Chris Lattnera3249072007-11-16 17:46:48 +00002332 // Fields cannot be declared with a 'register' storage class.
2333 // &X->f is always ok, even if X is declared register.
Chris Lattner48d7f382008-04-02 04:24:33 +00002334 if (cast<MemberExpr>(E)->isArrow())
Chris Lattnera3249072007-11-16 17:46:48 +00002335 return 0;
Chris Lattner48d7f382008-04-02 04:24:33 +00002336 return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
Anders Carlsson4b3db2b2008-02-01 07:15:58 +00002337 case Stmt::ArraySubscriptExprClass: {
Daniel Dunbarb45f75c2008-08-04 20:02:37 +00002338 // &X[4] and &4[X] refers to X if X is not a pointer.
Anders Carlsson4b3db2b2008-02-01 07:15:58 +00002339
Chris Lattner48d7f382008-04-02 04:24:33 +00002340 ValueDecl *VD = getPrimaryDecl(cast<ArraySubscriptExpr>(E)->getBase());
Anders Carlsson655694e2008-02-01 16:01:31 +00002341 if (!VD || VD->getType()->isPointerType())
Anders Carlsson4b3db2b2008-02-01 07:15:58 +00002342 return 0;
2343 else
2344 return VD;
2345 }
Daniel Dunbarb45f75c2008-08-04 20:02:37 +00002346 case Stmt::UnaryOperatorClass: {
2347 UnaryOperator *UO = cast<UnaryOperator>(E);
2348
2349 switch(UO->getOpcode()) {
2350 case UnaryOperator::Deref: {
2351 // *(X + 1) refers to X if X is not a pointer.
2352 ValueDecl *VD = getPrimaryDecl(UO->getSubExpr());
2353 if (!VD || VD->getType()->isPointerType())
2354 return 0;
2355 return VD;
2356 }
2357 case UnaryOperator::Real:
2358 case UnaryOperator::Imag:
2359 case UnaryOperator::Extension:
2360 return getPrimaryDecl(UO->getSubExpr());
2361 default:
2362 return 0;
2363 }
2364 }
2365 case Stmt::BinaryOperatorClass: {
2366 BinaryOperator *BO = cast<BinaryOperator>(E);
2367
2368 // Handle cases involving pointer arithmetic. The result of an
2369 // Assign or AddAssign is not an lvalue so they can be ignored.
2370
2371 // (x + n) or (n + x) => x
2372 if (BO->getOpcode() == BinaryOperator::Add) {
2373 if (BO->getLHS()->getType()->isPointerType()) {
2374 return getPrimaryDecl(BO->getLHS());
2375 } else if (BO->getRHS()->getType()->isPointerType()) {
2376 return getPrimaryDecl(BO->getRHS());
2377 }
2378 }
2379
2380 return 0;
2381 }
Chris Lattner4b009652007-07-25 00:24:17 +00002382 case Stmt::ParenExprClass:
Chris Lattner48d7f382008-04-02 04:24:33 +00002383 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
Chris Lattnera3249072007-11-16 17:46:48 +00002384 case Stmt::ImplicitCastExprClass:
2385 // &X[4] when X is an array, has an implicit cast from array to pointer.
Chris Lattner48d7f382008-04-02 04:24:33 +00002386 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
Chris Lattner4b009652007-07-25 00:24:17 +00002387 default:
2388 return 0;
2389 }
2390}
2391
2392/// CheckAddressOfOperand - The operand of & must be either a function
2393/// designator or an lvalue designating an object. If it is an lvalue, the
2394/// object cannot be declared with storage class register or be a bit field.
2395/// Note: The usual conversions are *not* applied to the operand of the &
2396/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
2397QualType Sema::CheckAddressOfOperand(Expr *op, SourceLocation OpLoc) {
Steve Naroff9c6c3592008-01-13 17:10:08 +00002398 if (getLangOptions().C99) {
2399 // Implement C99-only parts of addressof rules.
2400 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
2401 if (uOp->getOpcode() == UnaryOperator::Deref)
2402 // Per C99 6.5.3.2, the address of a deref always returns a valid result
2403 // (assuming the deref expression is valid).
2404 return uOp->getSubExpr()->getType();
2405 }
2406 // Technically, there should be a check for array subscript
2407 // expressions here, but the result of one is always an lvalue anyway.
2408 }
Anders Carlsson4b3db2b2008-02-01 07:15:58 +00002409 ValueDecl *dcl = getPrimaryDecl(op);
Chris Lattner25168a52008-07-26 21:30:36 +00002410 Expr::isLvalueResult lval = op->isLvalue(Context);
Chris Lattner4b009652007-07-25 00:24:17 +00002411
2412 if (lval != Expr::LV_Valid) { // C99 6.5.3.2p1
Chris Lattnera3249072007-11-16 17:46:48 +00002413 if (!dcl || !isa<FunctionDecl>(dcl)) {// allow function designators
2414 // FIXME: emit more specific diag...
Chris Lattner4b009652007-07-25 00:24:17 +00002415 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof,
2416 op->getSourceRange());
2417 return QualType();
2418 }
Steve Naroff73cf87e2008-02-29 23:30:25 +00002419 } else if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(op)) { // C99 6.5.3.2p1
2420 if (MemExpr->getMemberDecl()->isBitField()) {
2421 Diag(OpLoc, diag::err_typecheck_address_of,
2422 std::string("bit-field"), op->getSourceRange());
2423 return QualType();
2424 }
2425 // Check for Apple extension for accessing vector components.
2426 } else if (isa<ArraySubscriptExpr>(op) &&
2427 cast<ArraySubscriptExpr>(op)->getBase()->getType()->isVectorType()) {
2428 Diag(OpLoc, diag::err_typecheck_address_of,
2429 std::string("vector"), op->getSourceRange());
2430 return QualType();
2431 } else if (dcl) { // C99 6.5.3.2p1
Chris Lattner4b009652007-07-25 00:24:17 +00002432 // We have an lvalue with a decl. Make sure the decl is not declared
2433 // with the register storage-class specifier.
2434 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
2435 if (vd->getStorageClass() == VarDecl::Register) {
Steve Naroff73cf87e2008-02-29 23:30:25 +00002436 Diag(OpLoc, diag::err_typecheck_address_of,
2437 std::string("register variable"), op->getSourceRange());
Chris Lattner4b009652007-07-25 00:24:17 +00002438 return QualType();
2439 }
2440 } else
2441 assert(0 && "Unknown/unexpected decl type");
Chris Lattner4b009652007-07-25 00:24:17 +00002442 }
Chris Lattnera55e3212008-07-27 00:48:22 +00002443
Chris Lattner4b009652007-07-25 00:24:17 +00002444 // If the operand has type "type", the result has type "pointer to type".
2445 return Context.getPointerType(op->getType());
2446}
2447
2448QualType Sema::CheckIndirectionOperand(Expr *op, SourceLocation OpLoc) {
2449 UsualUnaryConversions(op);
2450 QualType qType = op->getType();
2451
Chris Lattner7931f4a2007-07-31 16:53:04 +00002452 if (const PointerType *PT = qType->getAsPointerType()) {
Steve Naroff9c6c3592008-01-13 17:10:08 +00002453 // Note that per both C89 and C99, this is always legal, even
2454 // if ptype is an incomplete type or void.
2455 // It would be possible to warn about dereferencing a
2456 // void pointer, but it's completely well-defined,
2457 // and such a warning is unlikely to catch any mistakes.
2458 return PT->getPointeeType();
Chris Lattner4b009652007-07-25 00:24:17 +00002459 }
2460 Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer,
2461 qType.getAsString(), op->getSourceRange());
2462 return QualType();
2463}
2464
2465static inline BinaryOperator::Opcode ConvertTokenKindToBinaryOpcode(
2466 tok::TokenKind Kind) {
2467 BinaryOperator::Opcode Opc;
2468 switch (Kind) {
2469 default: assert(0 && "Unknown binop!");
2470 case tok::star: Opc = BinaryOperator::Mul; break;
2471 case tok::slash: Opc = BinaryOperator::Div; break;
2472 case tok::percent: Opc = BinaryOperator::Rem; break;
2473 case tok::plus: Opc = BinaryOperator::Add; break;
2474 case tok::minus: Opc = BinaryOperator::Sub; break;
2475 case tok::lessless: Opc = BinaryOperator::Shl; break;
2476 case tok::greatergreater: Opc = BinaryOperator::Shr; break;
2477 case tok::lessequal: Opc = BinaryOperator::LE; break;
2478 case tok::less: Opc = BinaryOperator::LT; break;
2479 case tok::greaterequal: Opc = BinaryOperator::GE; break;
2480 case tok::greater: Opc = BinaryOperator::GT; break;
2481 case tok::exclaimequal: Opc = BinaryOperator::NE; break;
2482 case tok::equalequal: Opc = BinaryOperator::EQ; break;
2483 case tok::amp: Opc = BinaryOperator::And; break;
2484 case tok::caret: Opc = BinaryOperator::Xor; break;
2485 case tok::pipe: Opc = BinaryOperator::Or; break;
2486 case tok::ampamp: Opc = BinaryOperator::LAnd; break;
2487 case tok::pipepipe: Opc = BinaryOperator::LOr; break;
2488 case tok::equal: Opc = BinaryOperator::Assign; break;
2489 case tok::starequal: Opc = BinaryOperator::MulAssign; break;
2490 case tok::slashequal: Opc = BinaryOperator::DivAssign; break;
2491 case tok::percentequal: Opc = BinaryOperator::RemAssign; break;
2492 case tok::plusequal: Opc = BinaryOperator::AddAssign; break;
2493 case tok::minusequal: Opc = BinaryOperator::SubAssign; break;
2494 case tok::lesslessequal: Opc = BinaryOperator::ShlAssign; break;
2495 case tok::greatergreaterequal: Opc = BinaryOperator::ShrAssign; break;
2496 case tok::ampequal: Opc = BinaryOperator::AndAssign; break;
2497 case tok::caretequal: Opc = BinaryOperator::XorAssign; break;
2498 case tok::pipeequal: Opc = BinaryOperator::OrAssign; break;
2499 case tok::comma: Opc = BinaryOperator::Comma; break;
2500 }
2501 return Opc;
2502}
2503
2504static inline UnaryOperator::Opcode ConvertTokenKindToUnaryOpcode(
2505 tok::TokenKind Kind) {
2506 UnaryOperator::Opcode Opc;
2507 switch (Kind) {
2508 default: assert(0 && "Unknown unary op!");
2509 case tok::plusplus: Opc = UnaryOperator::PreInc; break;
2510 case tok::minusminus: Opc = UnaryOperator::PreDec; break;
2511 case tok::amp: Opc = UnaryOperator::AddrOf; break;
2512 case tok::star: Opc = UnaryOperator::Deref; break;
2513 case tok::plus: Opc = UnaryOperator::Plus; break;
2514 case tok::minus: Opc = UnaryOperator::Minus; break;
2515 case tok::tilde: Opc = UnaryOperator::Not; break;
2516 case tok::exclaim: Opc = UnaryOperator::LNot; break;
2517 case tok::kw_sizeof: Opc = UnaryOperator::SizeOf; break;
2518 case tok::kw___alignof: Opc = UnaryOperator::AlignOf; break;
2519 case tok::kw___real: Opc = UnaryOperator::Real; break;
2520 case tok::kw___imag: Opc = UnaryOperator::Imag; break;
2521 case tok::kw___extension__: Opc = UnaryOperator::Extension; break;
2522 }
2523 return Opc;
2524}
2525
2526// Binary Operators. 'Tok' is the token for the operator.
Steve Naroff87d58b42007-09-16 03:34:24 +00002527Action::ExprResult Sema::ActOnBinOp(SourceLocation TokLoc, tok::TokenKind Kind,
Chris Lattner4b009652007-07-25 00:24:17 +00002528 ExprTy *LHS, ExprTy *RHS) {
2529 BinaryOperator::Opcode Opc = ConvertTokenKindToBinaryOpcode(Kind);
2530 Expr *lhs = (Expr *)LHS, *rhs = (Expr*)RHS;
2531
Steve Naroff87d58b42007-09-16 03:34:24 +00002532 assert((lhs != 0) && "ActOnBinOp(): missing left expression");
2533 assert((rhs != 0) && "ActOnBinOp(): missing right expression");
Chris Lattner4b009652007-07-25 00:24:17 +00002534
2535 QualType ResultTy; // Result type of the binary operator.
2536 QualType CompTy; // Computation type for compound assignments (e.g. '+=')
2537
2538 switch (Opc) {
2539 default:
2540 assert(0 && "Unknown binary expr!");
2541 case BinaryOperator::Assign:
2542 ResultTy = CheckAssignmentOperands(lhs, rhs, TokLoc, QualType());
2543 break;
2544 case BinaryOperator::Mul:
2545 case BinaryOperator::Div:
2546 ResultTy = CheckMultiplyDivideOperands(lhs, rhs, TokLoc);
2547 break;
2548 case BinaryOperator::Rem:
2549 ResultTy = CheckRemainderOperands(lhs, rhs, TokLoc);
2550 break;
2551 case BinaryOperator::Add:
2552 ResultTy = CheckAdditionOperands(lhs, rhs, TokLoc);
2553 break;
2554 case BinaryOperator::Sub:
2555 ResultTy = CheckSubtractionOperands(lhs, rhs, TokLoc);
2556 break;
2557 case BinaryOperator::Shl:
2558 case BinaryOperator::Shr:
2559 ResultTy = CheckShiftOperands(lhs, rhs, TokLoc);
2560 break;
2561 case BinaryOperator::LE:
2562 case BinaryOperator::LT:
2563 case BinaryOperator::GE:
2564 case BinaryOperator::GT:
Chris Lattner254f3bc2007-08-26 01:18:55 +00002565 ResultTy = CheckCompareOperands(lhs, rhs, TokLoc, true);
Chris Lattner4b009652007-07-25 00:24:17 +00002566 break;
2567 case BinaryOperator::EQ:
2568 case BinaryOperator::NE:
Chris Lattner254f3bc2007-08-26 01:18:55 +00002569 ResultTy = CheckCompareOperands(lhs, rhs, TokLoc, false);
Chris Lattner4b009652007-07-25 00:24:17 +00002570 break;
2571 case BinaryOperator::And:
2572 case BinaryOperator::Xor:
2573 case BinaryOperator::Or:
2574 ResultTy = CheckBitwiseOperands(lhs, rhs, TokLoc);
2575 break;
2576 case BinaryOperator::LAnd:
2577 case BinaryOperator::LOr:
2578 ResultTy = CheckLogicalOperands(lhs, rhs, TokLoc);
2579 break;
2580 case BinaryOperator::MulAssign:
2581 case BinaryOperator::DivAssign:
Steve Naroff8f708362007-08-24 19:07:16 +00002582 CompTy = CheckMultiplyDivideOperands(lhs, rhs, TokLoc, true);
Chris Lattner4b009652007-07-25 00:24:17 +00002583 if (!CompTy.isNull())
2584 ResultTy = CheckAssignmentOperands(lhs, rhs, TokLoc, CompTy);
2585 break;
2586 case BinaryOperator::RemAssign:
Steve Naroff8f708362007-08-24 19:07:16 +00002587 CompTy = CheckRemainderOperands(lhs, rhs, TokLoc, true);
Chris Lattner4b009652007-07-25 00:24:17 +00002588 if (!CompTy.isNull())
2589 ResultTy = CheckAssignmentOperands(lhs, rhs, TokLoc, CompTy);
2590 break;
2591 case BinaryOperator::AddAssign:
Steve Naroff8f708362007-08-24 19:07:16 +00002592 CompTy = CheckAdditionOperands(lhs, rhs, TokLoc, true);
Chris Lattner4b009652007-07-25 00:24:17 +00002593 if (!CompTy.isNull())
2594 ResultTy = CheckAssignmentOperands(lhs, rhs, TokLoc, CompTy);
2595 break;
2596 case BinaryOperator::SubAssign:
Steve Naroff8f708362007-08-24 19:07:16 +00002597 CompTy = CheckSubtractionOperands(lhs, rhs, TokLoc, true);
Chris Lattner4b009652007-07-25 00:24:17 +00002598 if (!CompTy.isNull())
2599 ResultTy = CheckAssignmentOperands(lhs, rhs, TokLoc, CompTy);
2600 break;
2601 case BinaryOperator::ShlAssign:
2602 case BinaryOperator::ShrAssign:
Steve Naroff8f708362007-08-24 19:07:16 +00002603 CompTy = CheckShiftOperands(lhs, rhs, TokLoc, true);
Chris Lattner4b009652007-07-25 00:24:17 +00002604 if (!CompTy.isNull())
2605 ResultTy = CheckAssignmentOperands(lhs, rhs, TokLoc, CompTy);
2606 break;
2607 case BinaryOperator::AndAssign:
2608 case BinaryOperator::XorAssign:
2609 case BinaryOperator::OrAssign:
Steve Naroff8f708362007-08-24 19:07:16 +00002610 CompTy = CheckBitwiseOperands(lhs, rhs, TokLoc, true);
Chris Lattner4b009652007-07-25 00:24:17 +00002611 if (!CompTy.isNull())
2612 ResultTy = CheckAssignmentOperands(lhs, rhs, TokLoc, CompTy);
2613 break;
2614 case BinaryOperator::Comma:
2615 ResultTy = CheckCommaOperands(lhs, rhs, TokLoc);
2616 break;
2617 }
2618 if (ResultTy.isNull())
2619 return true;
2620 if (CompTy.isNull())
Chris Lattnerf420df12007-08-28 18:36:55 +00002621 return new BinaryOperator(lhs, rhs, Opc, ResultTy, TokLoc);
Chris Lattner4b009652007-07-25 00:24:17 +00002622 else
Chris Lattnerf420df12007-08-28 18:36:55 +00002623 return new CompoundAssignOperator(lhs, rhs, Opc, ResultTy, CompTy, TokLoc);
Chris Lattner4b009652007-07-25 00:24:17 +00002624}
2625
2626// Unary Operators. 'Tok' is the token for the operator.
Steve Naroff87d58b42007-09-16 03:34:24 +00002627Action::ExprResult Sema::ActOnUnaryOp(SourceLocation OpLoc, tok::TokenKind Op,
Chris Lattner4b009652007-07-25 00:24:17 +00002628 ExprTy *input) {
2629 Expr *Input = (Expr*)input;
2630 UnaryOperator::Opcode Opc = ConvertTokenKindToUnaryOpcode(Op);
2631 QualType resultType;
2632 switch (Opc) {
2633 default:
2634 assert(0 && "Unimplemented unary expr!");
2635 case UnaryOperator::PreInc:
2636 case UnaryOperator::PreDec:
2637 resultType = CheckIncrementDecrementOperand(Input, OpLoc);
2638 break;
2639 case UnaryOperator::AddrOf:
2640 resultType = CheckAddressOfOperand(Input, OpLoc);
2641 break;
2642 case UnaryOperator::Deref:
Steve Naroffccc26a72007-12-18 04:06:57 +00002643 DefaultFunctionArrayConversion(Input);
Chris Lattner4b009652007-07-25 00:24:17 +00002644 resultType = CheckIndirectionOperand(Input, OpLoc);
2645 break;
2646 case UnaryOperator::Plus:
2647 case UnaryOperator::Minus:
2648 UsualUnaryConversions(Input);
2649 resultType = Input->getType();
2650 if (!resultType->isArithmeticType()) // C99 6.5.3.3p1
2651 return Diag(OpLoc, diag::err_typecheck_unary_expr,
2652 resultType.getAsString());
2653 break;
2654 case UnaryOperator::Not: // bitwise complement
2655 UsualUnaryConversions(Input);
2656 resultType = Input->getType();
Chris Lattnerbd695022008-07-25 23:52:49 +00002657 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
2658 if (resultType->isComplexType() || resultType->isComplexIntegerType())
2659 // C99 does not support '~' for complex conjugation.
2660 Diag(OpLoc, diag::ext_integer_complement_complex,
2661 resultType.getAsString(), Input->getSourceRange());
2662 else if (!resultType->isIntegerType())
2663 return Diag(OpLoc, diag::err_typecheck_unary_expr,
2664 resultType.getAsString(), Input->getSourceRange());
Chris Lattner4b009652007-07-25 00:24:17 +00002665 break;
2666 case UnaryOperator::LNot: // logical negation
2667 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
2668 DefaultFunctionArrayConversion(Input);
2669 resultType = Input->getType();
2670 if (!resultType->isScalarType()) // C99 6.5.3.3p1
2671 return Diag(OpLoc, diag::err_typecheck_unary_expr,
2672 resultType.getAsString());
2673 // LNot always has type int. C99 6.5.3.3p5.
2674 resultType = Context.IntTy;
2675 break;
2676 case UnaryOperator::SizeOf:
Chris Lattnerf814d882008-07-25 21:45:37 +00002677 resultType = CheckSizeOfAlignOfOperand(Input->getType(), OpLoc,
2678 Input->getSourceRange(), true);
Chris Lattner4b009652007-07-25 00:24:17 +00002679 break;
2680 case UnaryOperator::AlignOf:
Chris Lattnerf814d882008-07-25 21:45:37 +00002681 resultType = CheckSizeOfAlignOfOperand(Input->getType(), OpLoc,
2682 Input->getSourceRange(), false);
Chris Lattner4b009652007-07-25 00:24:17 +00002683 break;
Chris Lattner03931a72007-08-24 21:16:53 +00002684 case UnaryOperator::Real:
Chris Lattner03931a72007-08-24 21:16:53 +00002685 case UnaryOperator::Imag:
Chris Lattner5110ad52007-08-24 21:41:10 +00002686 resultType = CheckRealImagOperand(Input, OpLoc);
Chris Lattner03931a72007-08-24 21:16:53 +00002687 break;
Chris Lattner4b009652007-07-25 00:24:17 +00002688 case UnaryOperator::Extension:
Chris Lattner4b009652007-07-25 00:24:17 +00002689 resultType = Input->getType();
2690 break;
2691 }
2692 if (resultType.isNull())
2693 return true;
2694 return new UnaryOperator(Input, Opc, resultType, OpLoc);
2695}
2696
Steve Naroff5cbb02f2007-09-16 14:56:35 +00002697/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
2698Sema::ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc,
Chris Lattner4b009652007-07-25 00:24:17 +00002699 SourceLocation LabLoc,
2700 IdentifierInfo *LabelII) {
2701 // Look up the record for this label identifier.
2702 LabelStmt *&LabelDecl = LabelMap[LabelII];
2703
Daniel Dunbar879788d2008-08-04 16:51:22 +00002704 // If we haven't seen this label yet, create a forward reference. It
2705 // will be validated and/or cleaned up in ActOnFinishFunctionBody.
Chris Lattner4b009652007-07-25 00:24:17 +00002706 if (LabelDecl == 0)
2707 LabelDecl = new LabelStmt(LabLoc, LabelII, 0);
2708
2709 // Create the AST node. The address of a label always has type 'void*'.
Chris Lattnera0d03a72007-08-03 17:31:20 +00002710 return new AddrLabelExpr(OpLoc, LabLoc, LabelDecl,
2711 Context.getPointerType(Context.VoidTy));
Chris Lattner4b009652007-07-25 00:24:17 +00002712}
2713
Steve Naroff5cbb02f2007-09-16 14:56:35 +00002714Sema::ExprResult Sema::ActOnStmtExpr(SourceLocation LPLoc, StmtTy *substmt,
Chris Lattner4b009652007-07-25 00:24:17 +00002715 SourceLocation RPLoc) { // "({..})"
2716 Stmt *SubStmt = static_cast<Stmt*>(substmt);
2717 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
2718 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
2719
2720 // FIXME: there are a variety of strange constraints to enforce here, for
2721 // example, it is not possible to goto into a stmt expression apparently.
2722 // More semantic analysis is needed.
2723
2724 // FIXME: the last statement in the compount stmt has its value used. We
2725 // should not warn about it being unused.
2726
2727 // If there are sub stmts in the compound stmt, take the type of the last one
2728 // as the type of the stmtexpr.
2729 QualType Ty = Context.VoidTy;
2730
Chris Lattner200964f2008-07-26 19:51:01 +00002731 if (!Compound->body_empty()) {
2732 Stmt *LastStmt = Compound->body_back();
2733 // If LastStmt is a label, skip down through into the body.
2734 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt))
2735 LastStmt = Label->getSubStmt();
2736
2737 if (Expr *LastExpr = dyn_cast<Expr>(LastStmt))
Chris Lattner4b009652007-07-25 00:24:17 +00002738 Ty = LastExpr->getType();
Chris Lattner200964f2008-07-26 19:51:01 +00002739 }
Chris Lattner4b009652007-07-25 00:24:17 +00002740
2741 return new StmtExpr(Compound, Ty, LPLoc, RPLoc);
2742}
Steve Naroff63bad2d2007-08-01 22:05:33 +00002743
Steve Naroff5cbb02f2007-09-16 14:56:35 +00002744Sema::ExprResult Sema::ActOnBuiltinOffsetOf(SourceLocation BuiltinLoc,
Chris Lattner0d9bcea2007-08-30 17:45:32 +00002745 SourceLocation TypeLoc,
2746 TypeTy *argty,
2747 OffsetOfComponent *CompPtr,
2748 unsigned NumComponents,
2749 SourceLocation RPLoc) {
2750 QualType ArgTy = QualType::getFromOpaquePtr(argty);
2751 assert(!ArgTy.isNull() && "Missing type argument!");
2752
2753 // We must have at least one component that refers to the type, and the first
2754 // one is known to be a field designator. Verify that the ArgTy represents
2755 // a struct/union/class.
2756 if (!ArgTy->isRecordType())
2757 return Diag(TypeLoc, diag::err_offsetof_record_type,ArgTy.getAsString());
2758
2759 // Otherwise, create a compound literal expression as the base, and
2760 // iteratively process the offsetof designators.
Steve Naroffbe37fc02008-01-14 18:19:28 +00002761 Expr *Res = new CompoundLiteralExpr(SourceLocation(), ArgTy, 0, false);
Chris Lattner0d9bcea2007-08-30 17:45:32 +00002762
Chris Lattnerb37522e2007-08-31 21:49:13 +00002763 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a
2764 // GCC extension, diagnose them.
2765 if (NumComponents != 1)
2766 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator,
2767 SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd));
2768
Chris Lattner0d9bcea2007-08-30 17:45:32 +00002769 for (unsigned i = 0; i != NumComponents; ++i) {
2770 const OffsetOfComponent &OC = CompPtr[i];
2771 if (OC.isBrackets) {
2772 // Offset of an array sub-field. TODO: Should we allow vector elements?
Chris Lattnera1923f62008-08-04 07:31:14 +00002773 const ArrayType *AT = Context.getAsArrayType(Res->getType());
Chris Lattner0d9bcea2007-08-30 17:45:32 +00002774 if (!AT) {
2775 delete Res;
2776 return Diag(OC.LocEnd, diag::err_offsetof_array_type,
2777 Res->getType().getAsString());
2778 }
2779
Chris Lattner2af6a802007-08-30 17:59:59 +00002780 // FIXME: C++: Verify that operator[] isn't overloaded.
2781
Chris Lattner0d9bcea2007-08-30 17:45:32 +00002782 // C99 6.5.2.1p1
2783 Expr *Idx = static_cast<Expr*>(OC.U.E);
2784 if (!Idx->getType()->isIntegerType())
2785 return Diag(Idx->getLocStart(), diag::err_typecheck_subscript,
2786 Idx->getSourceRange());
2787
2788 Res = new ArraySubscriptExpr(Res, Idx, AT->getElementType(), OC.LocEnd);
2789 continue;
2790 }
2791
2792 const RecordType *RC = Res->getType()->getAsRecordType();
2793 if (!RC) {
2794 delete Res;
2795 return Diag(OC.LocEnd, diag::err_offsetof_record_type,
2796 Res->getType().getAsString());
2797 }
2798
2799 // Get the decl corresponding to this.
2800 RecordDecl *RD = RC->getDecl();
2801 FieldDecl *MemberDecl = RD->getMember(OC.U.IdentInfo);
2802 if (!MemberDecl)
2803 return Diag(BuiltinLoc, diag::err_typecheck_no_member,
2804 OC.U.IdentInfo->getName(),
2805 SourceRange(OC.LocStart, OC.LocEnd));
Chris Lattner2af6a802007-08-30 17:59:59 +00002806
2807 // FIXME: C++: Verify that MemberDecl isn't a static field.
2808 // FIXME: Verify that MemberDecl isn't a bitfield.
Eli Friedman76b49832008-02-06 22:48:16 +00002809 // MemberDecl->getType() doesn't get the right qualifiers, but it doesn't
2810 // matter here.
2811 Res = new MemberExpr(Res, false, MemberDecl, OC.LocEnd, MemberDecl->getType());
Chris Lattner0d9bcea2007-08-30 17:45:32 +00002812 }
2813
2814 return new UnaryOperator(Res, UnaryOperator::OffsetOf, Context.getSizeType(),
2815 BuiltinLoc);
2816}
2817
2818
Steve Naroff5cbb02f2007-09-16 14:56:35 +00002819Sema::ExprResult Sema::ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
Steve Naroff63bad2d2007-08-01 22:05:33 +00002820 TypeTy *arg1, TypeTy *arg2,
2821 SourceLocation RPLoc) {
2822 QualType argT1 = QualType::getFromOpaquePtr(arg1);
2823 QualType argT2 = QualType::getFromOpaquePtr(arg2);
2824
2825 assert((!argT1.isNull() && !argT2.isNull()) && "Missing type argument(s)");
2826
Chris Lattner0d9bcea2007-08-30 17:45:32 +00002827 return new TypesCompatibleExpr(Context.IntTy, BuiltinLoc, argT1, argT2,RPLoc);
Steve Naroff63bad2d2007-08-01 22:05:33 +00002828}
2829
Steve Naroff5cbb02f2007-09-16 14:56:35 +00002830Sema::ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, ExprTy *cond,
Steve Naroff93c53012007-08-03 21:21:27 +00002831 ExprTy *expr1, ExprTy *expr2,
2832 SourceLocation RPLoc) {
2833 Expr *CondExpr = static_cast<Expr*>(cond);
2834 Expr *LHSExpr = static_cast<Expr*>(expr1);
2835 Expr *RHSExpr = static_cast<Expr*>(expr2);
2836
2837 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
2838
2839 // The conditional expression is required to be a constant expression.
2840 llvm::APSInt condEval(32);
2841 SourceLocation ExpLoc;
2842 if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc))
2843 return Diag(ExpLoc, diag::err_typecheck_choose_expr_requires_constant,
2844 CondExpr->getSourceRange());
2845
2846 // If the condition is > zero, then the AST type is the same as the LSHExpr.
2847 QualType resType = condEval.getZExtValue() ? LHSExpr->getType() :
2848 RHSExpr->getType();
2849 return new ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, resType, RPLoc);
2850}
2851
Steve Naroff52a81c02008-09-03 18:15:37 +00002852//===----------------------------------------------------------------------===//
2853// Clang Extensions.
2854//===----------------------------------------------------------------------===//
2855
2856/// ActOnBlockStart - This callback is invoked when a block literal is started.
2857void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope,
2858 Declarator &ParamInfo) {
2859 // Analyze block parameters.
2860 BlockSemaInfo *BSI = new BlockSemaInfo();
2861
2862 // Add BSI to CurBlock.
2863 BSI->PrevBlockInfo = CurBlock;
2864 CurBlock = BSI;
2865
2866 BSI->ReturnType = 0;
2867 BSI->TheScope = BlockScope;
2868
2869 // Analyze arguments to block.
2870 assert(ParamInfo.getTypeObject(0).Kind == DeclaratorChunk::Function &&
2871 "Not a function declarator!");
2872 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getTypeObject(0).Fun;
2873
2874 BSI->hasPrototype = FTI.hasPrototype;
2875 BSI->isVariadic = true;
2876
2877 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs function that takes
2878 // no arguments, not a function that takes a single void argument.
2879 if (FTI.hasPrototype &&
2880 FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2881 (!((ParmVarDecl *)FTI.ArgInfo[0].Param)->getType().getCVRQualifiers() &&
2882 ((ParmVarDecl *)FTI.ArgInfo[0].Param)->getType()->isVoidType())) {
2883 // empty arg list, don't push any params.
2884 BSI->isVariadic = false;
2885 } else if (FTI.hasPrototype) {
2886 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i)
2887 BSI->Params.push_back((ParmVarDecl *)FTI.ArgInfo[i].Param);
2888 BSI->isVariadic = FTI.isVariadic;
2889 }
2890}
2891
2892/// ActOnBlockError - If there is an error parsing a block, this callback
2893/// is invoked to pop the information about the block from the action impl.
2894void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
2895 // Ensure that CurBlock is deleted.
2896 llvm::OwningPtr<BlockSemaInfo> CC(CurBlock);
2897
2898 // Pop off CurBlock, handle nested blocks.
2899 CurBlock = CurBlock->PrevBlockInfo;
2900
2901 // FIXME: Delete the ParmVarDecl objects as well???
2902
2903}
2904
2905/// ActOnBlockStmtExpr - This is called when the body of a block statement
2906/// literal was successfully completed. ^(int x){...}
2907Sema::ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, StmtTy *body,
2908 Scope *CurScope) {
2909 // Ensure that CurBlock is deleted.
2910 llvm::OwningPtr<BlockSemaInfo> BSI(CurBlock);
2911 llvm::OwningPtr<CompoundStmt> Body(static_cast<CompoundStmt*>(body));
2912
2913 // Pop off CurBlock, handle nested blocks.
2914 CurBlock = CurBlock->PrevBlockInfo;
2915
2916 QualType RetTy = Context.VoidTy;
2917 if (BSI->ReturnType)
2918 RetTy = QualType(BSI->ReturnType, 0);
2919
2920 llvm::SmallVector<QualType, 8> ArgTypes;
2921 for (unsigned i = 0, e = BSI->Params.size(); i != e; ++i)
2922 ArgTypes.push_back(BSI->Params[i]->getType());
2923
2924 QualType BlockTy;
2925 if (!BSI->hasPrototype)
2926 BlockTy = Context.getFunctionTypeNoProto(RetTy);
2927 else
2928 BlockTy = Context.getFunctionType(RetTy, &ArgTypes[0], ArgTypes.size(),
2929 BSI->isVariadic);
2930
2931 BlockTy = Context.getBlockPointerType(BlockTy);
Steve Naroffb31e2b32008-09-17 18:37:59 +00002932 return new BlockExpr(CaretLoc, BlockTy, &BSI->Params[0], BSI->Params.size(),
2933 Body.take());
Steve Naroff52a81c02008-09-03 18:15:37 +00002934}
2935
Nate Begemanbd881ef2008-01-30 20:50:20 +00002936/// ExprsMatchFnType - return true if the Exprs in array Args have
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002937/// QualTypes that match the QualTypes of the arguments of the FnType.
Nate Begemanbd881ef2008-01-30 20:50:20 +00002938/// The number of arguments has already been validated to match the number of
2939/// arguments in FnType.
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00002940static bool ExprsMatchFnType(Expr **Args, const FunctionTypeProto *FnType,
2941 ASTContext &Context) {
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002942 unsigned NumParams = FnType->getNumArgs();
Nate Begeman778fd3b2008-04-18 23:35:14 +00002943 for (unsigned i = 0; i != NumParams; ++i) {
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00002944 QualType ExprTy = Context.getCanonicalType(Args[i]->getType());
2945 QualType ParmTy = Context.getCanonicalType(FnType->getArgType(i));
Nate Begeman778fd3b2008-04-18 23:35:14 +00002946
2947 if (ExprTy.getUnqualifiedType() != ParmTy.getUnqualifiedType())
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002948 return false;
Nate Begeman778fd3b2008-04-18 23:35:14 +00002949 }
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002950 return true;
2951}
2952
2953Sema::ExprResult Sema::ActOnOverloadExpr(ExprTy **args, unsigned NumArgs,
2954 SourceLocation *CommaLocs,
2955 SourceLocation BuiltinLoc,
2956 SourceLocation RParenLoc) {
Nate Begemanc6078c92008-01-31 05:38:29 +00002957 // __builtin_overload requires at least 2 arguments
2958 if (NumArgs < 2)
2959 return Diag(RParenLoc, diag::err_typecheck_call_too_few_args,
2960 SourceRange(BuiltinLoc, RParenLoc));
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002961
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002962 // The first argument is required to be a constant expression. It tells us
2963 // the number of arguments to pass to each of the functions to be overloaded.
Nate Begemanc6078c92008-01-31 05:38:29 +00002964 Expr **Args = reinterpret_cast<Expr**>(args);
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002965 Expr *NParamsExpr = Args[0];
2966 llvm::APSInt constEval(32);
2967 SourceLocation ExpLoc;
2968 if (!NParamsExpr->isIntegerConstantExpr(constEval, Context, &ExpLoc))
2969 return Diag(ExpLoc, diag::err_overload_expr_requires_non_zero_constant,
2970 NParamsExpr->getSourceRange());
2971
2972 // Verify that the number of parameters is > 0
2973 unsigned NumParams = constEval.getZExtValue();
2974 if (NumParams == 0)
2975 return Diag(ExpLoc, diag::err_overload_expr_requires_non_zero_constant,
2976 NParamsExpr->getSourceRange());
2977 // Verify that we have at least 1 + NumParams arguments to the builtin.
2978 if ((NumParams + 1) > NumArgs)
2979 return Diag(RParenLoc, diag::err_typecheck_call_too_few_args,
2980 SourceRange(BuiltinLoc, RParenLoc));
2981
2982 // Figure out the return type, by matching the args to one of the functions
Nate Begemanbd881ef2008-01-30 20:50:20 +00002983 // listed after the parameters.
Nate Begemanc6078c92008-01-31 05:38:29 +00002984 OverloadExpr *OE = 0;
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002985 for (unsigned i = NumParams + 1; i < NumArgs; ++i) {
2986 // UsualUnaryConversions will convert the function DeclRefExpr into a
2987 // pointer to function.
2988 Expr *Fn = UsualUnaryConversions(Args[i]);
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00002989 const FunctionTypeProto *FnType = 0;
2990 if (const PointerType *PT = Fn->getType()->getAsPointerType())
2991 FnType = PT->getPointeeType()->getAsFunctionTypeProto();
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002992
2993 // The Expr type must be FunctionTypeProto, since FunctionTypeProto has no
2994 // parameters, and the number of parameters must match the value passed to
2995 // the builtin.
2996 if (!FnType || (FnType->getNumArgs() != NumParams))
Nate Begemanbd881ef2008-01-30 20:50:20 +00002997 return Diag(Fn->getExprLoc(), diag::err_overload_incorrect_fntype,
2998 Fn->getSourceRange());
Nate Begeman9f3bfb72008-01-17 17:46:27 +00002999
3000 // Scan the parameter list for the FunctionType, checking the QualType of
Nate Begemanbd881ef2008-01-30 20:50:20 +00003001 // each parameter against the QualTypes of the arguments to the builtin.
Nate Begeman9f3bfb72008-01-17 17:46:27 +00003002 // If they match, return a new OverloadExpr.
Chris Lattnerd5a56aa2008-07-26 22:17:49 +00003003 if (ExprsMatchFnType(Args+1, FnType, Context)) {
Nate Begemanc6078c92008-01-31 05:38:29 +00003004 if (OE)
3005 return Diag(Fn->getExprLoc(), diag::err_overload_multiple_match,
3006 OE->getFn()->getSourceRange());
3007 // Remember our match, and continue processing the remaining arguments
3008 // to catch any errors.
3009 OE = new OverloadExpr(Args, NumArgs, i, FnType->getResultType(),
3010 BuiltinLoc, RParenLoc);
3011 }
Nate Begeman9f3bfb72008-01-17 17:46:27 +00003012 }
Nate Begemanc6078c92008-01-31 05:38:29 +00003013 // Return the newly created OverloadExpr node, if we succeded in matching
3014 // exactly one of the candidate functions.
3015 if (OE)
3016 return OE;
Nate Begeman9f3bfb72008-01-17 17:46:27 +00003017
3018 // If we didn't find a matching function Expr in the __builtin_overload list
3019 // the return an error.
3020 std::string typeNames;
Nate Begemanbd881ef2008-01-30 20:50:20 +00003021 for (unsigned i = 0; i != NumParams; ++i) {
3022 if (i != 0) typeNames += ", ";
3023 typeNames += Args[i+1]->getType().getAsString();
3024 }
Nate Begeman9f3bfb72008-01-17 17:46:27 +00003025
3026 return Diag(BuiltinLoc, diag::err_overload_no_match, typeNames,
3027 SourceRange(BuiltinLoc, RParenLoc));
3028}
3029
Anders Carlsson36760332007-10-15 20:28:48 +00003030Sema::ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc,
3031 ExprTy *expr, TypeTy *type,
Chris Lattner005ed752008-01-04 18:04:52 +00003032 SourceLocation RPLoc) {
Anders Carlsson36760332007-10-15 20:28:48 +00003033 Expr *E = static_cast<Expr*>(expr);
3034 QualType T = QualType::getFromOpaquePtr(type);
3035
3036 InitBuiltinVaListType();
Eli Friedmandd2b9af2008-08-09 23:32:40 +00003037
3038 // Get the va_list type
3039 QualType VaListType = Context.getBuiltinVaListType();
3040 // Deal with implicit array decay; for example, on x86-64,
3041 // va_list is an array, but it's supposed to decay to
3042 // a pointer for va_arg.
3043 if (VaListType->isArrayType())
3044 VaListType = Context.getArrayDecayedType(VaListType);
Eli Friedman8754e5b2008-08-20 22:17:17 +00003045 // Make sure the input expression also decays appropriately.
3046 UsualUnaryConversions(E);
Eli Friedmandd2b9af2008-08-09 23:32:40 +00003047
3048 if (CheckAssignmentConstraints(VaListType, E->getType()) != Compatible)
Anders Carlsson36760332007-10-15 20:28:48 +00003049 return Diag(E->getLocStart(),
3050 diag::err_first_argument_to_va_arg_not_of_type_va_list,
3051 E->getType().getAsString(),
3052 E->getSourceRange());
3053
3054 // FIXME: Warn if a non-POD type is passed in.
3055
3056 return new VAArgExpr(BuiltinLoc, E, T, RPLoc);
3057}
3058
Chris Lattner005ed752008-01-04 18:04:52 +00003059bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
3060 SourceLocation Loc,
3061 QualType DstType, QualType SrcType,
3062 Expr *SrcExpr, const char *Flavor) {
3063 // Decode the result (notice that AST's are still created for extensions).
3064 bool isInvalid = false;
3065 unsigned DiagKind;
3066 switch (ConvTy) {
3067 default: assert(0 && "Unknown conversion type");
3068 case Compatible: return false;
Chris Lattnerd951b7b2008-01-04 18:22:42 +00003069 case PointerToInt:
Chris Lattner005ed752008-01-04 18:04:52 +00003070 DiagKind = diag::ext_typecheck_convert_pointer_int;
3071 break;
Chris Lattnerd951b7b2008-01-04 18:22:42 +00003072 case IntToPointer:
3073 DiagKind = diag::ext_typecheck_convert_int_pointer;
3074 break;
Chris Lattner005ed752008-01-04 18:04:52 +00003075 case IncompatiblePointer:
3076 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
3077 break;
3078 case FunctionVoidPointer:
3079 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
3080 break;
3081 case CompatiblePointerDiscardsQualifiers:
Douglas Gregor1815b3b2008-09-12 00:47:35 +00003082 // If the qualifiers lost were because we were applying the
3083 // (deprecated) C++ conversion from a string literal to a char*
3084 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME:
3085 // Ideally, this check would be performed in
3086 // CheckPointerTypesForAssignment. However, that would require a
3087 // bit of refactoring (so that the second argument is an
3088 // expression, rather than a type), which should be done as part
3089 // of a larger effort to fix CheckPointerTypesForAssignment for
3090 // C++ semantics.
3091 if (getLangOptions().CPlusPlus &&
3092 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
3093 return false;
Chris Lattner005ed752008-01-04 18:04:52 +00003094 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
3095 break;
Steve Naroff3454b6c2008-09-04 15:10:53 +00003096 case IntToBlockPointer:
3097 DiagKind = diag::err_int_to_block_pointer;
3098 break;
3099 case IncompatibleBlockPointer:
Steve Naroff82324d62008-09-24 23:31:10 +00003100 DiagKind = diag::ext_typecheck_convert_incompatible_block_pointer;
Steve Naroff3454b6c2008-09-04 15:10:53 +00003101 break;
3102 case BlockVoidPointer:
3103 DiagKind = diag::ext_typecheck_convert_pointer_void_block;
3104 break;
Chris Lattner005ed752008-01-04 18:04:52 +00003105 case Incompatible:
3106 DiagKind = diag::err_typecheck_convert_incompatible;
3107 isInvalid = true;
3108 break;
3109 }
3110
3111 Diag(Loc, DiagKind, DstType.getAsString(), SrcType.getAsString(), Flavor,
3112 SrcExpr->getSourceRange());
3113 return isInvalid;
3114}