1//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for expressions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/DeclObjC.h"
17#include "clang/AST/ExprCXX.h"
18#include "clang/AST/ExprObjC.h"
19#include "clang/AST/DeclTemplate.h"
20#include "clang/Lex/Preprocessor.h"
21#include "clang/Lex/LiteralSupport.h"
22#include "clang/Basic/SourceManager.h"
23#include "clang/Basic/TargetInfo.h"
24#include "clang/Parse/DeclSpec.h"
25#include "clang/Parse/Designator.h"
26#include "clang/Parse/Scope.h"
27using namespace clang;
28
29/// \brief Determine whether the use of this declaration is valid, and
30/// emit any corresponding diagnostics.
31///
32/// This routine diagnoses various problems with referencing
33/// declarations that can occur when using a declaration. For example,
34/// it might warn if a deprecated or unavailable declaration is being
35/// used, or produce an error (and return true) if a C++0x deleted
36/// function is being used.
37///
38/// \returns true if there was an error (this declaration cannot be
39/// referenced), false otherwise.
40bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc) {
41 // See if the decl is deprecated.
| 1//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for expressions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/DeclObjC.h"
17#include "clang/AST/ExprCXX.h"
18#include "clang/AST/ExprObjC.h"
19#include "clang/AST/DeclTemplate.h"
20#include "clang/Lex/Preprocessor.h"
21#include "clang/Lex/LiteralSupport.h"
22#include "clang/Basic/SourceManager.h"
23#include "clang/Basic/TargetInfo.h"
24#include "clang/Parse/DeclSpec.h"
25#include "clang/Parse/Designator.h"
26#include "clang/Parse/Scope.h"
27using namespace clang;
28
29/// \brief Determine whether the use of this declaration is valid, and
30/// emit any corresponding diagnostics.
31///
32/// This routine diagnoses various problems with referencing
33/// declarations that can occur when using a declaration. For example,
34/// it might warn if a deprecated or unavailable declaration is being
35/// used, or produce an error (and return true) if a C++0x deleted
36/// function is being used.
37///
38/// \returns true if there was an error (this declaration cannot be
39/// referenced), false otherwise.
40bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc) {
41 // See if the decl is deprecated.
|
42 if (D->getAttr<DeprecatedAttr>(Context)) {
| 42 if (D->getAttr()) {
|
43 // Implementing deprecated stuff requires referencing deprecated
44 // stuff. Don't warn if we are implementing a deprecated
45 // construct.
46 bool isSilenced = false;
47
48 if (NamedDecl *ND = getCurFunctionOrMethodDecl()) {
49 // If this reference happens *in* a deprecated function or method, don't
50 // warn.
| 43 // Implementing deprecated stuff requires referencing deprecated
44 // stuff. Don't warn if we are implementing a deprecated
45 // construct.
46 bool isSilenced = false;
47
48 if (NamedDecl *ND = getCurFunctionOrMethodDecl()) {
49 // If this reference happens *in* a deprecated function or method, don't
50 // warn.
|
51 isSilenced = ND->getAttr<DeprecatedAttr>(Context);
| 51 isSilenced = ND->getAttr();
|
52
53 // If this is an Objective-C method implementation, check to see if the
54 // method was deprecated on the declaration, not the definition.
55 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND)) {
56 // The semantic decl context of a ObjCMethodDecl is the
57 // ObjCImplementationDecl.
58 if (ObjCImplementationDecl *Impl
59 = dyn_cast<ObjCImplementationDecl>(MD->getParent())) {
60
| 52
53 // If this is an Objective-C method implementation, check to see if the
54 // method was deprecated on the declaration, not the definition.
55 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND)) {
56 // The semantic decl context of a ObjCMethodDecl is the
57 // ObjCImplementationDecl.
58 if (ObjCImplementationDecl *Impl
59 = dyn_cast<ObjCImplementationDecl>(MD->getParent())) {
60
|
61 MD = Impl->getClassInterface()->getMethod(Context,
62 MD->getSelector(),
| 61 MD = Impl->getClassInterface()->getMethod(MD->getSelector(),
|
63 MD->isInstanceMethod());
| 62 MD->isInstanceMethod());
|
64 isSilenced |= MD && MD->getAttr<DeprecatedAttr>(Context);
| 63 isSilenced |= MD && MD->getAttr();
|
65 }
66 }
67 }
68
69 if (!isSilenced)
70 Diag(Loc, diag::warn_deprecated) << D->getDeclName();
71 }
72
73 // See if this is a deleted function.
74 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
75 if (FD->isDeleted()) {
76 Diag(Loc, diag::err_deleted_function_use);
77 Diag(D->getLocation(), diag::note_unavailable_here) << true;
78 return true;
79 }
80 }
81
82 // See if the decl is unavailable
| 64 }
65 }
66 }
67
68 if (!isSilenced)
69 Diag(Loc, diag::warn_deprecated) << D->getDeclName();
70 }
71
72 // See if this is a deleted function.
73 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
74 if (FD->isDeleted()) {
75 Diag(Loc, diag::err_deleted_function_use);
76 Diag(D->getLocation(), diag::note_unavailable_here) << true;
77 return true;
78 }
79 }
80
81 // See if the decl is unavailable
|
83 if (D->getAttr<UnavailableAttr>(Context)) {
| 82 if (D->getAttr()) {
|
84 Diag(Loc, diag::warn_unavailable) << D->getDeclName();
85 Diag(D->getLocation(), diag::note_unavailable_here) << 0;
86 }
87
88 return false;
89}
90
91/// DiagnoseSentinelCalls - This routine checks on method dispatch calls
92/// (and other functions in future), which have been declared with sentinel
93/// attribute. It warns if call does not have the sentinel argument.
94///
95void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
96 Expr **Args, unsigned NumArgs)
97{
| 83 Diag(Loc, diag::warn_unavailable) << D->getDeclName();
84 Diag(D->getLocation(), diag::note_unavailable_here) << 0;
85 }
86
87 return false;
88}
89
90/// DiagnoseSentinelCalls - This routine checks on method dispatch calls
91/// (and other functions in future), which have been declared with sentinel
92/// attribute. It warns if call does not have the sentinel argument.
93///
94void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
95 Expr **Args, unsigned NumArgs)
96{
|
98 const SentinelAttr *attr = D->getAttr<SentinelAttr>(Context);
| 97 const SentinelAttr *attr = D->getAttr();
|
99 if (!attr)
100 return;
101 int sentinelPos = attr->getSentinel();
102 int nullPos = attr->getNullPos();
103
104 // FIXME. ObjCMethodDecl and FunctionDecl need be derived from the same common
105 // base class. Then we won't be needing two versions of the same code.
106 unsigned int i = 0;
107 bool warnNotEnoughArgs = false;
108 int isMethod = 0;
109 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
110 // skip over named parameters.
111 ObjCMethodDecl::param_iterator P, E = MD->param_end();
112 for (P = MD->param_begin(); (P != E && i < NumArgs); ++P) {
113 if (nullPos)
114 --nullPos;
115 else
116 ++i;
117 }
118 warnNotEnoughArgs = (P != E || i >= NumArgs);
119 isMethod = 1;
120 }
121 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
122 // skip over named parameters.
123 ObjCMethodDecl::param_iterator P, E = FD->param_end();
124 for (P = FD->param_begin(); (P != E && i < NumArgs); ++P) {
125 if (nullPos)
126 --nullPos;
127 else
128 ++i;
129 }
130 warnNotEnoughArgs = (P != E || i >= NumArgs);
131 }
132 else if (VarDecl *V = dyn_cast<VarDecl>(D)) {
133 // block or function pointer call.
134 QualType Ty = V->getType();
135 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
136 const FunctionType *FT = Ty->isFunctionPointerType()
137 ? Ty->getAsPointerType()->getPointeeType()->getAsFunctionType()
138 : Ty->getAsBlockPointerType()->getPointeeType()->getAsFunctionType();
139 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) {
140 unsigned NumArgsInProto = Proto->getNumArgs();
141 unsigned k;
142 for (k = 0; (k != NumArgsInProto && i < NumArgs); k++) {
143 if (nullPos)
144 --nullPos;
145 else
146 ++i;
147 }
148 warnNotEnoughArgs = (k != NumArgsInProto || i >= NumArgs);
149 }
150 if (Ty->isBlockPointerType())
151 isMethod = 2;
152 }
153 else
154 return;
155 }
156 else
157 return;
158
159 if (warnNotEnoughArgs) {
160 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
161 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
162 return;
163 }
164 int sentinel = i;
165 while (sentinelPos > 0 && i < NumArgs-1) {
166 --sentinelPos;
167 ++i;
168 }
169 if (sentinelPos > 0) {
170 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
171 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
172 return;
173 }
174 while (i < NumArgs-1) {
175 ++i;
176 ++sentinel;
177 }
178 Expr *sentinelExpr = Args[sentinel];
179 if (sentinelExpr && (!sentinelExpr->getType()->isPointerType() ||
180 !sentinelExpr->isNullPointerConstant(Context))) {
181 Diag(Loc, diag::warn_missing_sentinel) << isMethod;
182 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
183 }
184 return;
185}
186
187SourceRange Sema::getExprRange(ExprTy *E) const {
188 Expr *Ex = (Expr *)E;
189 return Ex? Ex->getSourceRange() : SourceRange();
190}
191
192//===----------------------------------------------------------------------===//
193// Standard Promotions and Conversions
194//===----------------------------------------------------------------------===//
195
196/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
197void Sema::DefaultFunctionArrayConversion(Expr *&E) {
198 QualType Ty = E->getType();
199 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
200
201 if (Ty->isFunctionType())
202 ImpCastExprToType(E, Context.getPointerType(Ty));
203 else if (Ty->isArrayType()) {
204 // In C90 mode, arrays only promote to pointers if the array expression is
205 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
206 // type 'array of type' is converted to an expression that has type 'pointer
207 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
208 // that has type 'array of type' ...". The relevant change is "an lvalue"
209 // (C90) to "an expression" (C99).
210 //
211 // C++ 4.2p1:
212 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
213 // T" can be converted to an rvalue of type "pointer to T".
214 //
215 if (getLangOptions().C99 || getLangOptions().CPlusPlus ||
216 E->isLvalue(Context) == Expr::LV_Valid)
217 ImpCastExprToType(E, Context.getArrayDecayedType(Ty));
218 }
219}
220
221/// \brief Whether this is a promotable bitfield reference according
222/// to C99 6.3.1.1p2, bullet 2.
223///
224/// \returns the type this bit-field will promote to, or NULL if no
225/// promotion occurs.
226static QualType isPromotableBitField(Expr *E, ASTContext &Context) {
227 FieldDecl *Field = E->getBitField();
228 if (!Field)
229 return QualType();
230
231 const BuiltinType *BT = Field->getType()->getAsBuiltinType();
232 if (!BT)
233 return QualType();
234
235 if (BT->getKind() != BuiltinType::Bool &&
236 BT->getKind() != BuiltinType::Int &&
237 BT->getKind() != BuiltinType::UInt)
238 return QualType();
239
240 llvm::APSInt BitWidthAP;
241 if (!Field->getBitWidth()->isIntegerConstantExpr(BitWidthAP, Context))
242 return QualType();
243
244 uint64_t BitWidth = BitWidthAP.getZExtValue();
245 uint64_t IntSize = Context.getTypeSize(Context.IntTy);
246 if (BitWidth < IntSize ||
247 (Field->getType()->isSignedIntegerType() && BitWidth == IntSize))
248 return Context.IntTy;
249
250 if (BitWidth == IntSize && Field->getType()->isUnsignedIntegerType())
251 return Context.UnsignedIntTy;
252
253 return QualType();
254}
255
256/// UsualUnaryConversions - Performs various conversions that are common to most
257/// operators (C99 6.3). The conversions of array and function types are
258/// sometimes surpressed. For example, the array->pointer conversion doesn't
259/// apply if the array is an argument to the sizeof or address (&) operators.
260/// In these instances, this routine should *not* be called.
261Expr *Sema::UsualUnaryConversions(Expr *&Expr) {
262 QualType Ty = Expr->getType();
263 assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
264
265 // C99 6.3.1.1p2:
266 //
267 // The following may be used in an expression wherever an int or
268 // unsigned int may be used:
269 // - an object or expression with an integer type whose integer
270 // conversion rank is less than or equal to the rank of int
271 // and unsigned int.
272 // - A bit-field of type _Bool, int, signed int, or unsigned int.
273 //
274 // If an int can represent all values of the original type, the
275 // value is converted to an int; otherwise, it is converted to an
276 // unsigned int. These are called the integer promotions. All
277 // other types are unchanged by the integer promotions.
278 if (Ty->isPromotableIntegerType()) {
279 ImpCastExprToType(Expr, Context.IntTy);
280 return Expr;
281 } else {
282 QualType T = isPromotableBitField(Expr, Context);
283 if (!T.isNull()) {
284 ImpCastExprToType(Expr, T);
285 return Expr;
286 }
287 }
288
289 DefaultFunctionArrayConversion(Expr);
290 return Expr;
291}
292
293/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
294/// do not have a prototype. Arguments that have type float are promoted to
295/// double. All other argument types are converted by UsualUnaryConversions().
296void Sema::DefaultArgumentPromotion(Expr *&Expr) {
297 QualType Ty = Expr->getType();
298 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
299
300 // If this is a 'float' (CVR qualified or typedef) promote to double.
301 if (const BuiltinType *BT = Ty->getAsBuiltinType())
302 if (BT->getKind() == BuiltinType::Float)
303 return ImpCastExprToType(Expr, Context.DoubleTy);
304
305 UsualUnaryConversions(Expr);
306}
307
308/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
309/// will warn if the resulting type is not a POD type, and rejects ObjC
310/// interfaces passed by value. This returns true if the argument type is
311/// completely illegal.
312bool Sema::DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT) {
313 DefaultArgumentPromotion(Expr);
314
315 if (Expr->getType()->isObjCInterfaceType()) {
316 Diag(Expr->getLocStart(),
317 diag::err_cannot_pass_objc_interface_to_vararg)
318 << Expr->getType() << CT;
319 return true;
320 }
321
322 if (!Expr->getType()->isPODType())
323 Diag(Expr->getLocStart(), diag::warn_cannot_pass_non_pod_arg_to_vararg)
324 << Expr->getType() << CT;
325
326 return false;
327}
328
329
330/// UsualArithmeticConversions - Performs various conversions that are common to
331/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
332/// routine returns the first non-arithmetic type found. The client is
333/// responsible for emitting appropriate error diagnostics.
334/// FIXME: verify the conversion rules for "complex int" are consistent with
335/// GCC.
336QualType Sema::UsualArithmeticConversions(Expr *&lhsExpr, Expr *&rhsExpr,
337 bool isCompAssign) {
338 if (!isCompAssign)
339 UsualUnaryConversions(lhsExpr);
340
341 UsualUnaryConversions(rhsExpr);
342
343 // For conversion purposes, we ignore any qualifiers.
344 // For example, "const float" and "float" are equivalent.
345 QualType lhs =
346 Context.getCanonicalType(lhsExpr->getType()).getUnqualifiedType();
347 QualType rhs =
348 Context.getCanonicalType(rhsExpr->getType()).getUnqualifiedType();
349
350 // If both types are identical, no conversion is needed.
351 if (lhs == rhs)
352 return lhs;
353
354 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
355 // The caller can deal with this (e.g. pointer + int).
356 if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
357 return lhs;
358
359 // Perform bitfield promotions.
360 QualType LHSBitfieldPromoteTy = isPromotableBitField(lhsExpr, Context);
361 if (!LHSBitfieldPromoteTy.isNull())
362 lhs = LHSBitfieldPromoteTy;
363 QualType RHSBitfieldPromoteTy = isPromotableBitField(rhsExpr, Context);
364 if (!RHSBitfieldPromoteTy.isNull())
365 rhs = RHSBitfieldPromoteTy;
366
367 QualType destType = UsualArithmeticConversionsType(lhs, rhs);
368 if (!isCompAssign)
369 ImpCastExprToType(lhsExpr, destType);
370 ImpCastExprToType(rhsExpr, destType);
371 return destType;
372}
373
374QualType Sema::UsualArithmeticConversionsType(QualType lhs, QualType rhs) {
375 // Perform the usual unary conversions. We do this early so that
376 // integral promotions to "int" can allow us to exit early, in the
377 // lhs == rhs check. Also, for conversion purposes, we ignore any
378 // qualifiers. For example, "const float" and "float" are
379 // equivalent.
380 if (lhs->isPromotableIntegerType())
381 lhs = Context.IntTy;
382 else
383 lhs = lhs.getUnqualifiedType();
384 if (rhs->isPromotableIntegerType())
385 rhs = Context.IntTy;
386 else
387 rhs = rhs.getUnqualifiedType();
388
389 // If both types are identical, no conversion is needed.
390 if (lhs == rhs)
391 return lhs;
392
393 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
394 // The caller can deal with this (e.g. pointer + int).
395 if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
396 return lhs;
397
398 // At this point, we have two different arithmetic types.
399
400 // Handle complex types first (C99 6.3.1.8p1).
401 if (lhs->isComplexType() || rhs->isComplexType()) {
402 // if we have an integer operand, the result is the complex type.
403 if (rhs->isIntegerType() || rhs->isComplexIntegerType()) {
404 // convert the rhs to the lhs complex type.
405 return lhs;
406 }
407 if (lhs->isIntegerType() || lhs->isComplexIntegerType()) {
408 // convert the lhs to the rhs complex type.
409 return rhs;
410 }
411 // This handles complex/complex, complex/float, or float/complex.
412 // When both operands are complex, the shorter operand is converted to the
413 // type of the longer, and that is the type of the result. This corresponds
414 // to what is done when combining two real floating-point operands.
415 // The fun begins when size promotion occur across type domains.
416 // From H&S 6.3.4: When one operand is complex and the other is a real
417 // floating-point type, the less precise type is converted, within it's
418 // real or complex domain, to the precision of the other type. For example,
419 // when combining a "long double" with a "double _Complex", the
420 // "double _Complex" is promoted to "long double _Complex".
421 int result = Context.getFloatingTypeOrder(lhs, rhs);
422
423 if (result > 0) { // The left side is bigger, convert rhs.
424 rhs = Context.getFloatingTypeOfSizeWithinDomain(lhs, rhs);
425 } else if (result < 0) { // The right side is bigger, convert lhs.
426 lhs = Context.getFloatingTypeOfSizeWithinDomain(rhs, lhs);
427 }
428 // At this point, lhs and rhs have the same rank/size. Now, make sure the
429 // domains match. This is a requirement for our implementation, C99
430 // does not require this promotion.
431 if (lhs != rhs) { // Domains don't match, we have complex/float mix.
432 if (lhs->isRealFloatingType()) { // handle "double, _Complex double".
433 return rhs;
434 } else { // handle "_Complex double, double".
435 return lhs;
436 }
437 }
438 return lhs; // The domain/size match exactly.
439 }
440 // Now handle "real" floating types (i.e. float, double, long double).
441 if (lhs->isRealFloatingType() || rhs->isRealFloatingType()) {
442 // if we have an integer operand, the result is the real floating type.
443 if (rhs->isIntegerType()) {
444 // convert rhs to the lhs floating point type.
445 return lhs;
446 }
447 if (rhs->isComplexIntegerType()) {
448 // convert rhs to the complex floating point type.
449 return Context.getComplexType(lhs);
450 }
451 if (lhs->isIntegerType()) {
452 // convert lhs to the rhs floating point type.
453 return rhs;
454 }
455 if (lhs->isComplexIntegerType()) {
456 // convert lhs to the complex floating point type.
457 return Context.getComplexType(rhs);
458 }
459 // We have two real floating types, float/complex combos were handled above.
460 // Convert the smaller operand to the bigger result.
461 int result = Context.getFloatingTypeOrder(lhs, rhs);
462 if (result > 0) // convert the rhs
463 return lhs;
464 assert(result < 0 && "illegal float comparison");
465 return rhs; // convert the lhs
466 }
467 if (lhs->isComplexIntegerType() || rhs->isComplexIntegerType()) {
468 // Handle GCC complex int extension.
469 const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType();
470 const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType();
471
472 if (lhsComplexInt && rhsComplexInt) {
473 if (Context.getIntegerTypeOrder(lhsComplexInt->getElementType(),
474 rhsComplexInt->getElementType()) >= 0)
475 return lhs; // convert the rhs
476 return rhs;
477 } else if (lhsComplexInt && rhs->isIntegerType()) {
478 // convert the rhs to the lhs complex type.
479 return lhs;
480 } else if (rhsComplexInt && lhs->isIntegerType()) {
481 // convert the lhs to the rhs complex type.
482 return rhs;
483 }
484 }
485 // Finally, we have two differing integer types.
486 // The rules for this case are in C99 6.3.1.8
487 int compare = Context.getIntegerTypeOrder(lhs, rhs);
488 bool lhsSigned = lhs->isSignedIntegerType(),
489 rhsSigned = rhs->isSignedIntegerType();
490 QualType destType;
491 if (lhsSigned == rhsSigned) {
492 // Same signedness; use the higher-ranked type
493 destType = compare >= 0 ? lhs : rhs;
494 } else if (compare != (lhsSigned ? 1 : -1)) {
495 // The unsigned type has greater than or equal rank to the
496 // signed type, so use the unsigned type
497 destType = lhsSigned ? rhs : lhs;
498 } else if (Context.getIntWidth(lhs) != Context.getIntWidth(rhs)) {
499 // The two types are different widths; if we are here, that
500 // means the signed type is larger than the unsigned type, so
501 // use the signed type.
502 destType = lhsSigned ? lhs : rhs;
503 } else {
504 // The signed type is higher-ranked than the unsigned type,
505 // but isn't actually any bigger (like unsigned int and long
506 // on most 32-bit systems). Use the unsigned type corresponding
507 // to the signed type.
508 destType = Context.getCorrespondingUnsignedType(lhsSigned ? lhs : rhs);
509 }
510 return destType;
511}
512
513//===----------------------------------------------------------------------===//
514// Semantic Analysis for various Expression Types
515//===----------------------------------------------------------------------===//
516
517
518/// ActOnStringLiteral - The specified tokens were lexed as pasted string
519/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
520/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
521/// multiple tokens. However, the common case is that StringToks points to one
522/// string.
523///
524Action::OwningExprResult
525Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) {
526 assert(NumStringToks && "Must have at least one string!");
527
528 StringLiteralParser Literal(StringToks, NumStringToks, PP);
529 if (Literal.hadError)
530 return ExprError();
531
532 llvm::SmallVector<SourceLocation, 4> StringTokLocs;
533 for (unsigned i = 0; i != NumStringToks; ++i)
534 StringTokLocs.push_back(StringToks[i].getLocation());
535
536 QualType StrTy = Context.CharTy;
537 if (Literal.AnyWide) StrTy = Context.getWCharType();
538 if (Literal.Pascal) StrTy = Context.UnsignedCharTy;
539
540 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
541 if (getLangOptions().CPlusPlus)
542 StrTy.addConst();
543
544 // Get an array type for the string, according to C99 6.4.5. This includes
545 // the nul terminator character as well as the string length for pascal
546 // strings.
547 StrTy = Context.getConstantArrayType(StrTy,
548 llvm::APInt(32, Literal.GetNumStringChars()+1),
549 ArrayType::Normal, 0);
550
551 // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
552 return Owned(StringLiteral::Create(Context, Literal.GetString(),
553 Literal.GetStringLength(),
554 Literal.AnyWide, StrTy,
555 &StringTokLocs[0],
556 StringTokLocs.size()));
557}
558
559/// ShouldSnapshotBlockValueReference - Return true if a reference inside of
560/// CurBlock to VD should cause it to be snapshotted (as we do for auto
561/// variables defined outside the block) or false if this is not needed (e.g.
562/// for values inside the block or for globals).
563///
564/// This also keeps the 'hasBlockDeclRefExprs' in the BlockSemaInfo records
565/// up-to-date.
566///
567static bool ShouldSnapshotBlockValueReference(BlockSemaInfo *CurBlock,
568 ValueDecl *VD) {
569 // If the value is defined inside the block, we couldn't snapshot it even if
570 // we wanted to.
571 if (CurBlock->TheDecl == VD->getDeclContext())
572 return false;
573
574 // If this is an enum constant or function, it is constant, don't snapshot.
575 if (isa<EnumConstantDecl>(VD) || isa<FunctionDecl>(VD))
576 return false;
577
578 // If this is a reference to an extern, static, or global variable, no need to
579 // snapshot it.
580 // FIXME: What about 'const' variables in C++?
581 if (const VarDecl *Var = dyn_cast<VarDecl>(VD))
582 if (!Var->hasLocalStorage())
583 return false;
584
585 // Blocks that have these can't be constant.
586 CurBlock->hasBlockDeclRefExprs = true;
587
588 // If we have nested blocks, the decl may be declared in an outer block (in
589 // which case that outer block doesn't get "hasBlockDeclRefExprs") or it may
590 // be defined outside all of the current blocks (in which case the blocks do
591 // all get the bit). Walk the nesting chain.
592 for (BlockSemaInfo *NextBlock = CurBlock->PrevBlockInfo; NextBlock;
593 NextBlock = NextBlock->PrevBlockInfo) {
594 // If we found the defining block for the variable, don't mark the block as
595 // having a reference outside it.
596 if (NextBlock->TheDecl == VD->getDeclContext())
597 break;
598
599 // Otherwise, the DeclRef from the inner block causes the outer one to need
600 // a snapshot as well.
601 NextBlock->hasBlockDeclRefExprs = true;
602 }
603
604 return true;
605}
606
607
608
609/// ActOnIdentifierExpr - The parser read an identifier in expression context,
610/// validate it per-C99 6.5.1. HasTrailingLParen indicates whether this
611/// identifier is used in a function call context.
612/// SS is only used for a C++ qualified-id (foo::bar) to indicate the
613/// class or namespace that the identifier must be a member of.
614Sema::OwningExprResult Sema::ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
615 IdentifierInfo &II,
616 bool HasTrailingLParen,
617 const CXXScopeSpec *SS,
618 bool isAddressOfOperand) {
619 return ActOnDeclarationNameExpr(S, Loc, &II, HasTrailingLParen, SS,
620 isAddressOfOperand);
621}
622
623/// BuildDeclRefExpr - Build either a DeclRefExpr or a
624/// QualifiedDeclRefExpr based on whether or not SS is a
625/// nested-name-specifier.
626Sema::OwningExprResult
627Sema::BuildDeclRefExpr(NamedDecl *D, QualType Ty, SourceLocation Loc,
628 bool TypeDependent, bool ValueDependent,
629 const CXXScopeSpec *SS) {
630 if (Context.getCanonicalType(Ty) == Context.UndeducedAutoTy) {
631 Diag(Loc,
632 diag::err_auto_variable_cannot_appear_in_own_initializer)
633 << D->getDeclName();
634 return ExprError();
635 }
636
637 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
638 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
639 if (const FunctionDecl *FD = MD->getParent()->isLocalClass()) {
640 if (VD->hasLocalStorage() && VD->getDeclContext() != CurContext) {
641 Diag(Loc, diag::err_reference_to_local_var_in_enclosing_function)
642 << D->getIdentifier() << FD->getDeclName();
643 Diag(D->getLocation(), diag::note_local_variable_declared_here)
644 << D->getIdentifier();
645 return ExprError();
646 }
647 }
648 }
649 }
650
651 MarkDeclarationReferenced(Loc, D);
652
653 Expr *E;
654 if (SS && !SS->isEmpty()) {
655 E = new (Context) QualifiedDeclRefExpr(D, Ty, Loc, TypeDependent,
656 ValueDependent, SS->getRange(),
657 static_cast<NestedNameSpecifier *>(SS->getScopeRep()));
658 } else
659 E = new (Context) DeclRefExpr(D, Ty, Loc, TypeDependent, ValueDependent);
660
661 return Owned(E);
662}
663
664/// getObjectForAnonymousRecordDecl - Retrieve the (unnamed) field or
665/// variable corresponding to the anonymous union or struct whose type
666/// is Record.
667static Decl *getObjectForAnonymousRecordDecl(ASTContext &Context,
668 RecordDecl *Record) {
669 assert(Record->isAnonymousStructOrUnion() &&
670 "Record must be an anonymous struct or union!");
671
672 // FIXME: Once Decls are directly linked together, this will be an O(1)
673 // operation rather than a slow walk through DeclContext's vector (which
674 // itself will be eliminated). DeclGroups might make this even better.
675 DeclContext *Ctx = Record->getDeclContext();
| 98 if (!attr)
99 return;
100 int sentinelPos = attr->getSentinel();
101 int nullPos = attr->getNullPos();
102
103 // FIXME. ObjCMethodDecl and FunctionDecl need be derived from the same common
104 // base class. Then we won't be needing two versions of the same code.
105 unsigned int i = 0;
106 bool warnNotEnoughArgs = false;
107 int isMethod = 0;
108 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
109 // skip over named parameters.
110 ObjCMethodDecl::param_iterator P, E = MD->param_end();
111 for (P = MD->param_begin(); (P != E && i < NumArgs); ++P) {
112 if (nullPos)
113 --nullPos;
114 else
115 ++i;
116 }
117 warnNotEnoughArgs = (P != E || i >= NumArgs);
118 isMethod = 1;
119 }
120 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
121 // skip over named parameters.
122 ObjCMethodDecl::param_iterator P, E = FD->param_end();
123 for (P = FD->param_begin(); (P != E && i < NumArgs); ++P) {
124 if (nullPos)
125 --nullPos;
126 else
127 ++i;
128 }
129 warnNotEnoughArgs = (P != E || i >= NumArgs);
130 }
131 else if (VarDecl *V = dyn_cast<VarDecl>(D)) {
132 // block or function pointer call.
133 QualType Ty = V->getType();
134 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
135 const FunctionType *FT = Ty->isFunctionPointerType()
136 ? Ty->getAsPointerType()->getPointeeType()->getAsFunctionType()
137 : Ty->getAsBlockPointerType()->getPointeeType()->getAsFunctionType();
138 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) {
139 unsigned NumArgsInProto = Proto->getNumArgs();
140 unsigned k;
141 for (k = 0; (k != NumArgsInProto && i < NumArgs); k++) {
142 if (nullPos)
143 --nullPos;
144 else
145 ++i;
146 }
147 warnNotEnoughArgs = (k != NumArgsInProto || i >= NumArgs);
148 }
149 if (Ty->isBlockPointerType())
150 isMethod = 2;
151 }
152 else
153 return;
154 }
155 else
156 return;
157
158 if (warnNotEnoughArgs) {
159 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
160 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
161 return;
162 }
163 int sentinel = i;
164 while (sentinelPos > 0 && i < NumArgs-1) {
165 --sentinelPos;
166 ++i;
167 }
168 if (sentinelPos > 0) {
169 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
170 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
171 return;
172 }
173 while (i < NumArgs-1) {
174 ++i;
175 ++sentinel;
176 }
177 Expr *sentinelExpr = Args[sentinel];
178 if (sentinelExpr && (!sentinelExpr->getType()->isPointerType() ||
179 !sentinelExpr->isNullPointerConstant(Context))) {
180 Diag(Loc, diag::warn_missing_sentinel) << isMethod;
181 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod;
182 }
183 return;
184}
185
186SourceRange Sema::getExprRange(ExprTy *E) const {
187 Expr *Ex = (Expr *)E;
188 return Ex? Ex->getSourceRange() : SourceRange();
189}
190
191//===----------------------------------------------------------------------===//
192// Standard Promotions and Conversions
193//===----------------------------------------------------------------------===//
194
195/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
196void Sema::DefaultFunctionArrayConversion(Expr *&E) {
197 QualType Ty = E->getType();
198 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
199
200 if (Ty->isFunctionType())
201 ImpCastExprToType(E, Context.getPointerType(Ty));
202 else if (Ty->isArrayType()) {
203 // In C90 mode, arrays only promote to pointers if the array expression is
204 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
205 // type 'array of type' is converted to an expression that has type 'pointer
206 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
207 // that has type 'array of type' ...". The relevant change is "an lvalue"
208 // (C90) to "an expression" (C99).
209 //
210 // C++ 4.2p1:
211 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
212 // T" can be converted to an rvalue of type "pointer to T".
213 //
214 if (getLangOptions().C99 || getLangOptions().CPlusPlus ||
215 E->isLvalue(Context) == Expr::LV_Valid)
216 ImpCastExprToType(E, Context.getArrayDecayedType(Ty));
217 }
218}
219
220/// \brief Whether this is a promotable bitfield reference according
221/// to C99 6.3.1.1p2, bullet 2.
222///
223/// \returns the type this bit-field will promote to, or NULL if no
224/// promotion occurs.
225static QualType isPromotableBitField(Expr *E, ASTContext &Context) {
226 FieldDecl *Field = E->getBitField();
227 if (!Field)
228 return QualType();
229
230 const BuiltinType *BT = Field->getType()->getAsBuiltinType();
231 if (!BT)
232 return QualType();
233
234 if (BT->getKind() != BuiltinType::Bool &&
235 BT->getKind() != BuiltinType::Int &&
236 BT->getKind() != BuiltinType::UInt)
237 return QualType();
238
239 llvm::APSInt BitWidthAP;
240 if (!Field->getBitWidth()->isIntegerConstantExpr(BitWidthAP, Context))
241 return QualType();
242
243 uint64_t BitWidth = BitWidthAP.getZExtValue();
244 uint64_t IntSize = Context.getTypeSize(Context.IntTy);
245 if (BitWidth < IntSize ||
246 (Field->getType()->isSignedIntegerType() && BitWidth == IntSize))
247 return Context.IntTy;
248
249 if (BitWidth == IntSize && Field->getType()->isUnsignedIntegerType())
250 return Context.UnsignedIntTy;
251
252 return QualType();
253}
254
255/// UsualUnaryConversions - Performs various conversions that are common to most
256/// operators (C99 6.3). The conversions of array and function types are
257/// sometimes surpressed. For example, the array->pointer conversion doesn't
258/// apply if the array is an argument to the sizeof or address (&) operators.
259/// In these instances, this routine should *not* be called.
260Expr *Sema::UsualUnaryConversions(Expr *&Expr) {
261 QualType Ty = Expr->getType();
262 assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
263
264 // C99 6.3.1.1p2:
265 //
266 // The following may be used in an expression wherever an int or
267 // unsigned int may be used:
268 // - an object or expression with an integer type whose integer
269 // conversion rank is less than or equal to the rank of int
270 // and unsigned int.
271 // - A bit-field of type _Bool, int, signed int, or unsigned int.
272 //
273 // If an int can represent all values of the original type, the
274 // value is converted to an int; otherwise, it is converted to an
275 // unsigned int. These are called the integer promotions. All
276 // other types are unchanged by the integer promotions.
277 if (Ty->isPromotableIntegerType()) {
278 ImpCastExprToType(Expr, Context.IntTy);
279 return Expr;
280 } else {
281 QualType T = isPromotableBitField(Expr, Context);
282 if (!T.isNull()) {
283 ImpCastExprToType(Expr, T);
284 return Expr;
285 }
286 }
287
288 DefaultFunctionArrayConversion(Expr);
289 return Expr;
290}
291
292/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
293/// do not have a prototype. Arguments that have type float are promoted to
294/// double. All other argument types are converted by UsualUnaryConversions().
295void Sema::DefaultArgumentPromotion(Expr *&Expr) {
296 QualType Ty = Expr->getType();
297 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
298
299 // If this is a 'float' (CVR qualified or typedef) promote to double.
300 if (const BuiltinType *BT = Ty->getAsBuiltinType())
301 if (BT->getKind() == BuiltinType::Float)
302 return ImpCastExprToType(Expr, Context.DoubleTy);
303
304 UsualUnaryConversions(Expr);
305}
306
307/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
308/// will warn if the resulting type is not a POD type, and rejects ObjC
309/// interfaces passed by value. This returns true if the argument type is
310/// completely illegal.
311bool Sema::DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT) {
312 DefaultArgumentPromotion(Expr);
313
314 if (Expr->getType()->isObjCInterfaceType()) {
315 Diag(Expr->getLocStart(),
316 diag::err_cannot_pass_objc_interface_to_vararg)
317 << Expr->getType() << CT;
318 return true;
319 }
320
321 if (!Expr->getType()->isPODType())
322 Diag(Expr->getLocStart(), diag::warn_cannot_pass_non_pod_arg_to_vararg)
323 << Expr->getType() << CT;
324
325 return false;
326}
327
328
329/// UsualArithmeticConversions - Performs various conversions that are common to
330/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
331/// routine returns the first non-arithmetic type found. The client is
332/// responsible for emitting appropriate error diagnostics.
333/// FIXME: verify the conversion rules for "complex int" are consistent with
334/// GCC.
335QualType Sema::UsualArithmeticConversions(Expr *&lhsExpr, Expr *&rhsExpr,
336 bool isCompAssign) {
337 if (!isCompAssign)
338 UsualUnaryConversions(lhsExpr);
339
340 UsualUnaryConversions(rhsExpr);
341
342 // For conversion purposes, we ignore any qualifiers.
343 // For example, "const float" and "float" are equivalent.
344 QualType lhs =
345 Context.getCanonicalType(lhsExpr->getType()).getUnqualifiedType();
346 QualType rhs =
347 Context.getCanonicalType(rhsExpr->getType()).getUnqualifiedType();
348
349 // If both types are identical, no conversion is needed.
350 if (lhs == rhs)
351 return lhs;
352
353 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
354 // The caller can deal with this (e.g. pointer + int).
355 if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
356 return lhs;
357
358 // Perform bitfield promotions.
359 QualType LHSBitfieldPromoteTy = isPromotableBitField(lhsExpr, Context);
360 if (!LHSBitfieldPromoteTy.isNull())
361 lhs = LHSBitfieldPromoteTy;
362 QualType RHSBitfieldPromoteTy = isPromotableBitField(rhsExpr, Context);
363 if (!RHSBitfieldPromoteTy.isNull())
364 rhs = RHSBitfieldPromoteTy;
365
366 QualType destType = UsualArithmeticConversionsType(lhs, rhs);
367 if (!isCompAssign)
368 ImpCastExprToType(lhsExpr, destType);
369 ImpCastExprToType(rhsExpr, destType);
370 return destType;
371}
372
373QualType Sema::UsualArithmeticConversionsType(QualType lhs, QualType rhs) {
374 // Perform the usual unary conversions. We do this early so that
375 // integral promotions to "int" can allow us to exit early, in the
376 // lhs == rhs check. Also, for conversion purposes, we ignore any
377 // qualifiers. For example, "const float" and "float" are
378 // equivalent.
379 if (lhs->isPromotableIntegerType())
380 lhs = Context.IntTy;
381 else
382 lhs = lhs.getUnqualifiedType();
383 if (rhs->isPromotableIntegerType())
384 rhs = Context.IntTy;
385 else
386 rhs = rhs.getUnqualifiedType();
387
388 // If both types are identical, no conversion is needed.
389 if (lhs == rhs)
390 return lhs;
391
392 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
393 // The caller can deal with this (e.g. pointer + int).
394 if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
395 return lhs;
396
397 // At this point, we have two different arithmetic types.
398
399 // Handle complex types first (C99 6.3.1.8p1).
400 if (lhs->isComplexType() || rhs->isComplexType()) {
401 // if we have an integer operand, the result is the complex type.
402 if (rhs->isIntegerType() || rhs->isComplexIntegerType()) {
403 // convert the rhs to the lhs complex type.
404 return lhs;
405 }
406 if (lhs->isIntegerType() || lhs->isComplexIntegerType()) {
407 // convert the lhs to the rhs complex type.
408 return rhs;
409 }
410 // This handles complex/complex, complex/float, or float/complex.
411 // When both operands are complex, the shorter operand is converted to the
412 // type of the longer, and that is the type of the result. This corresponds
413 // to what is done when combining two real floating-point operands.
414 // The fun begins when size promotion occur across type domains.
415 // From H&S 6.3.4: When one operand is complex and the other is a real
416 // floating-point type, the less precise type is converted, within it's
417 // real or complex domain, to the precision of the other type. For example,
418 // when combining a "long double" with a "double _Complex", the
419 // "double _Complex" is promoted to "long double _Complex".
420 int result = Context.getFloatingTypeOrder(lhs, rhs);
421
422 if (result > 0) { // The left side is bigger, convert rhs.
423 rhs = Context.getFloatingTypeOfSizeWithinDomain(lhs, rhs);
424 } else if (result < 0) { // The right side is bigger, convert lhs.
425 lhs = Context.getFloatingTypeOfSizeWithinDomain(rhs, lhs);
426 }
427 // At this point, lhs and rhs have the same rank/size. Now, make sure the
428 // domains match. This is a requirement for our implementation, C99
429 // does not require this promotion.
430 if (lhs != rhs) { // Domains don't match, we have complex/float mix.
431 if (lhs->isRealFloatingType()) { // handle "double, _Complex double".
432 return rhs;
433 } else { // handle "_Complex double, double".
434 return lhs;
435 }
436 }
437 return lhs; // The domain/size match exactly.
438 }
439 // Now handle "real" floating types (i.e. float, double, long double).
440 if (lhs->isRealFloatingType() || rhs->isRealFloatingType()) {
441 // if we have an integer operand, the result is the real floating type.
442 if (rhs->isIntegerType()) {
443 // convert rhs to the lhs floating point type.
444 return lhs;
445 }
446 if (rhs->isComplexIntegerType()) {
447 // convert rhs to the complex floating point type.
448 return Context.getComplexType(lhs);
449 }
450 if (lhs->isIntegerType()) {
451 // convert lhs to the rhs floating point type.
452 return rhs;
453 }
454 if (lhs->isComplexIntegerType()) {
455 // convert lhs to the complex floating point type.
456 return Context.getComplexType(rhs);
457 }
458 // We have two real floating types, float/complex combos were handled above.
459 // Convert the smaller operand to the bigger result.
460 int result = Context.getFloatingTypeOrder(lhs, rhs);
461 if (result > 0) // convert the rhs
462 return lhs;
463 assert(result < 0 && "illegal float comparison");
464 return rhs; // convert the lhs
465 }
466 if (lhs->isComplexIntegerType() || rhs->isComplexIntegerType()) {
467 // Handle GCC complex int extension.
468 const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType();
469 const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType();
470
471 if (lhsComplexInt && rhsComplexInt) {
472 if (Context.getIntegerTypeOrder(lhsComplexInt->getElementType(),
473 rhsComplexInt->getElementType()) >= 0)
474 return lhs; // convert the rhs
475 return rhs;
476 } else if (lhsComplexInt && rhs->isIntegerType()) {
477 // convert the rhs to the lhs complex type.
478 return lhs;
479 } else if (rhsComplexInt && lhs->isIntegerType()) {
480 // convert the lhs to the rhs complex type.
481 return rhs;
482 }
483 }
484 // Finally, we have two differing integer types.
485 // The rules for this case are in C99 6.3.1.8
486 int compare = Context.getIntegerTypeOrder(lhs, rhs);
487 bool lhsSigned = lhs->isSignedIntegerType(),
488 rhsSigned = rhs->isSignedIntegerType();
489 QualType destType;
490 if (lhsSigned == rhsSigned) {
491 // Same signedness; use the higher-ranked type
492 destType = compare >= 0 ? lhs : rhs;
493 } else if (compare != (lhsSigned ? 1 : -1)) {
494 // The unsigned type has greater than or equal rank to the
495 // signed type, so use the unsigned type
496 destType = lhsSigned ? rhs : lhs;
497 } else if (Context.getIntWidth(lhs) != Context.getIntWidth(rhs)) {
498 // The two types are different widths; if we are here, that
499 // means the signed type is larger than the unsigned type, so
500 // use the signed type.
501 destType = lhsSigned ? lhs : rhs;
502 } else {
503 // The signed type is higher-ranked than the unsigned type,
504 // but isn't actually any bigger (like unsigned int and long
505 // on most 32-bit systems). Use the unsigned type corresponding
506 // to the signed type.
507 destType = Context.getCorrespondingUnsignedType(lhsSigned ? lhs : rhs);
508 }
509 return destType;
510}
511
512//===----------------------------------------------------------------------===//
513// Semantic Analysis for various Expression Types
514//===----------------------------------------------------------------------===//
515
516
517/// ActOnStringLiteral - The specified tokens were lexed as pasted string
518/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
519/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
520/// multiple tokens. However, the common case is that StringToks points to one
521/// string.
522///
523Action::OwningExprResult
524Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) {
525 assert(NumStringToks && "Must have at least one string!");
526
527 StringLiteralParser Literal(StringToks, NumStringToks, PP);
528 if (Literal.hadError)
529 return ExprError();
530
531 llvm::SmallVector<SourceLocation, 4> StringTokLocs;
532 for (unsigned i = 0; i != NumStringToks; ++i)
533 StringTokLocs.push_back(StringToks[i].getLocation());
534
535 QualType StrTy = Context.CharTy;
536 if (Literal.AnyWide) StrTy = Context.getWCharType();
537 if (Literal.Pascal) StrTy = Context.UnsignedCharTy;
538
539 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
540 if (getLangOptions().CPlusPlus)
541 StrTy.addConst();
542
543 // Get an array type for the string, according to C99 6.4.5. This includes
544 // the nul terminator character as well as the string length for pascal
545 // strings.
546 StrTy = Context.getConstantArrayType(StrTy,
547 llvm::APInt(32, Literal.GetNumStringChars()+1),
548 ArrayType::Normal, 0);
549
550 // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
551 return Owned(StringLiteral::Create(Context, Literal.GetString(),
552 Literal.GetStringLength(),
553 Literal.AnyWide, StrTy,
554 &StringTokLocs[0],
555 StringTokLocs.size()));
556}
557
558/// ShouldSnapshotBlockValueReference - Return true if a reference inside of
559/// CurBlock to VD should cause it to be snapshotted (as we do for auto
560/// variables defined outside the block) or false if this is not needed (e.g.
561/// for values inside the block or for globals).
562///
563/// This also keeps the 'hasBlockDeclRefExprs' in the BlockSemaInfo records
564/// up-to-date.
565///
566static bool ShouldSnapshotBlockValueReference(BlockSemaInfo *CurBlock,
567 ValueDecl *VD) {
568 // If the value is defined inside the block, we couldn't snapshot it even if
569 // we wanted to.
570 if (CurBlock->TheDecl == VD->getDeclContext())
571 return false;
572
573 // If this is an enum constant or function, it is constant, don't snapshot.
574 if (isa<EnumConstantDecl>(VD) || isa<FunctionDecl>(VD))
575 return false;
576
577 // If this is a reference to an extern, static, or global variable, no need to
578 // snapshot it.
579 // FIXME: What about 'const' variables in C++?
580 if (const VarDecl *Var = dyn_cast<VarDecl>(VD))
581 if (!Var->hasLocalStorage())
582 return false;
583
584 // Blocks that have these can't be constant.
585 CurBlock->hasBlockDeclRefExprs = true;
586
587 // If we have nested blocks, the decl may be declared in an outer block (in
588 // which case that outer block doesn't get "hasBlockDeclRefExprs") or it may
589 // be defined outside all of the current blocks (in which case the blocks do
590 // all get the bit). Walk the nesting chain.
591 for (BlockSemaInfo *NextBlock = CurBlock->PrevBlockInfo; NextBlock;
592 NextBlock = NextBlock->PrevBlockInfo) {
593 // If we found the defining block for the variable, don't mark the block as
594 // having a reference outside it.
595 if (NextBlock->TheDecl == VD->getDeclContext())
596 break;
597
598 // Otherwise, the DeclRef from the inner block causes the outer one to need
599 // a snapshot as well.
600 NextBlock->hasBlockDeclRefExprs = true;
601 }
602
603 return true;
604}
605
606
607
608/// ActOnIdentifierExpr - The parser read an identifier in expression context,
609/// validate it per-C99 6.5.1. HasTrailingLParen indicates whether this
610/// identifier is used in a function call context.
611/// SS is only used for a C++ qualified-id (foo::bar) to indicate the
612/// class or namespace that the identifier must be a member of.
613Sema::OwningExprResult Sema::ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
614 IdentifierInfo &II,
615 bool HasTrailingLParen,
616 const CXXScopeSpec *SS,
617 bool isAddressOfOperand) {
618 return ActOnDeclarationNameExpr(S, Loc, &II, HasTrailingLParen, SS,
619 isAddressOfOperand);
620}
621
622/// BuildDeclRefExpr - Build either a DeclRefExpr or a
623/// QualifiedDeclRefExpr based on whether or not SS is a
624/// nested-name-specifier.
625Sema::OwningExprResult
626Sema::BuildDeclRefExpr(NamedDecl *D, QualType Ty, SourceLocation Loc,
627 bool TypeDependent, bool ValueDependent,
628 const CXXScopeSpec *SS) {
629 if (Context.getCanonicalType(Ty) == Context.UndeducedAutoTy) {
630 Diag(Loc,
631 diag::err_auto_variable_cannot_appear_in_own_initializer)
632 << D->getDeclName();
633 return ExprError();
634 }
635
636 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
637 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
638 if (const FunctionDecl *FD = MD->getParent()->isLocalClass()) {
639 if (VD->hasLocalStorage() && VD->getDeclContext() != CurContext) {
640 Diag(Loc, diag::err_reference_to_local_var_in_enclosing_function)
641 << D->getIdentifier() << FD->getDeclName();
642 Diag(D->getLocation(), diag::note_local_variable_declared_here)
643 << D->getIdentifier();
644 return ExprError();
645 }
646 }
647 }
648 }
649
650 MarkDeclarationReferenced(Loc, D);
651
652 Expr *E;
653 if (SS && !SS->isEmpty()) {
654 E = new (Context) QualifiedDeclRefExpr(D, Ty, Loc, TypeDependent,
655 ValueDependent, SS->getRange(),
656 static_cast<NestedNameSpecifier *>(SS->getScopeRep()));
657 } else
658 E = new (Context) DeclRefExpr(D, Ty, Loc, TypeDependent, ValueDependent);
659
660 return Owned(E);
661}
662
663/// getObjectForAnonymousRecordDecl - Retrieve the (unnamed) field or
664/// variable corresponding to the anonymous union or struct whose type
665/// is Record.
666static Decl *getObjectForAnonymousRecordDecl(ASTContext &Context,
667 RecordDecl *Record) {
668 assert(Record->isAnonymousStructOrUnion() &&
669 "Record must be an anonymous struct or union!");
670
671 // FIXME: Once Decls are directly linked together, this will be an O(1)
672 // operation rather than a slow walk through DeclContext's vector (which
673 // itself will be eliminated). DeclGroups might make this even better.
674 DeclContext *Ctx = Record->getDeclContext();
|
676 for (DeclContext::decl_iterator D = Ctx->decls_begin(Context),
677 DEnd = Ctx->decls_end(Context);
| 675 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
676 DEnd = Ctx->decls_end();
|
678 D != DEnd; ++D) {
679 if (*D == Record) {
680 // The object for the anonymous struct/union directly
681 // follows its type in the list of declarations.
682 ++D;
683 assert(D != DEnd && "Missing object for anonymous record");
684 assert(!cast<NamedDecl>(*D)->getDeclName() && "Decl should be unnamed");
685 return *D;
686 }
687 }
688
689 assert(false && "Missing object for anonymous record");
690 return 0;
691}
692
693/// \brief Given a field that represents a member of an anonymous
694/// struct/union, build the path from that field's context to the
695/// actual member.
696///
697/// Construct the sequence of field member references we'll have to
698/// perform to get to the field in the anonymous union/struct. The
699/// list of members is built from the field outward, so traverse it
700/// backwards to go from an object in the current context to the field
701/// we found.
702///
703/// \returns The variable from which the field access should begin,
704/// for an anonymous struct/union that is not a member of another
705/// class. Otherwise, returns NULL.
706VarDecl *Sema::BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
707 llvm::SmallVectorImpl<FieldDecl *> &Path) {
708 assert(Field->getDeclContext()->isRecord() &&
709 cast<RecordDecl>(Field->getDeclContext())->isAnonymousStructOrUnion()
710 && "Field must be stored inside an anonymous struct or union");
711
712 Path.push_back(Field);
713 VarDecl *BaseObject = 0;
714 DeclContext *Ctx = Field->getDeclContext();
715 do {
716 RecordDecl *Record = cast<RecordDecl>(Ctx);
717 Decl *AnonObject = getObjectForAnonymousRecordDecl(Context, Record);
718 if (FieldDecl *AnonField = dyn_cast<FieldDecl>(AnonObject))
719 Path.push_back(AnonField);
720 else {
721 BaseObject = cast<VarDecl>(AnonObject);
722 break;
723 }
724 Ctx = Ctx->getParent();
725 } while (Ctx->isRecord() &&
726 cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion());
727
728 return BaseObject;
729}
730
731Sema::OwningExprResult
732Sema::BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
733 FieldDecl *Field,
734 Expr *BaseObjectExpr,
735 SourceLocation OpLoc) {
736 llvm::SmallVector<FieldDecl *, 4> AnonFields;
737 VarDecl *BaseObject = BuildAnonymousStructUnionMemberPath(Field,
738 AnonFields);
739
740 // Build the expression that refers to the base object, from
741 // which we will build a sequence of member references to each
742 // of the anonymous union objects and, eventually, the field we
743 // found via name lookup.
744 bool BaseObjectIsPointer = false;
745 unsigned ExtraQuals = 0;
746 if (BaseObject) {
747 // BaseObject is an anonymous struct/union variable (and is,
748 // therefore, not part of another non-anonymous record).
749 if (BaseObjectExpr) BaseObjectExpr->Destroy(Context);
750 MarkDeclarationReferenced(Loc, BaseObject);
751 BaseObjectExpr = new (Context) DeclRefExpr(BaseObject,BaseObject->getType(),
752 SourceLocation());
753 ExtraQuals
754 = Context.getCanonicalType(BaseObject->getType()).getCVRQualifiers();
755 } else if (BaseObjectExpr) {
756 // The caller provided the base object expression. Determine
757 // whether its a pointer and whether it adds any qualifiers to the
758 // anonymous struct/union fields we're looking into.
759 QualType ObjectType = BaseObjectExpr->getType();
760 if (const PointerType *ObjectPtr = ObjectType->getAsPointerType()) {
761 BaseObjectIsPointer = true;
762 ObjectType = ObjectPtr->getPointeeType();
763 }
764 ExtraQuals = Context.getCanonicalType(ObjectType).getCVRQualifiers();
765 } else {
766 // We've found a member of an anonymous struct/union that is
767 // inside a non-anonymous struct/union, so in a well-formed
768 // program our base object expression is "this".
769 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
770 if (!MD->isStatic()) {
771 QualType AnonFieldType
772 = Context.getTagDeclType(
773 cast<RecordDecl>(AnonFields.back()->getDeclContext()));
774 QualType ThisType = Context.getTagDeclType(MD->getParent());
775 if ((Context.getCanonicalType(AnonFieldType)
776 == Context.getCanonicalType(ThisType)) ||
777 IsDerivedFrom(ThisType, AnonFieldType)) {
778 // Our base object expression is "this".
779 BaseObjectExpr = new (Context) CXXThisExpr(SourceLocation(),
780 MD->getThisType(Context));
781 BaseObjectIsPointer = true;
782 }
783 } else {
784 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
785 << Field->getDeclName());
786 }
787 ExtraQuals = MD->getTypeQualifiers();
788 }
789
790 if (!BaseObjectExpr)
791 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
792 << Field->getDeclName());
793 }
794
795 // Build the implicit member references to the field of the
796 // anonymous struct/union.
797 Expr *Result = BaseObjectExpr;
798 for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator
799 FI = AnonFields.rbegin(), FIEnd = AnonFields.rend();
800 FI != FIEnd; ++FI) {
801 QualType MemberType = (*FI)->getType();
802 if (!(*FI)->isMutable()) {
803 unsigned combinedQualifiers
804 = MemberType.getCVRQualifiers() | ExtraQuals;
805 MemberType = MemberType.getQualifiedType(combinedQualifiers);
806 }
807 MarkDeclarationReferenced(Loc, *FI);
808 Result = new (Context) MemberExpr(Result, BaseObjectIsPointer, *FI,
809 OpLoc, MemberType);
810 BaseObjectIsPointer = false;
811 ExtraQuals = Context.getCanonicalType(MemberType).getCVRQualifiers();
812 }
813
814 return Owned(Result);
815}
816
817/// ActOnDeclarationNameExpr - The parser has read some kind of name
818/// (e.g., a C++ id-expression (C++ [expr.prim]p1)). This routine
819/// performs lookup on that name and returns an expression that refers
820/// to that name. This routine isn't directly called from the parser,
821/// because the parser doesn't know about DeclarationName. Rather,
822/// this routine is called by ActOnIdentifierExpr,
823/// ActOnOperatorFunctionIdExpr, and ActOnConversionFunctionExpr,
824/// which form the DeclarationName from the corresponding syntactic
825/// forms.
826///
827/// HasTrailingLParen indicates whether this identifier is used in a
828/// function call context. LookupCtx is only used for a C++
829/// qualified-id (foo::bar) to indicate the class or namespace that
830/// the identifier must be a member of.
831///
832/// isAddressOfOperand means that this expression is the direct operand
833/// of an address-of operator. This matters because this is the only
834/// situation where a qualified name referencing a non-static member may
835/// appear outside a member function of this class.
836Sema::OwningExprResult
837Sema::ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
838 DeclarationName Name, bool HasTrailingLParen,
839 const CXXScopeSpec *SS,
840 bool isAddressOfOperand) {
841 // Could be enum-constant, value decl, instance variable, etc.
842 if (SS && SS->isInvalid())
843 return ExprError();
844
845 // C++ [temp.dep.expr]p3:
846 // An id-expression is type-dependent if it contains:
847 // -- a nested-name-specifier that contains a class-name that
848 // names a dependent type.
849 // FIXME: Member of the current instantiation.
850 if (SS && isDependentScopeSpecifier(*SS)) {
851 return Owned(new (Context) UnresolvedDeclRefExpr(Name, Context.DependentTy,
852 Loc, SS->getRange(),
853 static_cast<NestedNameSpecifier *>(SS->getScopeRep())));
854 }
855
856 LookupResult Lookup = LookupParsedName(S, SS, Name, LookupOrdinaryName,
857 false, true, Loc);
858
859 if (Lookup.isAmbiguous()) {
860 DiagnoseAmbiguousLookup(Lookup, Name, Loc,
861 SS && SS->isSet() ? SS->getRange()
862 : SourceRange());
863 return ExprError();
864 }
865
866 NamedDecl *D = Lookup.getAsDecl();
867
868 // If this reference is in an Objective-C method, then ivar lookup happens as
869 // well.
870 IdentifierInfo *II = Name.getAsIdentifierInfo();
871 if (II && getCurMethodDecl()) {
872 // There are two cases to handle here. 1) scoped lookup could have failed,
873 // in which case we should look for an ivar. 2) scoped lookup could have
874 // found a decl, but that decl is outside the current instance method (i.e.
875 // a global variable). In these two cases, we do a lookup for an ivar with
876 // this name, if the lookup sucedes, we replace it our current decl.
877 if (D == 0 || D->isDefinedOutsideFunctionOrMethod()) {
878 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
879 ObjCInterfaceDecl *ClassDeclared;
| 677 D != DEnd; ++D) {
678 if (*D == Record) {
679 // The object for the anonymous struct/union directly
680 // follows its type in the list of declarations.
681 ++D;
682 assert(D != DEnd && "Missing object for anonymous record");
683 assert(!cast<NamedDecl>(*D)->getDeclName() && "Decl should be unnamed");
684 return *D;
685 }
686 }
687
688 assert(false && "Missing object for anonymous record");
689 return 0;
690}
691
692/// \brief Given a field that represents a member of an anonymous
693/// struct/union, build the path from that field's context to the
694/// actual member.
695///
696/// Construct the sequence of field member references we'll have to
697/// perform to get to the field in the anonymous union/struct. The
698/// list of members is built from the field outward, so traverse it
699/// backwards to go from an object in the current context to the field
700/// we found.
701///
702/// \returns The variable from which the field access should begin,
703/// for an anonymous struct/union that is not a member of another
704/// class. Otherwise, returns NULL.
705VarDecl *Sema::BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
706 llvm::SmallVectorImpl<FieldDecl *> &Path) {
707 assert(Field->getDeclContext()->isRecord() &&
708 cast<RecordDecl>(Field->getDeclContext())->isAnonymousStructOrUnion()
709 && "Field must be stored inside an anonymous struct or union");
710
711 Path.push_back(Field);
712 VarDecl *BaseObject = 0;
713 DeclContext *Ctx = Field->getDeclContext();
714 do {
715 RecordDecl *Record = cast<RecordDecl>(Ctx);
716 Decl *AnonObject = getObjectForAnonymousRecordDecl(Context, Record);
717 if (FieldDecl *AnonField = dyn_cast<FieldDecl>(AnonObject))
718 Path.push_back(AnonField);
719 else {
720 BaseObject = cast<VarDecl>(AnonObject);
721 break;
722 }
723 Ctx = Ctx->getParent();
724 } while (Ctx->isRecord() &&
725 cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion());
726
727 return BaseObject;
728}
729
730Sema::OwningExprResult
731Sema::BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
732 FieldDecl *Field,
733 Expr *BaseObjectExpr,
734 SourceLocation OpLoc) {
735 llvm::SmallVector<FieldDecl *, 4> AnonFields;
736 VarDecl *BaseObject = BuildAnonymousStructUnionMemberPath(Field,
737 AnonFields);
738
739 // Build the expression that refers to the base object, from
740 // which we will build a sequence of member references to each
741 // of the anonymous union objects and, eventually, the field we
742 // found via name lookup.
743 bool BaseObjectIsPointer = false;
744 unsigned ExtraQuals = 0;
745 if (BaseObject) {
746 // BaseObject is an anonymous struct/union variable (and is,
747 // therefore, not part of another non-anonymous record).
748 if (BaseObjectExpr) BaseObjectExpr->Destroy(Context);
749 MarkDeclarationReferenced(Loc, BaseObject);
750 BaseObjectExpr = new (Context) DeclRefExpr(BaseObject,BaseObject->getType(),
751 SourceLocation());
752 ExtraQuals
753 = Context.getCanonicalType(BaseObject->getType()).getCVRQualifiers();
754 } else if (BaseObjectExpr) {
755 // The caller provided the base object expression. Determine
756 // whether its a pointer and whether it adds any qualifiers to the
757 // anonymous struct/union fields we're looking into.
758 QualType ObjectType = BaseObjectExpr->getType();
759 if (const PointerType *ObjectPtr = ObjectType->getAsPointerType()) {
760 BaseObjectIsPointer = true;
761 ObjectType = ObjectPtr->getPointeeType();
762 }
763 ExtraQuals = Context.getCanonicalType(ObjectType).getCVRQualifiers();
764 } else {
765 // We've found a member of an anonymous struct/union that is
766 // inside a non-anonymous struct/union, so in a well-formed
767 // program our base object expression is "this".
768 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
769 if (!MD->isStatic()) {
770 QualType AnonFieldType
771 = Context.getTagDeclType(
772 cast<RecordDecl>(AnonFields.back()->getDeclContext()));
773 QualType ThisType = Context.getTagDeclType(MD->getParent());
774 if ((Context.getCanonicalType(AnonFieldType)
775 == Context.getCanonicalType(ThisType)) ||
776 IsDerivedFrom(ThisType, AnonFieldType)) {
777 // Our base object expression is "this".
778 BaseObjectExpr = new (Context) CXXThisExpr(SourceLocation(),
779 MD->getThisType(Context));
780 BaseObjectIsPointer = true;
781 }
782 } else {
783 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
784 << Field->getDeclName());
785 }
786 ExtraQuals = MD->getTypeQualifiers();
787 }
788
789 if (!BaseObjectExpr)
790 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
791 << Field->getDeclName());
792 }
793
794 // Build the implicit member references to the field of the
795 // anonymous struct/union.
796 Expr *Result = BaseObjectExpr;
797 for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator
798 FI = AnonFields.rbegin(), FIEnd = AnonFields.rend();
799 FI != FIEnd; ++FI) {
800 QualType MemberType = (*FI)->getType();
801 if (!(*FI)->isMutable()) {
802 unsigned combinedQualifiers
803 = MemberType.getCVRQualifiers() | ExtraQuals;
804 MemberType = MemberType.getQualifiedType(combinedQualifiers);
805 }
806 MarkDeclarationReferenced(Loc, *FI);
807 Result = new (Context) MemberExpr(Result, BaseObjectIsPointer, *FI,
808 OpLoc, MemberType);
809 BaseObjectIsPointer = false;
810 ExtraQuals = Context.getCanonicalType(MemberType).getCVRQualifiers();
811 }
812
813 return Owned(Result);
814}
815
816/// ActOnDeclarationNameExpr - The parser has read some kind of name
817/// (e.g., a C++ id-expression (C++ [expr.prim]p1)). This routine
818/// performs lookup on that name and returns an expression that refers
819/// to that name. This routine isn't directly called from the parser,
820/// because the parser doesn't know about DeclarationName. Rather,
821/// this routine is called by ActOnIdentifierExpr,
822/// ActOnOperatorFunctionIdExpr, and ActOnConversionFunctionExpr,
823/// which form the DeclarationName from the corresponding syntactic
824/// forms.
825///
826/// HasTrailingLParen indicates whether this identifier is used in a
827/// function call context. LookupCtx is only used for a C++
828/// qualified-id (foo::bar) to indicate the class or namespace that
829/// the identifier must be a member of.
830///
831/// isAddressOfOperand means that this expression is the direct operand
832/// of an address-of operator. This matters because this is the only
833/// situation where a qualified name referencing a non-static member may
834/// appear outside a member function of this class.
835Sema::OwningExprResult
836Sema::ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
837 DeclarationName Name, bool HasTrailingLParen,
838 const CXXScopeSpec *SS,
839 bool isAddressOfOperand) {
840 // Could be enum-constant, value decl, instance variable, etc.
841 if (SS && SS->isInvalid())
842 return ExprError();
843
844 // C++ [temp.dep.expr]p3:
845 // An id-expression is type-dependent if it contains:
846 // -- a nested-name-specifier that contains a class-name that
847 // names a dependent type.
848 // FIXME: Member of the current instantiation.
849 if (SS && isDependentScopeSpecifier(*SS)) {
850 return Owned(new (Context) UnresolvedDeclRefExpr(Name, Context.DependentTy,
851 Loc, SS->getRange(),
852 static_cast<NestedNameSpecifier *>(SS->getScopeRep())));
853 }
854
855 LookupResult Lookup = LookupParsedName(S, SS, Name, LookupOrdinaryName,
856 false, true, Loc);
857
858 if (Lookup.isAmbiguous()) {
859 DiagnoseAmbiguousLookup(Lookup, Name, Loc,
860 SS && SS->isSet() ? SS->getRange()
861 : SourceRange());
862 return ExprError();
863 }
864
865 NamedDecl *D = Lookup.getAsDecl();
866
867 // If this reference is in an Objective-C method, then ivar lookup happens as
868 // well.
869 IdentifierInfo *II = Name.getAsIdentifierInfo();
870 if (II && getCurMethodDecl()) {
871 // There are two cases to handle here. 1) scoped lookup could have failed,
872 // in which case we should look for an ivar. 2) scoped lookup could have
873 // found a decl, but that decl is outside the current instance method (i.e.
874 // a global variable). In these two cases, we do a lookup for an ivar with
875 // this name, if the lookup sucedes, we replace it our current decl.
876 if (D == 0 || D->isDefinedOutsideFunctionOrMethod()) {
877 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
878 ObjCInterfaceDecl *ClassDeclared;
|
880 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(Context, II,
881 ClassDeclared)) {
| 879 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
|
882 // Check if referencing a field with __attribute__((deprecated)).
883 if (DiagnoseUseOfDecl(IV, Loc))
884 return ExprError();
885
886 // If we're referencing an invalid decl, just return this as a silent
887 // error node. The error diagnostic was already emitted on the decl.
888 if (IV->isInvalidDecl())
889 return ExprError();
890
891 bool IsClsMethod = getCurMethodDecl()->isClassMethod();
892 // If a class method attemps to use a free standing ivar, this is
893 // an error.
894 if (IsClsMethod && D && !D->isDefinedOutsideFunctionOrMethod())
895 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
896 << IV->getDeclName());
897 // If a class method uses a global variable, even if an ivar with
898 // same name exists, use the global.
899 if (!IsClsMethod) {
900 if (IV->getAccessControl() == ObjCIvarDecl::Private &&
901 ClassDeclared != IFace)
902 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName();
903 // FIXME: This should use a new expr for a direct reference, don't
904 // turn this into Self->ivar, just return a BareIVarExpr or something.
905 IdentifierInfo &II = Context.Idents.get("self");
906 OwningExprResult SelfExpr = ActOnIdentifierExpr(S, Loc, II, false);
907 MarkDeclarationReferenced(Loc, IV);
908 return Owned(new (Context)
909 ObjCIvarRefExpr(IV, IV->getType(), Loc,
910 SelfExpr.takeAs<Expr>(), true, true));
911 }
912 }
913 }
914 else if (getCurMethodDecl()->isInstanceMethod()) {
915 // We should warn if a local variable hides an ivar.
916 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
917 ObjCInterfaceDecl *ClassDeclared;
| 880 // Check if referencing a field with __attribute__((deprecated)).
881 if (DiagnoseUseOfDecl(IV, Loc))
882 return ExprError();
883
884 // If we're referencing an invalid decl, just return this as a silent
885 // error node. The error diagnostic was already emitted on the decl.
886 if (IV->isInvalidDecl())
887 return ExprError();
888
889 bool IsClsMethod = getCurMethodDecl()->isClassMethod();
890 // If a class method attemps to use a free standing ivar, this is
891 // an error.
892 if (IsClsMethod && D && !D->isDefinedOutsideFunctionOrMethod())
893 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
894 << IV->getDeclName());
895 // If a class method uses a global variable, even if an ivar with
896 // same name exists, use the global.
897 if (!IsClsMethod) {
898 if (IV->getAccessControl() == ObjCIvarDecl::Private &&
899 ClassDeclared != IFace)
900 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName();
901 // FIXME: This should use a new expr for a direct reference, don't
902 // turn this into Self->ivar, just return a BareIVarExpr or something.
903 IdentifierInfo &II = Context.Idents.get("self");
904 OwningExprResult SelfExpr = ActOnIdentifierExpr(S, Loc, II, false);
905 MarkDeclarationReferenced(Loc, IV);
906 return Owned(new (Context)
907 ObjCIvarRefExpr(IV, IV->getType(), Loc,
908 SelfExpr.takeAs<Expr>(), true, true));
909 }
910 }
911 }
912 else if (getCurMethodDecl()->isInstanceMethod()) {
913 // We should warn if a local variable hides an ivar.
914 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface();
915 ObjCInterfaceDecl *ClassDeclared;
|
918 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(Context, II,
919 ClassDeclared)) {
| 916 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
|
920 if (IV->getAccessControl() != ObjCIvarDecl::Private ||
921 IFace == ClassDeclared)
922 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
923 }
924 }
925 // Needed to implement property "super.method" notation.
926 if (D == 0 && II->isStr("super")) {
927 QualType T;
928
929 if (getCurMethodDecl()->isInstanceMethod())
930 T = Context.getPointerType(Context.getObjCInterfaceType(
931 getCurMethodDecl()->getClassInterface()));
932 else
933 T = Context.getObjCClassType();
934 return Owned(new (Context) ObjCSuperExpr(Loc, T));
935 }
936 }
937
938 // Determine whether this name might be a candidate for
939 // argument-dependent lookup.
940 bool ADL = getLangOptions().CPlusPlus && (!SS || !SS->isSet()) &&
941 HasTrailingLParen;
942
943 if (ADL && D == 0) {
944 // We've seen something of the form
945 //
946 // identifier(
947 //
948 // and we did not find any entity by the name
949 // "identifier". However, this identifier is still subject to
950 // argument-dependent lookup, so keep track of the name.
951 return Owned(new (Context) UnresolvedFunctionNameExpr(Name,
952 Context.OverloadTy,
953 Loc));
954 }
955
956 if (D == 0) {
957 // Otherwise, this could be an implicitly declared function reference (legal
958 // in C90, extension in C99).
959 if (HasTrailingLParen && II &&
960 !getLangOptions().CPlusPlus) // Not in C++.
961 D = ImplicitlyDefineFunction(Loc, *II, S);
962 else {
963 // If this name wasn't predeclared and if this is not a function call,
964 // diagnose the problem.
965 if (SS && !SS->isEmpty())
966 return ExprError(Diag(Loc, diag::err_typecheck_no_member)
967 << Name << SS->getRange());
968 else if (Name.getNameKind() == DeclarationName::CXXOperatorName ||
969 Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
970 return ExprError(Diag(Loc, diag::err_undeclared_use)
971 << Name.getAsString());
972 else
973 return ExprError(Diag(Loc, diag::err_undeclared_var_use) << Name);
974 }
975 }
| 917 if (IV->getAccessControl() != ObjCIvarDecl::Private ||
918 IFace == ClassDeclared)
919 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
920 }
921 }
922 // Needed to implement property "super.method" notation.
923 if (D == 0 && II->isStr("super")) {
924 QualType T;
925
926 if (getCurMethodDecl()->isInstanceMethod())
927 T = Context.getPointerType(Context.getObjCInterfaceType(
928 getCurMethodDecl()->getClassInterface()));
929 else
930 T = Context.getObjCClassType();
931 return Owned(new (Context) ObjCSuperExpr(Loc, T));
932 }
933 }
934
935 // Determine whether this name might be a candidate for
936 // argument-dependent lookup.
937 bool ADL = getLangOptions().CPlusPlus && (!SS || !SS->isSet()) &&
938 HasTrailingLParen;
939
940 if (ADL && D == 0) {
941 // We've seen something of the form
942 //
943 // identifier(
944 //
945 // and we did not find any entity by the name
946 // "identifier". However, this identifier is still subject to
947 // argument-dependent lookup, so keep track of the name.
948 return Owned(new (Context) UnresolvedFunctionNameExpr(Name,
949 Context.OverloadTy,
950 Loc));
951 }
952
953 if (D == 0) {
954 // Otherwise, this could be an implicitly declared function reference (legal
955 // in C90, extension in C99).
956 if (HasTrailingLParen && II &&
957 !getLangOptions().CPlusPlus) // Not in C++.
958 D = ImplicitlyDefineFunction(Loc, *II, S);
959 else {
960 // If this name wasn't predeclared and if this is not a function call,
961 // diagnose the problem.
962 if (SS && !SS->isEmpty())
963 return ExprError(Diag(Loc, diag::err_typecheck_no_member)
964 << Name << SS->getRange());
965 else if (Name.getNameKind() == DeclarationName::CXXOperatorName ||
966 Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
967 return ExprError(Diag(Loc, diag::err_undeclared_use)
968 << Name.getAsString());
969 else
970 return ExprError(Diag(Loc, diag::err_undeclared_var_use) << Name);
971 }
972 }
|
| 973
974 if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
975 // Warn about constructs like:
976 // if (void *X = foo()) { ... } else { X }.
977 // In the else block, the pointer is always false.
978
979 // FIXME: In a template instantiation, we don't have scope
980 // information to check this property.
981 if (Var->isDeclaredInCondition() && Var->getType()->isScalarType()) {
982 Scope *CheckS = S;
983 while (CheckS) {
984 if (CheckS->isWithinElse() &&
985 CheckS->getControlParent()->isDeclScope(DeclPtrTy::make(Var))) {
986 if (Var->getType()->isBooleanType())
987 ExprError(Diag(Loc, diag::warn_value_always_false)
988 << Var->getDeclName());
989 else
990 ExprError(Diag(Loc, diag::warn_value_always_zero)
991 << Var->getDeclName());
992 break;
993 }
994
995 // Move up one more control parent to check again.
996 CheckS = CheckS->getControlParent();
997 if (CheckS)
998 CheckS = CheckS->getParent();
999 }
1000 }
1001 } else if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D)) {
1002 if (!getLangOptions().CPlusPlus && !Func->hasPrototype()) {
1003 // C99 DR 316 says that, if a function type comes from a
1004 // function definition (without a prototype), that type is only
1005 // used for checking compatibility. Therefore, when referencing
1006 // the function, we pretend that we don't have the full function
1007 // type.
1008 if (DiagnoseUseOfDecl(Func, Loc))
1009 return ExprError();
|
976
| 1010
|
| 1011 QualType T = Func->getType();
1012 QualType NoProtoType = T;
1013 if (const FunctionProtoType *Proto = T->getAsFunctionProtoType())
1014 NoProtoType = Context.getFunctionNoProtoType(Proto->getResultType());
1015 return BuildDeclRefExpr(Func, NoProtoType, Loc, false, false, SS);
1016 }
1017 }
1018
1019 return BuildDeclarationNameExpr(Loc, D, HasTrailingLParen, SS, isAddressOfOperand);
1020}
1021
1022/// \brief Complete semantic analysis for a reference to the given declaration.
1023Sema::OwningExprResult
1024Sema::BuildDeclarationNameExpr(SourceLocation Loc, NamedDecl *D,
1025 bool HasTrailingLParen,
1026 const CXXScopeSpec *SS,
1027 bool isAddressOfOperand) {
1028 assert(D && "Cannot refer to a NULL declaration");
1029 DeclarationName Name = D->getDeclName();
1030
|
977 // If this is an expression of the form &Class::member, don't build an
978 // implicit member ref, because we want a pointer to the member in general,
979 // not any specific instance's member.
980 if (isAddressOfOperand && SS && !SS->isEmpty() && !HasTrailingLParen) {
981 DeclContext *DC = computeDeclContext(*SS);
982 if (D && isa<CXXRecordDecl>(DC)) {
983 QualType DType;
984 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
985 DType = FD->getType().getNonReferenceType();
986 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
987 DType = Method->getType();
988 } else if (isa<OverloadedFunctionDecl>(D)) {
989 DType = Context.OverloadTy;
990 }
991 // Could be an inner type. That's diagnosed below, so ignore it here.
992 if (!DType.isNull()) {
993 // The pointer is type- and value-dependent if it points into something
994 // dependent.
995 bool Dependent = DC->isDependentContext();
996 return BuildDeclRefExpr(D, DType, Loc, Dependent, Dependent, SS);
997 }
998 }
999 }
1000
1001 // We may have found a field within an anonymous union or struct
1002 // (C++ [class.union]).
1003 if (FieldDecl *FD = dyn_cast<FieldDecl>(D))
1004 if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion())
1005 return BuildAnonymousStructUnionMemberReference(Loc, FD);
1006
1007 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
1008 if (!MD->isStatic()) {
1009 // C++ [class.mfct.nonstatic]p2:
1010 // [...] if name lookup (3.4.1) resolves the name in the
1011 // id-expression to a nonstatic nontype member of class X or of
1012 // a base class of X, the id-expression is transformed into a
1013 // class member access expression (5.2.5) using (*this) (9.3.2)
1014 // as the postfix-expression to the left of the '.' operator.
1015 DeclContext *Ctx = 0;
1016 QualType MemberType;
1017 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1018 Ctx = FD->getDeclContext();
1019 MemberType = FD->getType();
1020
1021 if (const ReferenceType *RefType = MemberType->getAsReferenceType())
1022 MemberType = RefType->getPointeeType();
1023 else if (!FD->isMutable()) {
1024 unsigned combinedQualifiers
1025 = MemberType.getCVRQualifiers() | MD->getTypeQualifiers();
1026 MemberType = MemberType.getQualifiedType(combinedQualifiers);
1027 }
1028 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
1029 if (!Method->isStatic()) {
1030 Ctx = Method->getParent();
1031 MemberType = Method->getType();
1032 }
1033 } else if (OverloadedFunctionDecl *Ovl
1034 = dyn_cast<OverloadedFunctionDecl>(D)) {
1035 for (OverloadedFunctionDecl::function_iterator
1036 Func = Ovl->function_begin(),
1037 FuncEnd = Ovl->function_end();
1038 Func != FuncEnd; ++Func) {
1039 if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(*Func))
1040 if (!DMethod->isStatic()) {
1041 Ctx = Ovl->getDeclContext();
1042 MemberType = Context.OverloadTy;
1043 break;
1044 }
1045 }
1046 }
1047
1048 if (Ctx && Ctx->isRecord()) {
1049 QualType CtxType = Context.getTagDeclType(cast<CXXRecordDecl>(Ctx));
1050 QualType ThisType = Context.getTagDeclType(MD->getParent());
1051 if ((Context.getCanonicalType(CtxType)
1052 == Context.getCanonicalType(ThisType)) ||
1053 IsDerivedFrom(ThisType, CtxType)) {
1054 // Build the implicit member access expression.
1055 Expr *This = new (Context) CXXThisExpr(SourceLocation(),
1056 MD->getThisType(Context));
1057 MarkDeclarationReferenced(Loc, D);
1058 return Owned(new (Context) MemberExpr(This, true, D,
1059 Loc, MemberType));
1060 }
1061 }
1062 }
1063 }
1064
1065 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1066 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
1067 if (MD->isStatic())
1068 // "invalid use of member 'x' in static member function"
1069 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
1070 << FD->getDeclName());
1071 }
1072
1073 // Any other ways we could have found the field in a well-formed
1074 // program would have been turned into implicit member expressions
1075 // above.
1076 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
1077 << FD->getDeclName());
1078 }
1079
1080 if (isa<TypedefDecl>(D))
1081 return ExprError(Diag(Loc, diag::err_unexpected_typedef) << Name);
1082 if (isa<ObjCInterfaceDecl>(D))
1083 return ExprError(Diag(Loc, diag::err_unexpected_interface) << Name);
1084 if (isa<NamespaceDecl>(D))
1085 return ExprError(Diag(Loc, diag::err_unexpected_namespace) << Name);
1086
1087 // Make the DeclRefExpr or BlockDeclRefExpr for the decl.
1088 if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D))
1089 return BuildDeclRefExpr(Ovl, Context.OverloadTy, Loc,
1090 false, false, SS);
1091 else if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
1092 return BuildDeclRefExpr(Template, Context.OverloadTy, Loc,
1093 false, false, SS);
1094 ValueDecl *VD = cast<ValueDecl>(D);
1095
1096 // Check whether this declaration can be used. Note that we suppress
1097 // this check when we're going to perform argument-dependent lookup
1098 // on this function name, because this might not be the function
1099 // that overload resolution actually selects.
| 1031 // If this is an expression of the form &Class::member, don't build an
1032 // implicit member ref, because we want a pointer to the member in general,
1033 // not any specific instance's member.
1034 if (isAddressOfOperand && SS && !SS->isEmpty() && !HasTrailingLParen) {
1035 DeclContext *DC = computeDeclContext(*SS);
1036 if (D && isa<CXXRecordDecl>(DC)) {
1037 QualType DType;
1038 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1039 DType = FD->getType().getNonReferenceType();
1040 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
1041 DType = Method->getType();
1042 } else if (isa<OverloadedFunctionDecl>(D)) {
1043 DType = Context.OverloadTy;
1044 }
1045 // Could be an inner type. That's diagnosed below, so ignore it here.
1046 if (!DType.isNull()) {
1047 // The pointer is type- and value-dependent if it points into something
1048 // dependent.
1049 bool Dependent = DC->isDependentContext();
1050 return BuildDeclRefExpr(D, DType, Loc, Dependent, Dependent, SS);
1051 }
1052 }
1053 }
1054
1055 // We may have found a field within an anonymous union or struct
1056 // (C++ [class.union]).
1057 if (FieldDecl *FD = dyn_cast<FieldDecl>(D))
1058 if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion())
1059 return BuildAnonymousStructUnionMemberReference(Loc, FD);
1060
1061 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
1062 if (!MD->isStatic()) {
1063 // C++ [class.mfct.nonstatic]p2:
1064 // [...] if name lookup (3.4.1) resolves the name in the
1065 // id-expression to a nonstatic nontype member of class X or of
1066 // a base class of X, the id-expression is transformed into a
1067 // class member access expression (5.2.5) using (*this) (9.3.2)
1068 // as the postfix-expression to the left of the '.' operator.
1069 DeclContext *Ctx = 0;
1070 QualType MemberType;
1071 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1072 Ctx = FD->getDeclContext();
1073 MemberType = FD->getType();
1074
1075 if (const ReferenceType *RefType = MemberType->getAsReferenceType())
1076 MemberType = RefType->getPointeeType();
1077 else if (!FD->isMutable()) {
1078 unsigned combinedQualifiers
1079 = MemberType.getCVRQualifiers() | MD->getTypeQualifiers();
1080 MemberType = MemberType.getQualifiedType(combinedQualifiers);
1081 }
1082 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
1083 if (!Method->isStatic()) {
1084 Ctx = Method->getParent();
1085 MemberType = Method->getType();
1086 }
1087 } else if (OverloadedFunctionDecl *Ovl
1088 = dyn_cast<OverloadedFunctionDecl>(D)) {
1089 for (OverloadedFunctionDecl::function_iterator
1090 Func = Ovl->function_begin(),
1091 FuncEnd = Ovl->function_end();
1092 Func != FuncEnd; ++Func) {
1093 if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(*Func))
1094 if (!DMethod->isStatic()) {
1095 Ctx = Ovl->getDeclContext();
1096 MemberType = Context.OverloadTy;
1097 break;
1098 }
1099 }
1100 }
1101
1102 if (Ctx && Ctx->isRecord()) {
1103 QualType CtxType = Context.getTagDeclType(cast<CXXRecordDecl>(Ctx));
1104 QualType ThisType = Context.getTagDeclType(MD->getParent());
1105 if ((Context.getCanonicalType(CtxType)
1106 == Context.getCanonicalType(ThisType)) ||
1107 IsDerivedFrom(ThisType, CtxType)) {
1108 // Build the implicit member access expression.
1109 Expr *This = new (Context) CXXThisExpr(SourceLocation(),
1110 MD->getThisType(Context));
1111 MarkDeclarationReferenced(Loc, D);
1112 return Owned(new (Context) MemberExpr(This, true, D,
1113 Loc, MemberType));
1114 }
1115 }
1116 }
1117 }
1118
1119 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1120 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) {
1121 if (MD->isStatic())
1122 // "invalid use of member 'x' in static member function"
1123 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method)
1124 << FD->getDeclName());
1125 }
1126
1127 // Any other ways we could have found the field in a well-formed
1128 // program would have been turned into implicit member expressions
1129 // above.
1130 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use)
1131 << FD->getDeclName());
1132 }
1133
1134 if (isa<TypedefDecl>(D))
1135 return ExprError(Diag(Loc, diag::err_unexpected_typedef) << Name);
1136 if (isa<ObjCInterfaceDecl>(D))
1137 return ExprError(Diag(Loc, diag::err_unexpected_interface) << Name);
1138 if (isa<NamespaceDecl>(D))
1139 return ExprError(Diag(Loc, diag::err_unexpected_namespace) << Name);
1140
1141 // Make the DeclRefExpr or BlockDeclRefExpr for the decl.
1142 if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D))
1143 return BuildDeclRefExpr(Ovl, Context.OverloadTy, Loc,
1144 false, false, SS);
1145 else if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D))
1146 return BuildDeclRefExpr(Template, Context.OverloadTy, Loc,
1147 false, false, SS);
1148 ValueDecl *VD = cast<ValueDecl>(D);
1149
1150 // Check whether this declaration can be used. Note that we suppress
1151 // this check when we're going to perform argument-dependent lookup
1152 // on this function name, because this might not be the function
1153 // that overload resolution actually selects.
|
| 1154 bool ADL = getLangOptions().CPlusPlus && (!SS || !SS->isSet()) &&
1155 HasTrailingLParen;
|
1100 if (!(ADL && isa<FunctionDecl>(VD)) && DiagnoseUseOfDecl(VD, Loc))
1101 return ExprError();
1102
| 1156 if (!(ADL && isa<FunctionDecl>(VD)) && DiagnoseUseOfDecl(VD, Loc))
1157 return ExprError();
1158
|
1103 if (VarDecl *Var = dyn_cast<VarDecl>(VD)) {
1104 // Warn about constructs like:
1105 // if (void *X = foo()) { ... } else { X }.
1106 // In the else block, the pointer is always false.
1107
1108 // FIXME: In a template instantiation, we don't have scope
1109 // information to check this property.
1110 if (Var->isDeclaredInCondition() && Var->getType()->isScalarType()) {
1111 Scope *CheckS = S;
1112 while (CheckS) {
1113 if (CheckS->isWithinElse() &&
1114 CheckS->getControlParent()->isDeclScope(DeclPtrTy::make(Var))) {
1115 if (Var->getType()->isBooleanType())
1116 ExprError(Diag(Loc, diag::warn_value_always_false)
1117 << Var->getDeclName());
1118 else
1119 ExprError(Diag(Loc, diag::warn_value_always_zero)
1120 << Var->getDeclName());
1121 break;
1122 }
1123
1124 // Move up one more control parent to check again.
1125 CheckS = CheckS->getControlParent();
1126 if (CheckS)
1127 CheckS = CheckS->getParent();
1128 }
1129 }
1130 } else if (FunctionDecl *Func = dyn_cast<FunctionDecl>(VD)) {
1131 if (!getLangOptions().CPlusPlus && !Func->hasPrototype()) {
1132 // C99 DR 316 says that, if a function type comes from a
1133 // function definition (without a prototype), that type is only
1134 // used for checking compatibility. Therefore, when referencing
1135 // the function, we pretend that we don't have the full function
1136 // type.
1137 QualType T = Func->getType();
1138 QualType NoProtoType = T;
1139 if (const FunctionProtoType *Proto = T->getAsFunctionProtoType())
1140 NoProtoType = Context.getFunctionNoProtoType(Proto->getResultType());
1141 return BuildDeclRefExpr(VD, NoProtoType, Loc, false, false, SS);
1142 }
1143 }
1144
| |
1145 // Only create DeclRefExpr's for valid Decl's.
1146 if (VD->isInvalidDecl())
1147 return ExprError();
1148
1149 // If the identifier reference is inside a block, and it refers to a value
1150 // that is outside the block, create a BlockDeclRefExpr instead of a
1151 // DeclRefExpr. This ensures the value is treated as a copy-in snapshot when
1152 // the block is formed.
1153 //
1154 // We do not do this for things like enum constants, global variables, etc,
1155 // as they do not get snapshotted.
1156 //
1157 if (CurBlock && ShouldSnapshotBlockValueReference(CurBlock, VD)) {
1158 MarkDeclarationReferenced(Loc, VD);
1159 QualType ExprTy = VD->getType().getNonReferenceType();
1160 // The BlocksAttr indicates the variable is bound by-reference.
| 1159 // Only create DeclRefExpr's for valid Decl's.
1160 if (VD->isInvalidDecl())
1161 return ExprError();
1162
1163 // If the identifier reference is inside a block, and it refers to a value
1164 // that is outside the block, create a BlockDeclRefExpr instead of a
1165 // DeclRefExpr. This ensures the value is treated as a copy-in snapshot when
1166 // the block is formed.
1167 //
1168 // We do not do this for things like enum constants, global variables, etc,
1169 // as they do not get snapshotted.
1170 //
1171 if (CurBlock && ShouldSnapshotBlockValueReference(CurBlock, VD)) {
1172 MarkDeclarationReferenced(Loc, VD);
1173 QualType ExprTy = VD->getType().getNonReferenceType();
1174 // The BlocksAttr indicates the variable is bound by-reference.
|
1161 if (VD->getAttr<BlocksAttr>(Context))
| 1175 if (VD->getAttr())
|
1162 return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, true));
1163 // This is to record that a 'const' was actually synthesize and added.
1164 bool constAdded = !ExprTy.isConstQualified();
1165 // Variable will be bound by-copy, make it const within the closure.
1166
1167 ExprTy.addConst();
1168 return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, false,
1169 constAdded));
1170 }
1171 // If this reference is not in a block or if the referenced variable is
1172 // within the block, create a normal DeclRefExpr.
1173
1174 bool TypeDependent = false;
1175 bool ValueDependent = false;
1176 if (getLangOptions().CPlusPlus) {
1177 // C++ [temp.dep.expr]p3:
1178 // An id-expression is type-dependent if it contains:
1179 // - an identifier that was declared with a dependent type,
1180 if (VD->getType()->isDependentType())
1181 TypeDependent = true;
1182 // - FIXME: a template-id that is dependent,
1183 // - a conversion-function-id that specifies a dependent type,
1184 else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
1185 Name.getCXXNameType()->isDependentType())
1186 TypeDependent = true;
1187 // - a nested-name-specifier that contains a class-name that
1188 // names a dependent type.
1189 else if (SS && !SS->isEmpty()) {
1190 for (DeclContext *DC = computeDeclContext(*SS);
1191 DC; DC = DC->getParent()) {
1192 // FIXME: could stop early at namespace scope.
1193 if (DC->isRecord()) {
1194 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1195 if (Context.getTypeDeclType(Record)->isDependentType()) {
1196 TypeDependent = true;
1197 break;
1198 }
1199 }
1200 }
1201 }
1202
1203 // C++ [temp.dep.constexpr]p2:
1204 //
1205 // An identifier is value-dependent if it is:
1206 // - a name declared with a dependent type,
1207 if (TypeDependent)
1208 ValueDependent = true;
1209 // - the name of a non-type template parameter,
1210 else if (isa<NonTypeTemplateParmDecl>(VD))
1211 ValueDependent = true;
1212 // - a constant with integral or enumeration type and is
1213 // initialized with an expression that is value-dependent
1214 else if (const VarDecl *Dcl = dyn_cast<VarDecl>(VD)) {
1215 if (Dcl->getType().getCVRQualifiers() == QualType::Const &&
1216 Dcl->getInit()) {
1217 ValueDependent = Dcl->getInit()->isValueDependent();
1218 }
1219 }
1220 }
1221
1222 return BuildDeclRefExpr(VD, VD->getType().getNonReferenceType(), Loc,
1223 TypeDependent, ValueDependent, SS);
1224}
1225
1226Sema::OwningExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc,
1227 tok::TokenKind Kind) {
1228 PredefinedExpr::IdentType IT;
1229
1230 switch (Kind) {
1231 default: assert(0 && "Unknown simple primary expr!");
1232 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
1233 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
1234 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
1235 }
1236
1237 // Pre-defined identifiers are of type char[x], where x is the length of the
1238 // string.
1239 unsigned Length;
1240 if (FunctionDecl *FD = getCurFunctionDecl())
1241 Length = FD->getIdentifier()->getLength();
1242 else if (ObjCMethodDecl *MD = getCurMethodDecl())
1243 Length = MD->getSynthesizedMethodSize();
1244 else {
1245 Diag(Loc, diag::ext_predef_outside_function);
1246 // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
1247 Length = IT == PredefinedExpr::PrettyFunction ? strlen("top level") : 0;
1248 }
1249
1250
1251 llvm::APInt LengthI(32, Length + 1);
1252 QualType ResTy = Context.CharTy.getQualifiedType(QualType::Const);
1253 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0);
1254 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT));
1255}
1256
1257Sema::OwningExprResult Sema::ActOnCharacterConstant(const Token &Tok) {
1258 llvm::SmallString<16> CharBuffer;
1259 CharBuffer.resize(Tok.getLength());
1260 const char *ThisTokBegin = &CharBuffer[0];
1261 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
1262
1263 CharLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
1264 Tok.getLocation(), PP);
1265 if (Literal.hadError())
1266 return ExprError();
1267
1268 QualType type = getLangOptions().CPlusPlus ? Context.CharTy : Context.IntTy;
1269
1270 return Owned(new (Context) CharacterLiteral(Literal.getValue(),
1271 Literal.isWide(),
1272 type, Tok.getLocation()));
1273}
1274
1275Action::OwningExprResult Sema::ActOnNumericConstant(const Token &Tok) {
1276 // Fast path for a single digit (which is quite common). A single digit
1277 // cannot have a trigraph, escaped newline, radix prefix, or type suffix.
1278 if (Tok.getLength() == 1) {
1279 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
1280 unsigned IntSize = Context.Target.getIntWidth();
1281 return Owned(new (Context) IntegerLiteral(llvm::APInt(IntSize, Val-'0'),
1282 Context.IntTy, Tok.getLocation()));
1283 }
1284
1285 llvm::SmallString<512> IntegerBuffer;
1286 // Add padding so that NumericLiteralParser can overread by one character.
1287 IntegerBuffer.resize(Tok.getLength()+1);
1288 const char *ThisTokBegin = &IntegerBuffer[0];
1289
1290 // Get the spelling of the token, which eliminates trigraphs, etc.
1291 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
1292
1293 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
1294 Tok.getLocation(), PP);
1295 if (Literal.hadError)
1296 return ExprError();
1297
1298 Expr *Res;
1299
1300 if (Literal.isFloatingLiteral()) {
1301 QualType Ty;
1302 if (Literal.isFloat)
1303 Ty = Context.FloatTy;
1304 else if (!Literal.isLong)
1305 Ty = Context.DoubleTy;
1306 else
1307 Ty = Context.LongDoubleTy;
1308
1309 const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty);
1310
1311 // isExact will be set by GetFloatValue().
1312 bool isExact = false;
| 1176 return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, true));
1177 // This is to record that a 'const' was actually synthesize and added.
1178 bool constAdded = !ExprTy.isConstQualified();
1179 // Variable will be bound by-copy, make it const within the closure.
1180
1181 ExprTy.addConst();
1182 return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, false,
1183 constAdded));
1184 }
1185 // If this reference is not in a block or if the referenced variable is
1186 // within the block, create a normal DeclRefExpr.
1187
1188 bool TypeDependent = false;
1189 bool ValueDependent = false;
1190 if (getLangOptions().CPlusPlus) {
1191 // C++ [temp.dep.expr]p3:
1192 // An id-expression is type-dependent if it contains:
1193 // - an identifier that was declared with a dependent type,
1194 if (VD->getType()->isDependentType())
1195 TypeDependent = true;
1196 // - FIXME: a template-id that is dependent,
1197 // - a conversion-function-id that specifies a dependent type,
1198 else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
1199 Name.getCXXNameType()->isDependentType())
1200 TypeDependent = true;
1201 // - a nested-name-specifier that contains a class-name that
1202 // names a dependent type.
1203 else if (SS && !SS->isEmpty()) {
1204 for (DeclContext *DC = computeDeclContext(*SS);
1205 DC; DC = DC->getParent()) {
1206 // FIXME: could stop early at namespace scope.
1207 if (DC->isRecord()) {
1208 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
1209 if (Context.getTypeDeclType(Record)->isDependentType()) {
1210 TypeDependent = true;
1211 break;
1212 }
1213 }
1214 }
1215 }
1216
1217 // C++ [temp.dep.constexpr]p2:
1218 //
1219 // An identifier is value-dependent if it is:
1220 // - a name declared with a dependent type,
1221 if (TypeDependent)
1222 ValueDependent = true;
1223 // - the name of a non-type template parameter,
1224 else if (isa<NonTypeTemplateParmDecl>(VD))
1225 ValueDependent = true;
1226 // - a constant with integral or enumeration type and is
1227 // initialized with an expression that is value-dependent
1228 else if (const VarDecl *Dcl = dyn_cast<VarDecl>(VD)) {
1229 if (Dcl->getType().getCVRQualifiers() == QualType::Const &&
1230 Dcl->getInit()) {
1231 ValueDependent = Dcl->getInit()->isValueDependent();
1232 }
1233 }
1234 }
1235
1236 return BuildDeclRefExpr(VD, VD->getType().getNonReferenceType(), Loc,
1237 TypeDependent, ValueDependent, SS);
1238}
1239
1240Sema::OwningExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc,
1241 tok::TokenKind Kind) {
1242 PredefinedExpr::IdentType IT;
1243
1244 switch (Kind) {
1245 default: assert(0 && "Unknown simple primary expr!");
1246 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
1247 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
1248 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
1249 }
1250
1251 // Pre-defined identifiers are of type char[x], where x is the length of the
1252 // string.
1253 unsigned Length;
1254 if (FunctionDecl *FD = getCurFunctionDecl())
1255 Length = FD->getIdentifier()->getLength();
1256 else if (ObjCMethodDecl *MD = getCurMethodDecl())
1257 Length = MD->getSynthesizedMethodSize();
1258 else {
1259 Diag(Loc, diag::ext_predef_outside_function);
1260 // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
1261 Length = IT == PredefinedExpr::PrettyFunction ? strlen("top level") : 0;
1262 }
1263
1264
1265 llvm::APInt LengthI(32, Length + 1);
1266 QualType ResTy = Context.CharTy.getQualifiedType(QualType::Const);
1267 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0);
1268 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT));
1269}
1270
1271Sema::OwningExprResult Sema::ActOnCharacterConstant(const Token &Tok) {
1272 llvm::SmallString<16> CharBuffer;
1273 CharBuffer.resize(Tok.getLength());
1274 const char *ThisTokBegin = &CharBuffer[0];
1275 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
1276
1277 CharLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
1278 Tok.getLocation(), PP);
1279 if (Literal.hadError())
1280 return ExprError();
1281
1282 QualType type = getLangOptions().CPlusPlus ? Context.CharTy : Context.IntTy;
1283
1284 return Owned(new (Context) CharacterLiteral(Literal.getValue(),
1285 Literal.isWide(),
1286 type, Tok.getLocation()));
1287}
1288
1289Action::OwningExprResult Sema::ActOnNumericConstant(const Token &Tok) {
1290 // Fast path for a single digit (which is quite common). A single digit
1291 // cannot have a trigraph, escaped newline, radix prefix, or type suffix.
1292 if (Tok.getLength() == 1) {
1293 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
1294 unsigned IntSize = Context.Target.getIntWidth();
1295 return Owned(new (Context) IntegerLiteral(llvm::APInt(IntSize, Val-'0'),
1296 Context.IntTy, Tok.getLocation()));
1297 }
1298
1299 llvm::SmallString<512> IntegerBuffer;
1300 // Add padding so that NumericLiteralParser can overread by one character.
1301 IntegerBuffer.resize(Tok.getLength()+1);
1302 const char *ThisTokBegin = &IntegerBuffer[0];
1303
1304 // Get the spelling of the token, which eliminates trigraphs, etc.
1305 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin);
1306
1307 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength,
1308 Tok.getLocation(), PP);
1309 if (Literal.hadError)
1310 return ExprError();
1311
1312 Expr *Res;
1313
1314 if (Literal.isFloatingLiteral()) {
1315 QualType Ty;
1316 if (Literal.isFloat)
1317 Ty = Context.FloatTy;
1318 else if (!Literal.isLong)
1319 Ty = Context.DoubleTy;
1320 else
1321 Ty = Context.LongDoubleTy;
1322
1323 const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty);
1324
1325 // isExact will be set by GetFloatValue().
1326 bool isExact = false;
|
1313 Res = new (Context) FloatingLiteral(Literal.GetFloatValue(Format, &isExact),
1314 &isExact, Ty, Tok.getLocation());
| 1327 llvm::APFloat Val = Literal.GetFloatValue(Format, &isExact);
1328 Res = new (Context) FloatingLiteral(Val, isExact, Ty, Tok.getLocation());
|
1315
1316 } else if (!Literal.isIntegerLiteral()) {
1317 return ExprError();
1318 } else {
1319 QualType Ty;
1320
1321 // long long is a C99 feature.
1322 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
1323 Literal.isLongLong)
1324 Diag(Tok.getLocation(), diag::ext_longlong);
1325
1326 // Get the value in the widest-possible width.
1327 llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0);
1328
1329 if (Literal.GetIntegerValue(ResultVal)) {
1330 // If this value didn't fit into uintmax_t, warn and force to ull.
1331 Diag(Tok.getLocation(), diag::warn_integer_too_large);
1332 Ty = Context.UnsignedLongLongTy;
1333 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
1334 "long long is not intmax_t?");
1335 } else {
1336 // If this value fits into a ULL, try to figure out what else it fits into
1337 // according to the rules of C99 6.4.4.1p5.
1338
1339 // Octal, Hexadecimal, and integers with a U suffix are allowed to
1340 // be an unsigned int.
1341 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
1342
1343 // Check from smallest to largest, picking the smallest type we can.
1344 unsigned Width = 0;
1345 if (!Literal.isLong && !Literal.isLongLong) {
1346 // Are int/unsigned possibilities?
1347 unsigned IntSize = Context.Target.getIntWidth();
1348
1349 // Does it fit in a unsigned int?
1350 if (ResultVal.isIntN(IntSize)) {
1351 // Does it fit in a signed int?
1352 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
1353 Ty = Context.IntTy;
1354 else if (AllowUnsigned)
1355 Ty = Context.UnsignedIntTy;
1356 Width = IntSize;
1357 }
1358 }
1359
1360 // Are long/unsigned long possibilities?
1361 if (Ty.isNull() && !Literal.isLongLong) {
1362 unsigned LongSize = Context.Target.getLongWidth();
1363
1364 // Does it fit in a unsigned long?
1365 if (ResultVal.isIntN(LongSize)) {
1366 // Does it fit in a signed long?
1367 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
1368 Ty = Context.LongTy;
1369 else if (AllowUnsigned)
1370 Ty = Context.UnsignedLongTy;
1371 Width = LongSize;
1372 }
1373 }
1374
1375 // Finally, check long long if needed.
1376 if (Ty.isNull()) {
1377 unsigned LongLongSize = Context.Target.getLongLongWidth();
1378
1379 // Does it fit in a unsigned long long?
1380 if (ResultVal.isIntN(LongLongSize)) {
1381 // Does it fit in a signed long long?
1382 if (!Literal.isUnsigned && ResultVal[LongLongSize-1] == 0)
1383 Ty = Context.LongLongTy;
1384 else if (AllowUnsigned)
1385 Ty = Context.UnsignedLongLongTy;
1386 Width = LongLongSize;
1387 }
1388 }
1389
1390 // If we still couldn't decide a type, we probably have something that
1391 // does not fit in a signed long long, but has no U suffix.
1392 if (Ty.isNull()) {
1393 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed);
1394 Ty = Context.UnsignedLongLongTy;
1395 Width = Context.Target.getLongLongWidth();
1396 }
1397
1398 if (ResultVal.getBitWidth() != Width)
1399 ResultVal.trunc(Width);
1400 }
1401 Res = new (Context) IntegerLiteral(ResultVal, Ty, Tok.getLocation());
1402 }
1403
1404 // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
1405 if (Literal.isImaginary)
1406 Res = new (Context) ImaginaryLiteral(Res,
1407 Context.getComplexType(Res->getType()));
1408
1409 return Owned(Res);
1410}
1411
1412Action::OwningExprResult Sema::ActOnParenExpr(SourceLocation L,
1413 SourceLocation R, ExprArg Val) {
1414 Expr *E = Val.takeAs<Expr>();
1415 assert((E != 0) && "ActOnParenExpr() missing expr");
1416 return Owned(new (Context) ParenExpr(L, R, E));
1417}
1418
1419/// The UsualUnaryConversions() function is *not* called by this routine.
1420/// See C99 6.3.2.1p[2-4] for more details.
1421bool Sema::CheckSizeOfAlignOfOperand(QualType exprType,
1422 SourceLocation OpLoc,
1423 const SourceRange &ExprRange,
1424 bool isSizeof) {
1425 if (exprType->isDependentType())
1426 return false;
1427
1428 // C99 6.5.3.4p1:
1429 if (isa<FunctionType>(exprType)) {
1430 // alignof(function) is allowed as an extension.
1431 if (isSizeof)
1432 Diag(OpLoc, diag::ext_sizeof_function_type) << ExprRange;
1433 return false;
1434 }
1435
1436 // Allow sizeof(void)/alignof(void) as an extension.
1437 if (exprType->isVoidType()) {
1438 Diag(OpLoc, diag::ext_sizeof_void_type)
1439 << (isSizeof ? "sizeof" : "__alignof") << ExprRange;
1440 return false;
1441 }
1442
1443 if (RequireCompleteType(OpLoc, exprType,
1444 isSizeof ? diag::err_sizeof_incomplete_type :
1445 diag::err_alignof_incomplete_type,
1446 ExprRange))
1447 return true;
1448
1449 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode.
1450 if (LangOpts.ObjCNonFragileABI && exprType->isObjCInterfaceType()) {
1451 Diag(OpLoc, diag::err_sizeof_nonfragile_interface)
1452 << exprType << isSizeof << ExprRange;
1453 return true;
1454 }
1455
1456 return false;
1457}
1458
1459bool Sema::CheckAlignOfExpr(Expr *E, SourceLocation OpLoc,
1460 const SourceRange &ExprRange) {
1461 E = E->IgnoreParens();
1462
1463 // alignof decl is always ok.
1464 if (isa<DeclRefExpr>(E))
1465 return false;
1466
1467 // Cannot know anything else if the expression is dependent.
1468 if (E->isTypeDependent())
1469 return false;
1470
1471 if (E->getBitField()) {
1472 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 1 << ExprRange;
1473 return true;
1474 }
1475
1476 // Alignment of a field access is always okay, so long as it isn't a
1477 // bit-field.
1478 if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
1479 if (dyn_cast<FieldDecl>(ME->getMemberDecl()))
1480 return false;
1481
1482 return CheckSizeOfAlignOfOperand(E->getType(), OpLoc, ExprRange, false);
1483}
1484
1485/// \brief Build a sizeof or alignof expression given a type operand.
1486Action::OwningExprResult
1487Sema::CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
1488 bool isSizeOf, SourceRange R) {
1489 if (T.isNull())
1490 return ExprError();
1491
1492 if (!T->isDependentType() &&
1493 CheckSizeOfAlignOfOperand(T, OpLoc, R, isSizeOf))
1494 return ExprError();
1495
1496 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
1497 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, T,
1498 Context.getSizeType(), OpLoc,
1499 R.getEnd()));
1500}
1501
1502/// \brief Build a sizeof or alignof expression given an expression
1503/// operand.
1504Action::OwningExprResult
1505Sema::CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
1506 bool isSizeOf, SourceRange R) {
1507 // Verify that the operand is valid.
1508 bool isInvalid = false;
1509 if (E->isTypeDependent()) {
1510 // Delay type-checking for type-dependent expressions.
1511 } else if (!isSizeOf) {
1512 isInvalid = CheckAlignOfExpr(E, OpLoc, R);
1513 } else if (E->getBitField()) { // C99 6.5.3.4p1.
1514 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 0;
1515 isInvalid = true;
1516 } else {
1517 isInvalid = CheckSizeOfAlignOfOperand(E->getType(), OpLoc, R, true);
1518 }
1519
1520 if (isInvalid)
1521 return ExprError();
1522
1523 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
1524 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, E,
1525 Context.getSizeType(), OpLoc,
1526 R.getEnd()));
1527}
1528
1529/// ActOnSizeOfAlignOfExpr - Handle @c sizeof(type) and @c sizeof @c expr and
1530/// the same for @c alignof and @c __alignof
1531/// Note that the ArgRange is invalid if isType is false.
1532Action::OwningExprResult
1533Sema::ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1534 void *TyOrEx, const SourceRange &ArgRange) {
1535 // If error parsing type, ignore.
1536 if (TyOrEx == 0) return ExprError();
1537
1538 if (isType) {
1539 QualType ArgTy = QualType::getFromOpaquePtr(TyOrEx);
1540 return CreateSizeOfAlignOfExpr(ArgTy, OpLoc, isSizeof, ArgRange);
1541 }
1542
1543 // Get the end location.
1544 Expr *ArgEx = (Expr *)TyOrEx;
1545 Action::OwningExprResult Result
1546 = CreateSizeOfAlignOfExpr(ArgEx, OpLoc, isSizeof, ArgEx->getSourceRange());
1547
1548 if (Result.isInvalid())
1549 DeleteExpr(ArgEx);
1550
1551 return move(Result);
1552}
1553
1554QualType Sema::CheckRealImagOperand(Expr *&V, SourceLocation Loc, bool isReal) {
1555 if (V->isTypeDependent())
1556 return Context.DependentTy;
1557
1558 // These operators return the element type of a complex type.
1559 if (const ComplexType *CT = V->getType()->getAsComplexType())
1560 return CT->getElementType();
1561
1562 // Otherwise they pass through real integer and floating point types here.
1563 if (V->getType()->isArithmeticType())
1564 return V->getType();
1565
1566 // Reject anything else.
1567 Diag(Loc, diag::err_realimag_invalid_type) << V->getType()
1568 << (isReal ? "__real" : "__imag");
1569 return QualType();
1570}
1571
1572
1573
1574Action::OwningExprResult
1575Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1576 tok::TokenKind Kind, ExprArg Input) {
1577 Expr *Arg = (Expr *)Input.get();
1578
1579 UnaryOperator::Opcode Opc;
1580 switch (Kind) {
1581 default: assert(0 && "Unknown unary op!");
1582 case tok::plusplus: Opc = UnaryOperator::PostInc; break;
1583 case tok::minusminus: Opc = UnaryOperator::PostDec; break;
1584 }
1585
1586 if (getLangOptions().CPlusPlus &&
1587 (Arg->getType()->isRecordType() || Arg->getType()->isEnumeralType())) {
1588 // Which overloaded operator?
1589 OverloadedOperatorKind OverOp =
1590 (Opc == UnaryOperator::PostInc)? OO_PlusPlus : OO_MinusMinus;
1591
1592 // C++ [over.inc]p1:
1593 //
1594 // [...] If the function is a member function with one
1595 // parameter (which shall be of type int) or a non-member
1596 // function with two parameters (the second of which shall be
1597 // of type int), it defines the postfix increment operator ++
1598 // for objects of that type. When the postfix increment is
1599 // called as a result of using the ++ operator, the int
1600 // argument will have value zero.
1601 Expr *Args[2] = {
1602 Arg,
1603 new (Context) IntegerLiteral(llvm::APInt(Context.Target.getIntWidth(), 0,
1604 /*isSigned=*/true), Context.IntTy, SourceLocation())
1605 };
1606
1607 // Build the candidate set for overloading
1608 OverloadCandidateSet CandidateSet;
1609 AddOperatorCandidates(OverOp, S, OpLoc, Args, 2, CandidateSet);
1610
1611 // Perform overload resolution.
1612 OverloadCandidateSet::iterator Best;
1613 switch (BestViableFunction(CandidateSet, OpLoc, Best)) {
1614 case OR_Success: {
1615 // We found a built-in operator or an overloaded operator.
1616 FunctionDecl *FnDecl = Best->Function;
1617
1618 if (FnDecl) {
1619 // We matched an overloaded operator. Build a call to that
1620 // operator.
1621
1622 // Convert the arguments.
1623 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
1624 if (PerformObjectArgumentInitialization(Arg, Method))
1625 return ExprError();
1626 } else {
1627 // Convert the arguments.
1628 if (PerformCopyInitialization(Arg,
1629 FnDecl->getParamDecl(0)->getType(),
1630 "passing"))
1631 return ExprError();
1632 }
1633
1634 // Determine the result type
1635 QualType ResultTy
1636 = FnDecl->getType()->getAsFunctionType()->getResultType();
1637 ResultTy = ResultTy.getNonReferenceType();
1638
1639 // Build the actual expression node.
1640 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
1641 SourceLocation());
1642 UsualUnaryConversions(FnExpr);
1643
1644 Input.release();
1645 Args[0] = Arg;
1646 return Owned(new (Context) CXXOperatorCallExpr(Context, OverOp, FnExpr,
1647 Args, 2, ResultTy,
1648 OpLoc));
1649 } else {
1650 // We matched a built-in operator. Convert the arguments, then
1651 // break out so that we will build the appropriate built-in
1652 // operator node.
1653 if (PerformCopyInitialization(Arg, Best->BuiltinTypes.ParamTypes[0],
1654 "passing"))
1655 return ExprError();
1656
1657 break;
1658 }
1659 }
1660
1661 case OR_No_Viable_Function:
1662 // No viable function; fall through to handling this as a
1663 // built-in operator, which will produce an error message for us.
1664 break;
1665
1666 case OR_Ambiguous:
1667 Diag(OpLoc, diag::err_ovl_ambiguous_oper)
1668 << UnaryOperator::getOpcodeStr(Opc)
1669 << Arg->getSourceRange();
1670 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1671 return ExprError();
1672
1673 case OR_Deleted:
1674 Diag(OpLoc, diag::err_ovl_deleted_oper)
1675 << Best->Function->isDeleted()
1676 << UnaryOperator::getOpcodeStr(Opc)
1677 << Arg->getSourceRange();
1678 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1679 return ExprError();
1680 }
1681
1682 // Either we found no viable overloaded operator or we matched a
1683 // built-in operator. In either case, fall through to trying to
1684 // build a built-in operation.
1685 }
1686
1687 QualType result = CheckIncrementDecrementOperand(Arg, OpLoc,
1688 Opc == UnaryOperator::PostInc);
1689 if (result.isNull())
1690 return ExprError();
1691 Input.release();
1692 return Owned(new (Context) UnaryOperator(Arg, Opc, result, OpLoc));
1693}
1694
1695Action::OwningExprResult
1696Sema::ActOnArraySubscriptExpr(Scope *S, ExprArg Base, SourceLocation LLoc,
1697 ExprArg Idx, SourceLocation RLoc) {
1698 Expr *LHSExp = static_cast<Expr*>(Base.get()),
1699 *RHSExp = static_cast<Expr*>(Idx.get());
1700
1701 if (getLangOptions().CPlusPlus &&
1702 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) {
1703 Base.release();
1704 Idx.release();
1705 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
1706 Context.DependentTy, RLoc));
1707 }
1708
1709 if (getLangOptions().CPlusPlus &&
1710 (LHSExp->getType()->isRecordType() ||
1711 LHSExp->getType()->isEnumeralType() ||
1712 RHSExp->getType()->isRecordType() ||
1713 RHSExp->getType()->isEnumeralType())) {
1714 // Add the appropriate overloaded operators (C++ [over.match.oper])
1715 // to the candidate set.
1716 OverloadCandidateSet CandidateSet;
1717 Expr *Args[2] = { LHSExp, RHSExp };
1718 AddOperatorCandidates(OO_Subscript, S, LLoc, Args, 2, CandidateSet,
1719 SourceRange(LLoc, RLoc));
1720
1721 // Perform overload resolution.
1722 OverloadCandidateSet::iterator Best;
1723 switch (BestViableFunction(CandidateSet, LLoc, Best)) {
1724 case OR_Success: {
1725 // We found a built-in operator or an overloaded operator.
1726 FunctionDecl *FnDecl = Best->Function;
1727
1728 if (FnDecl) {
1729 // We matched an overloaded operator. Build a call to that
1730 // operator.
1731
1732 // Convert the arguments.
1733 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
1734 if (PerformObjectArgumentInitialization(LHSExp, Method) ||
1735 PerformCopyInitialization(RHSExp,
1736 FnDecl->getParamDecl(0)->getType(),
1737 "passing"))
1738 return ExprError();
1739 } else {
1740 // Convert the arguments.
1741 if (PerformCopyInitialization(LHSExp,
1742 FnDecl->getParamDecl(0)->getType(),
1743 "passing") ||
1744 PerformCopyInitialization(RHSExp,
1745 FnDecl->getParamDecl(1)->getType(),
1746 "passing"))
1747 return ExprError();
1748 }
1749
1750 // Determine the result type
1751 QualType ResultTy
1752 = FnDecl->getType()->getAsFunctionType()->getResultType();
1753 ResultTy = ResultTy.getNonReferenceType();
1754
1755 // Build the actual expression node.
1756 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
1757 SourceLocation());
1758 UsualUnaryConversions(FnExpr);
1759
1760 Base.release();
1761 Idx.release();
1762 Args[0] = LHSExp;
1763 Args[1] = RHSExp;
1764 return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
1765 FnExpr, Args, 2,
1766 ResultTy, LLoc));
1767 } else {
1768 // We matched a built-in operator. Convert the arguments, then
1769 // break out so that we will build the appropriate built-in
1770 // operator node.
1771 if (PerformCopyInitialization(LHSExp, Best->BuiltinTypes.ParamTypes[0],
1772 "passing") ||
1773 PerformCopyInitialization(RHSExp, Best->BuiltinTypes.ParamTypes[1],
1774 "passing"))
1775 return ExprError();
1776
1777 break;
1778 }
1779 }
1780
1781 case OR_No_Viable_Function:
1782 // No viable function; fall through to handling this as a
1783 // built-in operator, which will produce an error message for us.
1784 break;
1785
1786 case OR_Ambiguous:
1787 Diag(LLoc, diag::err_ovl_ambiguous_oper)
1788 << "[]"
1789 << LHSExp->getSourceRange() << RHSExp->getSourceRange();
1790 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1791 return ExprError();
1792
1793 case OR_Deleted:
1794 Diag(LLoc, diag::err_ovl_deleted_oper)
1795 << Best->Function->isDeleted()
1796 << "[]"
1797 << LHSExp->getSourceRange() << RHSExp->getSourceRange();
1798 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1799 return ExprError();
1800 }
1801
1802 // Either we found no viable overloaded operator or we matched a
1803 // built-in operator. In either case, fall through to trying to
1804 // build a built-in operation.
1805 }
1806
1807 // Perform default conversions.
1808 DefaultFunctionArrayConversion(LHSExp);
1809 DefaultFunctionArrayConversion(RHSExp);
1810
1811 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
1812
1813 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
1814 // to the expression *((e1)+(e2)). This means the array "Base" may actually be
1815 // in the subscript position. As a result, we need to derive the array base
1816 // and index from the expression types.
1817 Expr *BaseExpr, *IndexExpr;
1818 QualType ResultType;
1819 if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
1820 BaseExpr = LHSExp;
1821 IndexExpr = RHSExp;
1822 ResultType = Context.DependentTy;
1823 } else if (const PointerType *PTy = LHSTy->getAsPointerType()) {
1824 BaseExpr = LHSExp;
1825 IndexExpr = RHSExp;
1826 ResultType = PTy->getPointeeType();
1827 } else if (const PointerType *PTy = RHSTy->getAsPointerType()) {
1828 // Handle the uncommon case of "123[Ptr]".
1829 BaseExpr = RHSExp;
1830 IndexExpr = LHSExp;
1831 ResultType = PTy->getPointeeType();
1832 } else if (const VectorType *VTy = LHSTy->getAsVectorType()) {
1833 BaseExpr = LHSExp; // vectors: V[123]
1834 IndexExpr = RHSExp;
1835
1836 // FIXME: need to deal with const...
1837 ResultType = VTy->getElementType();
1838 } else if (LHSTy->isArrayType()) {
1839 // If we see an array that wasn't promoted by
1840 // DefaultFunctionArrayConversion, it must be an array that
1841 // wasn't promoted because of the C90 rule that doesn't
1842 // allow promoting non-lvalue arrays. Warn, then
1843 // force the promotion here.
1844 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
1845 LHSExp->getSourceRange();
1846 ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy));
1847 LHSTy = LHSExp->getType();
1848
1849 BaseExpr = LHSExp;
1850 IndexExpr = RHSExp;
1851 ResultType = LHSTy->getAsPointerType()->getPointeeType();
1852 } else if (RHSTy->isArrayType()) {
1853 // Same as previous, except for 123[f().a] case
1854 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
1855 RHSExp->getSourceRange();
1856 ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy));
1857 RHSTy = RHSExp->getType();
1858
1859 BaseExpr = RHSExp;
1860 IndexExpr = LHSExp;
1861 ResultType = RHSTy->getAsPointerType()->getPointeeType();
1862 } else {
1863 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
1864 << LHSExp->getSourceRange() << RHSExp->getSourceRange());
1865 }
1866 // C99 6.5.2.1p1
1867 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
1868 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
1869 << IndexExpr->getSourceRange());
1870
1871 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
1872 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
1873 // type. Note that Functions are not objects, and that (in C99 parlance)
1874 // incomplete types are not object types.
1875 if (ResultType->isFunctionType()) {
1876 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type)
1877 << ResultType << BaseExpr->getSourceRange();
1878 return ExprError();
1879 }
1880
1881 if (!ResultType->isDependentType() &&
1882 RequireCompleteType(LLoc, ResultType, diag::err_subscript_incomplete_type,
1883 BaseExpr->getSourceRange()))
1884 return ExprError();
1885
1886 // Diagnose bad cases where we step over interface counts.
1887 if (ResultType->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
1888 Diag(LLoc, diag::err_subscript_nonfragile_interface)
1889 << ResultType << BaseExpr->getSourceRange();
1890 return ExprError();
1891 }
1892
1893 Base.release();
1894 Idx.release();
1895 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
1896 ResultType, RLoc));
1897}
1898
1899QualType Sema::
1900CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
1901 IdentifierInfo &CompName, SourceLocation CompLoc) {
1902 const ExtVectorType *vecType = baseType->getAsExtVectorType();
1903
1904 // The vector accessor can't exceed the number of elements.
1905 const char *compStr = CompName.getName();
1906
1907 // This flag determines whether or not the component is one of the four
1908 // special names that indicate a subset of exactly half the elements are
1909 // to be selected.
1910 bool HalvingSwizzle = false;
1911
1912 // This flag determines whether or not CompName has an 's' char prefix,
1913 // indicating that it is a string of hex values to be used as vector indices.
1914 bool HexSwizzle = *compStr == 's' || *compStr == 'S';
1915
1916 // Check that we've found one of the special components, or that the component
1917 // names must come from the same set.
1918 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
1919 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
1920 HalvingSwizzle = true;
1921 } else if (vecType->getPointAccessorIdx(*compStr) != -1) {
1922 do
1923 compStr++;
1924 while (*compStr && vecType->getPointAccessorIdx(*compStr) != -1);
1925 } else if (HexSwizzle || vecType->getNumericAccessorIdx(*compStr) != -1) {
1926 do
1927 compStr++;
1928 while (*compStr && vecType->getNumericAccessorIdx(*compStr) != -1);
1929 }
1930
1931 if (!HalvingSwizzle && *compStr) {
1932 // We didn't get to the end of the string. This means the component names
1933 // didn't come from the same set *or* we encountered an illegal name.
1934 Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
1935 << std::string(compStr,compStr+1) << SourceRange(CompLoc);
1936 return QualType();
1937 }
1938
1939 // Ensure no component accessor exceeds the width of the vector type it
1940 // operates on.
1941 if (!HalvingSwizzle) {
1942 compStr = CompName.getName();
1943
1944 if (HexSwizzle)
1945 compStr++;
1946
1947 while (*compStr) {
1948 if (!vecType->isAccessorWithinNumElements(*compStr++)) {
1949 Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
1950 << baseType << SourceRange(CompLoc);
1951 return QualType();
1952 }
1953 }
1954 }
1955
1956 // If this is a halving swizzle, verify that the base type has an even
1957 // number of elements.
1958 if (HalvingSwizzle && (vecType->getNumElements() & 1U)) {
1959 Diag(OpLoc, diag::err_ext_vector_component_requires_even)
1960 << baseType << SourceRange(CompLoc);
1961 return QualType();
1962 }
1963
1964 // The component accessor looks fine - now we need to compute the actual type.
1965 // The vector type is implied by the component accessor. For example,
1966 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
1967 // vec4.s0 is a float, vec4.s23 is a vec3, etc.
1968 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
1969 unsigned CompSize = HalvingSwizzle ? vecType->getNumElements() / 2
1970 : CompName.getLength();
1971 if (HexSwizzle)
1972 CompSize--;
1973
1974 if (CompSize == 1)
1975 return vecType->getElementType();
1976
1977 QualType VT = Context.getExtVectorType(vecType->getElementType(), CompSize);
1978 // Now look up the TypeDefDecl from the vector type. Without this,
1979 // diagostics look bad. We want extended vector types to appear built-in.
1980 for (unsigned i = 0, E = ExtVectorDecls.size(); i != E; ++i) {
1981 if (ExtVectorDecls[i]->getUnderlyingType() == VT)
1982 return Context.getTypedefType(ExtVectorDecls[i]);
1983 }
1984 return VT; // should never get here (a typedef type should always be found).
1985}
1986
1987static Decl *FindGetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
1988 IdentifierInfo &Member,
1989 const Selector &Sel,
1990 ASTContext &Context) {
1991
| 1329
1330 } else if (!Literal.isIntegerLiteral()) {
1331 return ExprError();
1332 } else {
1333 QualType Ty;
1334
1335 // long long is a C99 feature.
1336 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
1337 Literal.isLongLong)
1338 Diag(Tok.getLocation(), diag::ext_longlong);
1339
1340 // Get the value in the widest-possible width.
1341 llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0);
1342
1343 if (Literal.GetIntegerValue(ResultVal)) {
1344 // If this value didn't fit into uintmax_t, warn and force to ull.
1345 Diag(Tok.getLocation(), diag::warn_integer_too_large);
1346 Ty = Context.UnsignedLongLongTy;
1347 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
1348 "long long is not intmax_t?");
1349 } else {
1350 // If this value fits into a ULL, try to figure out what else it fits into
1351 // according to the rules of C99 6.4.4.1p5.
1352
1353 // Octal, Hexadecimal, and integers with a U suffix are allowed to
1354 // be an unsigned int.
1355 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
1356
1357 // Check from smallest to largest, picking the smallest type we can.
1358 unsigned Width = 0;
1359 if (!Literal.isLong && !Literal.isLongLong) {
1360 // Are int/unsigned possibilities?
1361 unsigned IntSize = Context.Target.getIntWidth();
1362
1363 // Does it fit in a unsigned int?
1364 if (ResultVal.isIntN(IntSize)) {
1365 // Does it fit in a signed int?
1366 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
1367 Ty = Context.IntTy;
1368 else if (AllowUnsigned)
1369 Ty = Context.UnsignedIntTy;
1370 Width = IntSize;
1371 }
1372 }
1373
1374 // Are long/unsigned long possibilities?
1375 if (Ty.isNull() && !Literal.isLongLong) {
1376 unsigned LongSize = Context.Target.getLongWidth();
1377
1378 // Does it fit in a unsigned long?
1379 if (ResultVal.isIntN(LongSize)) {
1380 // Does it fit in a signed long?
1381 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
1382 Ty = Context.LongTy;
1383 else if (AllowUnsigned)
1384 Ty = Context.UnsignedLongTy;
1385 Width = LongSize;
1386 }
1387 }
1388
1389 // Finally, check long long if needed.
1390 if (Ty.isNull()) {
1391 unsigned LongLongSize = Context.Target.getLongLongWidth();
1392
1393 // Does it fit in a unsigned long long?
1394 if (ResultVal.isIntN(LongLongSize)) {
1395 // Does it fit in a signed long long?
1396 if (!Literal.isUnsigned && ResultVal[LongLongSize-1] == 0)
1397 Ty = Context.LongLongTy;
1398 else if (AllowUnsigned)
1399 Ty = Context.UnsignedLongLongTy;
1400 Width = LongLongSize;
1401 }
1402 }
1403
1404 // If we still couldn't decide a type, we probably have something that
1405 // does not fit in a signed long long, but has no U suffix.
1406 if (Ty.isNull()) {
1407 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed);
1408 Ty = Context.UnsignedLongLongTy;
1409 Width = Context.Target.getLongLongWidth();
1410 }
1411
1412 if (ResultVal.getBitWidth() != Width)
1413 ResultVal.trunc(Width);
1414 }
1415 Res = new (Context) IntegerLiteral(ResultVal, Ty, Tok.getLocation());
1416 }
1417
1418 // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
1419 if (Literal.isImaginary)
1420 Res = new (Context) ImaginaryLiteral(Res,
1421 Context.getComplexType(Res->getType()));
1422
1423 return Owned(Res);
1424}
1425
1426Action::OwningExprResult Sema::ActOnParenExpr(SourceLocation L,
1427 SourceLocation R, ExprArg Val) {
1428 Expr *E = Val.takeAs<Expr>();
1429 assert((E != 0) && "ActOnParenExpr() missing expr");
1430 return Owned(new (Context) ParenExpr(L, R, E));
1431}
1432
1433/// The UsualUnaryConversions() function is *not* called by this routine.
1434/// See C99 6.3.2.1p[2-4] for more details.
1435bool Sema::CheckSizeOfAlignOfOperand(QualType exprType,
1436 SourceLocation OpLoc,
1437 const SourceRange &ExprRange,
1438 bool isSizeof) {
1439 if (exprType->isDependentType())
1440 return false;
1441
1442 // C99 6.5.3.4p1:
1443 if (isa<FunctionType>(exprType)) {
1444 // alignof(function) is allowed as an extension.
1445 if (isSizeof)
1446 Diag(OpLoc, diag::ext_sizeof_function_type) << ExprRange;
1447 return false;
1448 }
1449
1450 // Allow sizeof(void)/alignof(void) as an extension.
1451 if (exprType->isVoidType()) {
1452 Diag(OpLoc, diag::ext_sizeof_void_type)
1453 << (isSizeof ? "sizeof" : "__alignof") << ExprRange;
1454 return false;
1455 }
1456
1457 if (RequireCompleteType(OpLoc, exprType,
1458 isSizeof ? diag::err_sizeof_incomplete_type :
1459 diag::err_alignof_incomplete_type,
1460 ExprRange))
1461 return true;
1462
1463 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode.
1464 if (LangOpts.ObjCNonFragileABI && exprType->isObjCInterfaceType()) {
1465 Diag(OpLoc, diag::err_sizeof_nonfragile_interface)
1466 << exprType << isSizeof << ExprRange;
1467 return true;
1468 }
1469
1470 return false;
1471}
1472
1473bool Sema::CheckAlignOfExpr(Expr *E, SourceLocation OpLoc,
1474 const SourceRange &ExprRange) {
1475 E = E->IgnoreParens();
1476
1477 // alignof decl is always ok.
1478 if (isa<DeclRefExpr>(E))
1479 return false;
1480
1481 // Cannot know anything else if the expression is dependent.
1482 if (E->isTypeDependent())
1483 return false;
1484
1485 if (E->getBitField()) {
1486 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 1 << ExprRange;
1487 return true;
1488 }
1489
1490 // Alignment of a field access is always okay, so long as it isn't a
1491 // bit-field.
1492 if (MemberExpr *ME = dyn_cast<MemberExpr>(E))
1493 if (dyn_cast<FieldDecl>(ME->getMemberDecl()))
1494 return false;
1495
1496 return CheckSizeOfAlignOfOperand(E->getType(), OpLoc, ExprRange, false);
1497}
1498
1499/// \brief Build a sizeof or alignof expression given a type operand.
1500Action::OwningExprResult
1501Sema::CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
1502 bool isSizeOf, SourceRange R) {
1503 if (T.isNull())
1504 return ExprError();
1505
1506 if (!T->isDependentType() &&
1507 CheckSizeOfAlignOfOperand(T, OpLoc, R, isSizeOf))
1508 return ExprError();
1509
1510 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
1511 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, T,
1512 Context.getSizeType(), OpLoc,
1513 R.getEnd()));
1514}
1515
1516/// \brief Build a sizeof or alignof expression given an expression
1517/// operand.
1518Action::OwningExprResult
1519Sema::CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
1520 bool isSizeOf, SourceRange R) {
1521 // Verify that the operand is valid.
1522 bool isInvalid = false;
1523 if (E->isTypeDependent()) {
1524 // Delay type-checking for type-dependent expressions.
1525 } else if (!isSizeOf) {
1526 isInvalid = CheckAlignOfExpr(E, OpLoc, R);
1527 } else if (E->getBitField()) { // C99 6.5.3.4p1.
1528 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 0;
1529 isInvalid = true;
1530 } else {
1531 isInvalid = CheckSizeOfAlignOfOperand(E->getType(), OpLoc, R, true);
1532 }
1533
1534 if (isInvalid)
1535 return ExprError();
1536
1537 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
1538 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, E,
1539 Context.getSizeType(), OpLoc,
1540 R.getEnd()));
1541}
1542
1543/// ActOnSizeOfAlignOfExpr - Handle @c sizeof(type) and @c sizeof @c expr and
1544/// the same for @c alignof and @c __alignof
1545/// Note that the ArgRange is invalid if isType is false.
1546Action::OwningExprResult
1547Sema::ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1548 void *TyOrEx, const SourceRange &ArgRange) {
1549 // If error parsing type, ignore.
1550 if (TyOrEx == 0) return ExprError();
1551
1552 if (isType) {
1553 QualType ArgTy = QualType::getFromOpaquePtr(TyOrEx);
1554 return CreateSizeOfAlignOfExpr(ArgTy, OpLoc, isSizeof, ArgRange);
1555 }
1556
1557 // Get the end location.
1558 Expr *ArgEx = (Expr *)TyOrEx;
1559 Action::OwningExprResult Result
1560 = CreateSizeOfAlignOfExpr(ArgEx, OpLoc, isSizeof, ArgEx->getSourceRange());
1561
1562 if (Result.isInvalid())
1563 DeleteExpr(ArgEx);
1564
1565 return move(Result);
1566}
1567
1568QualType Sema::CheckRealImagOperand(Expr *&V, SourceLocation Loc, bool isReal) {
1569 if (V->isTypeDependent())
1570 return Context.DependentTy;
1571
1572 // These operators return the element type of a complex type.
1573 if (const ComplexType *CT = V->getType()->getAsComplexType())
1574 return CT->getElementType();
1575
1576 // Otherwise they pass through real integer and floating point types here.
1577 if (V->getType()->isArithmeticType())
1578 return V->getType();
1579
1580 // Reject anything else.
1581 Diag(Loc, diag::err_realimag_invalid_type) << V->getType()
1582 << (isReal ? "__real" : "__imag");
1583 return QualType();
1584}
1585
1586
1587
1588Action::OwningExprResult
1589Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1590 tok::TokenKind Kind, ExprArg Input) {
1591 Expr *Arg = (Expr *)Input.get();
1592
1593 UnaryOperator::Opcode Opc;
1594 switch (Kind) {
1595 default: assert(0 && "Unknown unary op!");
1596 case tok::plusplus: Opc = UnaryOperator::PostInc; break;
1597 case tok::minusminus: Opc = UnaryOperator::PostDec; break;
1598 }
1599
1600 if (getLangOptions().CPlusPlus &&
1601 (Arg->getType()->isRecordType() || Arg->getType()->isEnumeralType())) {
1602 // Which overloaded operator?
1603 OverloadedOperatorKind OverOp =
1604 (Opc == UnaryOperator::PostInc)? OO_PlusPlus : OO_MinusMinus;
1605
1606 // C++ [over.inc]p1:
1607 //
1608 // [...] If the function is a member function with one
1609 // parameter (which shall be of type int) or a non-member
1610 // function with two parameters (the second of which shall be
1611 // of type int), it defines the postfix increment operator ++
1612 // for objects of that type. When the postfix increment is
1613 // called as a result of using the ++ operator, the int
1614 // argument will have value zero.
1615 Expr *Args[2] = {
1616 Arg,
1617 new (Context) IntegerLiteral(llvm::APInt(Context.Target.getIntWidth(), 0,
1618 /*isSigned=*/true), Context.IntTy, SourceLocation())
1619 };
1620
1621 // Build the candidate set for overloading
1622 OverloadCandidateSet CandidateSet;
1623 AddOperatorCandidates(OverOp, S, OpLoc, Args, 2, CandidateSet);
1624
1625 // Perform overload resolution.
1626 OverloadCandidateSet::iterator Best;
1627 switch (BestViableFunction(CandidateSet, OpLoc, Best)) {
1628 case OR_Success: {
1629 // We found a built-in operator or an overloaded operator.
1630 FunctionDecl *FnDecl = Best->Function;
1631
1632 if (FnDecl) {
1633 // We matched an overloaded operator. Build a call to that
1634 // operator.
1635
1636 // Convert the arguments.
1637 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
1638 if (PerformObjectArgumentInitialization(Arg, Method))
1639 return ExprError();
1640 } else {
1641 // Convert the arguments.
1642 if (PerformCopyInitialization(Arg,
1643 FnDecl->getParamDecl(0)->getType(),
1644 "passing"))
1645 return ExprError();
1646 }
1647
1648 // Determine the result type
1649 QualType ResultTy
1650 = FnDecl->getType()->getAsFunctionType()->getResultType();
1651 ResultTy = ResultTy.getNonReferenceType();
1652
1653 // Build the actual expression node.
1654 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
1655 SourceLocation());
1656 UsualUnaryConversions(FnExpr);
1657
1658 Input.release();
1659 Args[0] = Arg;
1660 return Owned(new (Context) CXXOperatorCallExpr(Context, OverOp, FnExpr,
1661 Args, 2, ResultTy,
1662 OpLoc));
1663 } else {
1664 // We matched a built-in operator. Convert the arguments, then
1665 // break out so that we will build the appropriate built-in
1666 // operator node.
1667 if (PerformCopyInitialization(Arg, Best->BuiltinTypes.ParamTypes[0],
1668 "passing"))
1669 return ExprError();
1670
1671 break;
1672 }
1673 }
1674
1675 case OR_No_Viable_Function:
1676 // No viable function; fall through to handling this as a
1677 // built-in operator, which will produce an error message for us.
1678 break;
1679
1680 case OR_Ambiguous:
1681 Diag(OpLoc, diag::err_ovl_ambiguous_oper)
1682 << UnaryOperator::getOpcodeStr(Opc)
1683 << Arg->getSourceRange();
1684 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1685 return ExprError();
1686
1687 case OR_Deleted:
1688 Diag(OpLoc, diag::err_ovl_deleted_oper)
1689 << Best->Function->isDeleted()
1690 << UnaryOperator::getOpcodeStr(Opc)
1691 << Arg->getSourceRange();
1692 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1693 return ExprError();
1694 }
1695
1696 // Either we found no viable overloaded operator or we matched a
1697 // built-in operator. In either case, fall through to trying to
1698 // build a built-in operation.
1699 }
1700
1701 QualType result = CheckIncrementDecrementOperand(Arg, OpLoc,
1702 Opc == UnaryOperator::PostInc);
1703 if (result.isNull())
1704 return ExprError();
1705 Input.release();
1706 return Owned(new (Context) UnaryOperator(Arg, Opc, result, OpLoc));
1707}
1708
1709Action::OwningExprResult
1710Sema::ActOnArraySubscriptExpr(Scope *S, ExprArg Base, SourceLocation LLoc,
1711 ExprArg Idx, SourceLocation RLoc) {
1712 Expr *LHSExp = static_cast<Expr*>(Base.get()),
1713 *RHSExp = static_cast<Expr*>(Idx.get());
1714
1715 if (getLangOptions().CPlusPlus &&
1716 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) {
1717 Base.release();
1718 Idx.release();
1719 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
1720 Context.DependentTy, RLoc));
1721 }
1722
1723 if (getLangOptions().CPlusPlus &&
1724 (LHSExp->getType()->isRecordType() ||
1725 LHSExp->getType()->isEnumeralType() ||
1726 RHSExp->getType()->isRecordType() ||
1727 RHSExp->getType()->isEnumeralType())) {
1728 // Add the appropriate overloaded operators (C++ [over.match.oper])
1729 // to the candidate set.
1730 OverloadCandidateSet CandidateSet;
1731 Expr *Args[2] = { LHSExp, RHSExp };
1732 AddOperatorCandidates(OO_Subscript, S, LLoc, Args, 2, CandidateSet,
1733 SourceRange(LLoc, RLoc));
1734
1735 // Perform overload resolution.
1736 OverloadCandidateSet::iterator Best;
1737 switch (BestViableFunction(CandidateSet, LLoc, Best)) {
1738 case OR_Success: {
1739 // We found a built-in operator or an overloaded operator.
1740 FunctionDecl *FnDecl = Best->Function;
1741
1742 if (FnDecl) {
1743 // We matched an overloaded operator. Build a call to that
1744 // operator.
1745
1746 // Convert the arguments.
1747 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
1748 if (PerformObjectArgumentInitialization(LHSExp, Method) ||
1749 PerformCopyInitialization(RHSExp,
1750 FnDecl->getParamDecl(0)->getType(),
1751 "passing"))
1752 return ExprError();
1753 } else {
1754 // Convert the arguments.
1755 if (PerformCopyInitialization(LHSExp,
1756 FnDecl->getParamDecl(0)->getType(),
1757 "passing") ||
1758 PerformCopyInitialization(RHSExp,
1759 FnDecl->getParamDecl(1)->getType(),
1760 "passing"))
1761 return ExprError();
1762 }
1763
1764 // Determine the result type
1765 QualType ResultTy
1766 = FnDecl->getType()->getAsFunctionType()->getResultType();
1767 ResultTy = ResultTy.getNonReferenceType();
1768
1769 // Build the actual expression node.
1770 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(),
1771 SourceLocation());
1772 UsualUnaryConversions(FnExpr);
1773
1774 Base.release();
1775 Idx.release();
1776 Args[0] = LHSExp;
1777 Args[1] = RHSExp;
1778 return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript,
1779 FnExpr, Args, 2,
1780 ResultTy, LLoc));
1781 } else {
1782 // We matched a built-in operator. Convert the arguments, then
1783 // break out so that we will build the appropriate built-in
1784 // operator node.
1785 if (PerformCopyInitialization(LHSExp, Best->BuiltinTypes.ParamTypes[0],
1786 "passing") ||
1787 PerformCopyInitialization(RHSExp, Best->BuiltinTypes.ParamTypes[1],
1788 "passing"))
1789 return ExprError();
1790
1791 break;
1792 }
1793 }
1794
1795 case OR_No_Viable_Function:
1796 // No viable function; fall through to handling this as a
1797 // built-in operator, which will produce an error message for us.
1798 break;
1799
1800 case OR_Ambiguous:
1801 Diag(LLoc, diag::err_ovl_ambiguous_oper)
1802 << "[]"
1803 << LHSExp->getSourceRange() << RHSExp->getSourceRange();
1804 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1805 return ExprError();
1806
1807 case OR_Deleted:
1808 Diag(LLoc, diag::err_ovl_deleted_oper)
1809 << Best->Function->isDeleted()
1810 << "[]"
1811 << LHSExp->getSourceRange() << RHSExp->getSourceRange();
1812 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true);
1813 return ExprError();
1814 }
1815
1816 // Either we found no viable overloaded operator or we matched a
1817 // built-in operator. In either case, fall through to trying to
1818 // build a built-in operation.
1819 }
1820
1821 // Perform default conversions.
1822 DefaultFunctionArrayConversion(LHSExp);
1823 DefaultFunctionArrayConversion(RHSExp);
1824
1825 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
1826
1827 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
1828 // to the expression *((e1)+(e2)). This means the array "Base" may actually be
1829 // in the subscript position. As a result, we need to derive the array base
1830 // and index from the expression types.
1831 Expr *BaseExpr, *IndexExpr;
1832 QualType ResultType;
1833 if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
1834 BaseExpr = LHSExp;
1835 IndexExpr = RHSExp;
1836 ResultType = Context.DependentTy;
1837 } else if (const PointerType *PTy = LHSTy->getAsPointerType()) {
1838 BaseExpr = LHSExp;
1839 IndexExpr = RHSExp;
1840 ResultType = PTy->getPointeeType();
1841 } else if (const PointerType *PTy = RHSTy->getAsPointerType()) {
1842 // Handle the uncommon case of "123[Ptr]".
1843 BaseExpr = RHSExp;
1844 IndexExpr = LHSExp;
1845 ResultType = PTy->getPointeeType();
1846 } else if (const VectorType *VTy = LHSTy->getAsVectorType()) {
1847 BaseExpr = LHSExp; // vectors: V[123]
1848 IndexExpr = RHSExp;
1849
1850 // FIXME: need to deal with const...
1851 ResultType = VTy->getElementType();
1852 } else if (LHSTy->isArrayType()) {
1853 // If we see an array that wasn't promoted by
1854 // DefaultFunctionArrayConversion, it must be an array that
1855 // wasn't promoted because of the C90 rule that doesn't
1856 // allow promoting non-lvalue arrays. Warn, then
1857 // force the promotion here.
1858 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
1859 LHSExp->getSourceRange();
1860 ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy));
1861 LHSTy = LHSExp->getType();
1862
1863 BaseExpr = LHSExp;
1864 IndexExpr = RHSExp;
1865 ResultType = LHSTy->getAsPointerType()->getPointeeType();
1866 } else if (RHSTy->isArrayType()) {
1867 // Same as previous, except for 123[f().a] case
1868 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
1869 RHSExp->getSourceRange();
1870 ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy));
1871 RHSTy = RHSExp->getType();
1872
1873 BaseExpr = RHSExp;
1874 IndexExpr = LHSExp;
1875 ResultType = RHSTy->getAsPointerType()->getPointeeType();
1876 } else {
1877 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
1878 << LHSExp->getSourceRange() << RHSExp->getSourceRange());
1879 }
1880 // C99 6.5.2.1p1
1881 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
1882 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
1883 << IndexExpr->getSourceRange());
1884
1885 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
1886 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
1887 // type. Note that Functions are not objects, and that (in C99 parlance)
1888 // incomplete types are not object types.
1889 if (ResultType->isFunctionType()) {
1890 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type)
1891 << ResultType << BaseExpr->getSourceRange();
1892 return ExprError();
1893 }
1894
1895 if (!ResultType->isDependentType() &&
1896 RequireCompleteType(LLoc, ResultType, diag::err_subscript_incomplete_type,
1897 BaseExpr->getSourceRange()))
1898 return ExprError();
1899
1900 // Diagnose bad cases where we step over interface counts.
1901 if (ResultType->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
1902 Diag(LLoc, diag::err_subscript_nonfragile_interface)
1903 << ResultType << BaseExpr->getSourceRange();
1904 return ExprError();
1905 }
1906
1907 Base.release();
1908 Idx.release();
1909 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
1910 ResultType, RLoc));
1911}
1912
1913QualType Sema::
1914CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
1915 IdentifierInfo &CompName, SourceLocation CompLoc) {
1916 const ExtVectorType *vecType = baseType->getAsExtVectorType();
1917
1918 // The vector accessor can't exceed the number of elements.
1919 const char *compStr = CompName.getName();
1920
1921 // This flag determines whether or not the component is one of the four
1922 // special names that indicate a subset of exactly half the elements are
1923 // to be selected.
1924 bool HalvingSwizzle = false;
1925
1926 // This flag determines whether or not CompName has an 's' char prefix,
1927 // indicating that it is a string of hex values to be used as vector indices.
1928 bool HexSwizzle = *compStr == 's' || *compStr == 'S';
1929
1930 // Check that we've found one of the special components, or that the component
1931 // names must come from the same set.
1932 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
1933 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
1934 HalvingSwizzle = true;
1935 } else if (vecType->getPointAccessorIdx(*compStr) != -1) {
1936 do
1937 compStr++;
1938 while (*compStr && vecType->getPointAccessorIdx(*compStr) != -1);
1939 } else if (HexSwizzle || vecType->getNumericAccessorIdx(*compStr) != -1) {
1940 do
1941 compStr++;
1942 while (*compStr && vecType->getNumericAccessorIdx(*compStr) != -1);
1943 }
1944
1945 if (!HalvingSwizzle && *compStr) {
1946 // We didn't get to the end of the string. This means the component names
1947 // didn't come from the same set *or* we encountered an illegal name.
1948 Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
1949 << std::string(compStr,compStr+1) << SourceRange(CompLoc);
1950 return QualType();
1951 }
1952
1953 // Ensure no component accessor exceeds the width of the vector type it
1954 // operates on.
1955 if (!HalvingSwizzle) {
1956 compStr = CompName.getName();
1957
1958 if (HexSwizzle)
1959 compStr++;
1960
1961 while (*compStr) {
1962 if (!vecType->isAccessorWithinNumElements(*compStr++)) {
1963 Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
1964 << baseType << SourceRange(CompLoc);
1965 return QualType();
1966 }
1967 }
1968 }
1969
1970 // If this is a halving swizzle, verify that the base type has an even
1971 // number of elements.
1972 if (HalvingSwizzle && (vecType->getNumElements() & 1U)) {
1973 Diag(OpLoc, diag::err_ext_vector_component_requires_even)
1974 << baseType << SourceRange(CompLoc);
1975 return QualType();
1976 }
1977
1978 // The component accessor looks fine - now we need to compute the actual type.
1979 // The vector type is implied by the component accessor. For example,
1980 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
1981 // vec4.s0 is a float, vec4.s23 is a vec3, etc.
1982 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
1983 unsigned CompSize = HalvingSwizzle ? vecType->getNumElements() / 2
1984 : CompName.getLength();
1985 if (HexSwizzle)
1986 CompSize--;
1987
1988 if (CompSize == 1)
1989 return vecType->getElementType();
1990
1991 QualType VT = Context.getExtVectorType(vecType->getElementType(), CompSize);
1992 // Now look up the TypeDefDecl from the vector type. Without this,
1993 // diagostics look bad. We want extended vector types to appear built-in.
1994 for (unsigned i = 0, E = ExtVectorDecls.size(); i != E; ++i) {
1995 if (ExtVectorDecls[i]->getUnderlyingType() == VT)
1996 return Context.getTypedefType(ExtVectorDecls[i]);
1997 }
1998 return VT; // should never get here (a typedef type should always be found).
1999}
2000
2001static Decl *FindGetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
2002 IdentifierInfo &Member,
2003 const Selector &Sel,
2004 ASTContext &Context) {
2005
|
1992 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Context, &Member))
| 2006 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(&Member))
|
1993 return PD;
| 2007 return PD;
|
1994 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Context, Sel))
| 2008 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel))
|
1995 return OMD;
1996
1997 for (ObjCProtocolDecl::protocol_iterator I = PDecl->protocol_begin(),
1998 E = PDecl->protocol_end(); I != E; ++I) {
1999 if (Decl *D = FindGetterNameDeclFromProtocolList(*I, Member, Sel,
2000 Context))
2001 return D;
2002 }
2003 return 0;
2004}
2005
2006static Decl *FindGetterNameDecl(const ObjCObjectPointerType *QIdTy,
2007 IdentifierInfo &Member,
2008 const Selector &Sel,
2009 ASTContext &Context) {
2010 // Check protocols on qualified interfaces.
2011 Decl *GDecl = 0;
2012 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
2013 E = QIdTy->qual_end(); I != E; ++I) {
| 2009 return OMD;
2010
2011 for (ObjCProtocolDecl::protocol_iterator I = PDecl->protocol_begin(),
2012 E = PDecl->protocol_end(); I != E; ++I) {
2013 if (Decl *D = FindGetterNameDeclFromProtocolList(*I, Member, Sel,
2014 Context))
2015 return D;
2016 }
2017 return 0;
2018}
2019
2020static Decl *FindGetterNameDecl(const ObjCObjectPointerType *QIdTy,
2021 IdentifierInfo &Member,
2022 const Selector &Sel,
2023 ASTContext &Context) {
2024 // Check protocols on qualified interfaces.
2025 Decl *GDecl = 0;
2026 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
2027 E = QIdTy->qual_end(); I != E; ++I) {
|
2014 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Context, &Member)) {
| 2028 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(&Member)) {
|
2015 GDecl = PD;
2016 break;
2017 }
2018 // Also must look for a getter name which uses property syntax.
| 2029 GDecl = PD;
2030 break;
2031 }
2032 // Also must look for a getter name which uses property syntax.
|
2019 if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Context, Sel)) {
| 2033 if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Sel)) {
|
2020 GDecl = OMD;
2021 break;
2022 }
2023 }
2024 if (!GDecl) {
2025 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
2026 E = QIdTy->qual_end(); I != E; ++I) {
2027 // Search in the protocol-qualifier list of current protocol.
2028 GDecl = FindGetterNameDeclFromProtocolList(*I, Member, Sel, Context);
2029 if (GDecl)
2030 return GDecl;
2031 }
2032 }
2033 return GDecl;
2034}
2035
2036/// FindMethodInNestedImplementations - Look up a method in current and
2037/// all base class implementations.
2038///
2039ObjCMethodDecl *Sema::FindMethodInNestedImplementations(
2040 const ObjCInterfaceDecl *IFace,
2041 const Selector &Sel) {
2042 ObjCMethodDecl *Method = 0;
2043 if (ObjCImplementationDecl *ImpDecl
2044 = LookupObjCImplementation(IFace->getIdentifier()))
| 2034 GDecl = OMD;
2035 break;
2036 }
2037 }
2038 if (!GDecl) {
2039 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
2040 E = QIdTy->qual_end(); I != E; ++I) {
2041 // Search in the protocol-qualifier list of current protocol.
2042 GDecl = FindGetterNameDeclFromProtocolList(*I, Member, Sel, Context);
2043 if (GDecl)
2044 return GDecl;
2045 }
2046 }
2047 return GDecl;
2048}
2049
2050/// FindMethodInNestedImplementations - Look up a method in current and
2051/// all base class implementations.
2052///
2053ObjCMethodDecl *Sema::FindMethodInNestedImplementations(
2054 const ObjCInterfaceDecl *IFace,
2055 const Selector &Sel) {
2056 ObjCMethodDecl *Method = 0;
2057 if (ObjCImplementationDecl *ImpDecl
2058 = LookupObjCImplementation(IFace->getIdentifier()))
|
2045 Method = ImpDecl->getInstanceMethod(Context, Sel);
| 2059 Method = ImpDecl->getInstanceMethod(Sel);
|
2046
2047 if (!Method && IFace->getSuperClass())
2048 return FindMethodInNestedImplementations(IFace->getSuperClass(), Sel);
2049 return Method;
2050}
2051
2052Action::OwningExprResult
2053Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc,
2054 tok::TokenKind OpKind, SourceLocation MemberLoc,
2055 IdentifierInfo &Member,
2056 DeclPtrTy ObjCImpDecl) {
2057 Expr *BaseExpr = Base.takeAs<Expr>();
2058 assert(BaseExpr && "no record expression");
2059
2060 // Perform default conversions.
2061 DefaultFunctionArrayConversion(BaseExpr);
2062
2063 QualType BaseType = BaseExpr->getType();
2064 assert(!BaseType.isNull() && "no type for member expression");
2065
2066 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
2067 // must have pointer type, and the accessed type is the pointee.
2068 if (OpKind == tok::arrow) {
2069 if (BaseType->isDependentType())
2070 return Owned(new (Context) CXXUnresolvedMemberExpr(Context,
2071 BaseExpr, true,
2072 OpLoc,
2073 DeclarationName(&Member),
2074 MemberLoc));
2075 else if (const PointerType *PT = BaseType->getAsPointerType())
2076 BaseType = PT->getPointeeType();
2077 else if (getLangOptions().CPlusPlus && BaseType->isRecordType())
2078 return Owned(BuildOverloadedArrowExpr(S, BaseExpr, OpLoc,
2079 MemberLoc, Member));
2080 else
2081 return ExprError(Diag(MemberLoc,
2082 diag::err_typecheck_member_reference_arrow)
2083 << BaseType << BaseExpr->getSourceRange());
2084 } else {
2085 if (BaseType->isDependentType()) {
2086 // Require that the base type isn't a pointer type
2087 // (so we'll report an error for)
2088 // T* t;
2089 // t.f;
2090 //
2091 // In Obj-C++, however, the above expression is valid, since it could be
2092 // accessing the 'f' property if T is an Obj-C interface. The extra check
2093 // allows this, while still reporting an error if T is a struct pointer.
2094 const PointerType *PT = BaseType->getAsPointerType();
2095
2096 if (!PT || (getLangOptions().ObjC1 &&
2097 !PT->getPointeeType()->isRecordType()))
2098 return Owned(new (Context) CXXUnresolvedMemberExpr(Context,
2099 BaseExpr, false,
2100 OpLoc,
2101 DeclarationName(&Member),
2102 MemberLoc));
2103 }
2104 }
2105
2106 // Handle field access to simple records. This also handles access to fields
2107 // of the ObjC 'id' struct.
2108 if (const RecordType *RTy = BaseType->getAsRecordType()) {
2109 RecordDecl *RDecl = RTy->getDecl();
2110 if (RequireCompleteType(OpLoc, BaseType,
2111 diag::err_typecheck_incomplete_tag,
2112 BaseExpr->getSourceRange()))
2113 return ExprError();
2114
2115 // The record definition is complete, now make sure the member is valid.
2116 // FIXME: Qualified name lookup for C++ is a bit more complicated than this.
2117 LookupResult Result
2118 = LookupQualifiedName(RDecl, DeclarationName(&Member),
2119 LookupMemberName, false);
2120
2121 if (!Result)
2122 return ExprError(Diag(MemberLoc, diag::err_typecheck_no_member)
2123 << &Member << BaseExpr->getSourceRange());
2124 if (Result.isAmbiguous()) {
2125 DiagnoseAmbiguousLookup(Result, DeclarationName(&Member),
2126 MemberLoc, BaseExpr->getSourceRange());
2127 return ExprError();
2128 }
2129
2130 NamedDecl *MemberDecl = Result;
2131
2132 // If the decl being referenced had an error, return an error for this
2133 // sub-expr without emitting another error, in order to avoid cascading
2134 // error cases.
2135 if (MemberDecl->isInvalidDecl())
2136 return ExprError();
2137
2138 // Check the use of this field
2139 if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
2140 return ExprError();
2141
2142 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
2143 // We may have found a field within an anonymous union or struct
2144 // (C++ [class.union]).
2145 if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion())
2146 return BuildAnonymousStructUnionMemberReference(MemberLoc, FD,
2147 BaseExpr, OpLoc);
2148
2149 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
2150 // FIXME: Handle address space modifiers
2151 QualType MemberType = FD->getType();
2152 if (const ReferenceType *Ref = MemberType->getAsReferenceType())
2153 MemberType = Ref->getPointeeType();
2154 else {
2155 unsigned combinedQualifiers =
2156 MemberType.getCVRQualifiers() | BaseType.getCVRQualifiers();
2157 if (FD->isMutable())
2158 combinedQualifiers &= ~QualType::Const;
2159 MemberType = MemberType.getQualifiedType(combinedQualifiers);
2160 }
2161
2162 MarkDeclarationReferenced(MemberLoc, FD);
2163 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, FD,
2164 MemberLoc, MemberType));
2165 }
2166
2167 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
2168 MarkDeclarationReferenced(MemberLoc, MemberDecl);
2169 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2170 Var, MemberLoc,
2171 Var->getType().getNonReferenceType()));
2172 }
2173 if (FunctionDecl *MemberFn = dyn_cast<FunctionDecl>(MemberDecl)) {
2174 MarkDeclarationReferenced(MemberLoc, MemberDecl);
2175 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2176 MemberFn, MemberLoc,
2177 MemberFn->getType()));
2178 }
2179 if (OverloadedFunctionDecl *Ovl
2180 = dyn_cast<OverloadedFunctionDecl>(MemberDecl))
2181 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, Ovl,
2182 MemberLoc, Context.OverloadTy));
2183 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
2184 MarkDeclarationReferenced(MemberLoc, MemberDecl);
2185 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2186 Enum, MemberLoc, Enum->getType()));
2187 }
2188 if (isa<TypeDecl>(MemberDecl))
2189 return ExprError(Diag(MemberLoc,diag::err_typecheck_member_reference_type)
2190 << DeclarationName(&Member) << int(OpKind == tok::arrow));
2191
2192 // We found a declaration kind that we didn't expect. This is a
2193 // generic error message that tells the user that she can't refer
2194 // to this member with '.' or '->'.
2195 return ExprError(Diag(MemberLoc,
2196 diag::err_typecheck_member_reference_unknown)
2197 << DeclarationName(&Member) << int(OpKind == tok::arrow));
2198 }
2199
2200 // Handle access to Objective-C instance variables, such as "Obj->ivar" and
2201 // (*Obj).ivar.
2202 if (const ObjCInterfaceType *IFTy = BaseType->getAsObjCInterfaceType()) {
2203 ObjCInterfaceDecl *ClassDeclared;
| 2060
2061 if (!Method && IFace->getSuperClass())
2062 return FindMethodInNestedImplementations(IFace->getSuperClass(), Sel);
2063 return Method;
2064}
2065
2066Action::OwningExprResult
2067Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc,
2068 tok::TokenKind OpKind, SourceLocation MemberLoc,
2069 IdentifierInfo &Member,
2070 DeclPtrTy ObjCImpDecl) {
2071 Expr *BaseExpr = Base.takeAs<Expr>();
2072 assert(BaseExpr && "no record expression");
2073
2074 // Perform default conversions.
2075 DefaultFunctionArrayConversion(BaseExpr);
2076
2077 QualType BaseType = BaseExpr->getType();
2078 assert(!BaseType.isNull() && "no type for member expression");
2079
2080 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
2081 // must have pointer type, and the accessed type is the pointee.
2082 if (OpKind == tok::arrow) {
2083 if (BaseType->isDependentType())
2084 return Owned(new (Context) CXXUnresolvedMemberExpr(Context,
2085 BaseExpr, true,
2086 OpLoc,
2087 DeclarationName(&Member),
2088 MemberLoc));
2089 else if (const PointerType *PT = BaseType->getAsPointerType())
2090 BaseType = PT->getPointeeType();
2091 else if (getLangOptions().CPlusPlus && BaseType->isRecordType())
2092 return Owned(BuildOverloadedArrowExpr(S, BaseExpr, OpLoc,
2093 MemberLoc, Member));
2094 else
2095 return ExprError(Diag(MemberLoc,
2096 diag::err_typecheck_member_reference_arrow)
2097 << BaseType << BaseExpr->getSourceRange());
2098 } else {
2099 if (BaseType->isDependentType()) {
2100 // Require that the base type isn't a pointer type
2101 // (so we'll report an error for)
2102 // T* t;
2103 // t.f;
2104 //
2105 // In Obj-C++, however, the above expression is valid, since it could be
2106 // accessing the 'f' property if T is an Obj-C interface. The extra check
2107 // allows this, while still reporting an error if T is a struct pointer.
2108 const PointerType *PT = BaseType->getAsPointerType();
2109
2110 if (!PT || (getLangOptions().ObjC1 &&
2111 !PT->getPointeeType()->isRecordType()))
2112 return Owned(new (Context) CXXUnresolvedMemberExpr(Context,
2113 BaseExpr, false,
2114 OpLoc,
2115 DeclarationName(&Member),
2116 MemberLoc));
2117 }
2118 }
2119
2120 // Handle field access to simple records. This also handles access to fields
2121 // of the ObjC 'id' struct.
2122 if (const RecordType *RTy = BaseType->getAsRecordType()) {
2123 RecordDecl *RDecl = RTy->getDecl();
2124 if (RequireCompleteType(OpLoc, BaseType,
2125 diag::err_typecheck_incomplete_tag,
2126 BaseExpr->getSourceRange()))
2127 return ExprError();
2128
2129 // The record definition is complete, now make sure the member is valid.
2130 // FIXME: Qualified name lookup for C++ is a bit more complicated than this.
2131 LookupResult Result
2132 = LookupQualifiedName(RDecl, DeclarationName(&Member),
2133 LookupMemberName, false);
2134
2135 if (!Result)
2136 return ExprError(Diag(MemberLoc, diag::err_typecheck_no_member)
2137 << &Member << BaseExpr->getSourceRange());
2138 if (Result.isAmbiguous()) {
2139 DiagnoseAmbiguousLookup(Result, DeclarationName(&Member),
2140 MemberLoc, BaseExpr->getSourceRange());
2141 return ExprError();
2142 }
2143
2144 NamedDecl *MemberDecl = Result;
2145
2146 // If the decl being referenced had an error, return an error for this
2147 // sub-expr without emitting another error, in order to avoid cascading
2148 // error cases.
2149 if (MemberDecl->isInvalidDecl())
2150 return ExprError();
2151
2152 // Check the use of this field
2153 if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
2154 return ExprError();
2155
2156 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
2157 // We may have found a field within an anonymous union or struct
2158 // (C++ [class.union]).
2159 if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion())
2160 return BuildAnonymousStructUnionMemberReference(MemberLoc, FD,
2161 BaseExpr, OpLoc);
2162
2163 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
2164 // FIXME: Handle address space modifiers
2165 QualType MemberType = FD->getType();
2166 if (const ReferenceType *Ref = MemberType->getAsReferenceType())
2167 MemberType = Ref->getPointeeType();
2168 else {
2169 unsigned combinedQualifiers =
2170 MemberType.getCVRQualifiers() | BaseType.getCVRQualifiers();
2171 if (FD->isMutable())
2172 combinedQualifiers &= ~QualType::Const;
2173 MemberType = MemberType.getQualifiedType(combinedQualifiers);
2174 }
2175
2176 MarkDeclarationReferenced(MemberLoc, FD);
2177 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, FD,
2178 MemberLoc, MemberType));
2179 }
2180
2181 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
2182 MarkDeclarationReferenced(MemberLoc, MemberDecl);
2183 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2184 Var, MemberLoc,
2185 Var->getType().getNonReferenceType()));
2186 }
2187 if (FunctionDecl *MemberFn = dyn_cast<FunctionDecl>(MemberDecl)) {
2188 MarkDeclarationReferenced(MemberLoc, MemberDecl);
2189 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2190 MemberFn, MemberLoc,
2191 MemberFn->getType()));
2192 }
2193 if (OverloadedFunctionDecl *Ovl
2194 = dyn_cast<OverloadedFunctionDecl>(MemberDecl))
2195 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, Ovl,
2196 MemberLoc, Context.OverloadTy));
2197 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
2198 MarkDeclarationReferenced(MemberLoc, MemberDecl);
2199 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow,
2200 Enum, MemberLoc, Enum->getType()));
2201 }
2202 if (isa<TypeDecl>(MemberDecl))
2203 return ExprError(Diag(MemberLoc,diag::err_typecheck_member_reference_type)
2204 << DeclarationName(&Member) << int(OpKind == tok::arrow));
2205
2206 // We found a declaration kind that we didn't expect. This is a
2207 // generic error message that tells the user that she can't refer
2208 // to this member with '.' or '->'.
2209 return ExprError(Diag(MemberLoc,
2210 diag::err_typecheck_member_reference_unknown)
2211 << DeclarationName(&Member) << int(OpKind == tok::arrow));
2212 }
2213
2214 // Handle access to Objective-C instance variables, such as "Obj->ivar" and
2215 // (*Obj).ivar.
2216 if (const ObjCInterfaceType *IFTy = BaseType->getAsObjCInterfaceType()) {
2217 ObjCInterfaceDecl *ClassDeclared;
|
2204 if (ObjCIvarDecl *IV = IFTy->getDecl()->lookupInstanceVariable(Context,
2205 &Member,
| 2218 if (ObjCIvarDecl *IV = IFTy->getDecl()->lookupInstanceVariable(&Member,
|
2206 ClassDeclared)) {
2207 // If the decl being referenced had an error, return an error for this
2208 // sub-expr without emitting another error, in order to avoid cascading
2209 // error cases.
2210 if (IV->isInvalidDecl())
2211 return ExprError();
2212
2213 // Check whether we can reference this field.
2214 if (DiagnoseUseOfDecl(IV, MemberLoc))
2215 return ExprError();
2216 if (IV->getAccessControl() != ObjCIvarDecl::Public &&
2217 IV->getAccessControl() != ObjCIvarDecl::Package) {
2218 ObjCInterfaceDecl *ClassOfMethodDecl = 0;
2219 if (ObjCMethodDecl *MD = getCurMethodDecl())
2220 ClassOfMethodDecl = MD->getClassInterface();
2221 else if (ObjCImpDecl && getCurFunctionDecl()) {
2222 // Case of a c-function declared inside an objc implementation.
2223 // FIXME: For a c-style function nested inside an objc implementation
2224 // class, there is no implementation context available, so we pass
2225 // down the context as argument to this routine. Ideally, this context
2226 // need be passed down in the AST node and somehow calculated from the
2227 // AST for a function decl.
2228 Decl *ImplDecl = ObjCImpDecl.getAs<Decl>();
2229 if (ObjCImplementationDecl *IMPD =
2230 dyn_cast<ObjCImplementationDecl>(ImplDecl))
2231 ClassOfMethodDecl = IMPD->getClassInterface();
2232 else if (ObjCCategoryImplDecl* CatImplClass =
2233 dyn_cast<ObjCCategoryImplDecl>(ImplDecl))
2234 ClassOfMethodDecl = CatImplClass->getClassInterface();
2235 }
2236
2237 if (IV->getAccessControl() == ObjCIvarDecl::Private) {
2238 if (ClassDeclared != IFTy->getDecl() ||
2239 ClassOfMethodDecl != ClassDeclared)
2240 Diag(MemberLoc, diag::error_private_ivar_access) << IV->getDeclName();
2241 }
2242 // @protected
2243 else if (!IFTy->getDecl()->isSuperClassOf(ClassOfMethodDecl))
2244 Diag(MemberLoc, diag::error_protected_ivar_access) << IV->getDeclName();
2245 }
2246
2247 return Owned(new (Context) ObjCIvarRefExpr(IV, IV->getType(),
2248 MemberLoc, BaseExpr,
2249 OpKind == tok::arrow));
2250 }
2251 return ExprError(Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
2252 << IFTy->getDecl()->getDeclName() << &Member
2253 << BaseExpr->getSourceRange());
2254 }
2255
2256 // Handle Objective-C property access, which is "Obj.property" where Obj is a
2257 // pointer to a (potentially qualified) interface type.
2258 const PointerType *PTy;
2259 const ObjCInterfaceType *IFTy;
2260 if (OpKind == tok::period && (PTy = BaseType->getAsPointerType()) &&
2261 (IFTy = PTy->getPointeeType()->getAsObjCInterfaceType())) {
2262 ObjCInterfaceDecl *IFace = IFTy->getDecl();
2263
2264 // Search for a declared property first.
| 2219 ClassDeclared)) {
2220 // If the decl being referenced had an error, return an error for this
2221 // sub-expr without emitting another error, in order to avoid cascading
2222 // error cases.
2223 if (IV->isInvalidDecl())
2224 return ExprError();
2225
2226 // Check whether we can reference this field.
2227 if (DiagnoseUseOfDecl(IV, MemberLoc))
2228 return ExprError();
2229 if (IV->getAccessControl() != ObjCIvarDecl::Public &&
2230 IV->getAccessControl() != ObjCIvarDecl::Package) {
2231 ObjCInterfaceDecl *ClassOfMethodDecl = 0;
2232 if (ObjCMethodDecl *MD = getCurMethodDecl())
2233 ClassOfMethodDecl = MD->getClassInterface();
2234 else if (ObjCImpDecl && getCurFunctionDecl()) {
2235 // Case of a c-function declared inside an objc implementation.
2236 // FIXME: For a c-style function nested inside an objc implementation
2237 // class, there is no implementation context available, so we pass
2238 // down the context as argument to this routine. Ideally, this context
2239 // need be passed down in the AST node and somehow calculated from the
2240 // AST for a function decl.
2241 Decl *ImplDecl = ObjCImpDecl.getAs<Decl>();
2242 if (ObjCImplementationDecl *IMPD =
2243 dyn_cast<ObjCImplementationDecl>(ImplDecl))
2244 ClassOfMethodDecl = IMPD->getClassInterface();
2245 else if (ObjCCategoryImplDecl* CatImplClass =
2246 dyn_cast<ObjCCategoryImplDecl>(ImplDecl))
2247 ClassOfMethodDecl = CatImplClass->getClassInterface();
2248 }
2249
2250 if (IV->getAccessControl() == ObjCIvarDecl::Private) {
2251 if (ClassDeclared != IFTy->getDecl() ||
2252 ClassOfMethodDecl != ClassDeclared)
2253 Diag(MemberLoc, diag::error_private_ivar_access) << IV->getDeclName();
2254 }
2255 // @protected
2256 else if (!IFTy->getDecl()->isSuperClassOf(ClassOfMethodDecl))
2257 Diag(MemberLoc, diag::error_protected_ivar_access) << IV->getDeclName();
2258 }
2259
2260 return Owned(new (Context) ObjCIvarRefExpr(IV, IV->getType(),
2261 MemberLoc, BaseExpr,
2262 OpKind == tok::arrow));
2263 }
2264 return ExprError(Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
2265 << IFTy->getDecl()->getDeclName() << &Member
2266 << BaseExpr->getSourceRange());
2267 }
2268
2269 // Handle Objective-C property access, which is "Obj.property" where Obj is a
2270 // pointer to a (potentially qualified) interface type.
2271 const PointerType *PTy;
2272 const ObjCInterfaceType *IFTy;
2273 if (OpKind == tok::period && (PTy = BaseType->getAsPointerType()) &&
2274 (IFTy = PTy->getPointeeType()->getAsObjCInterfaceType())) {
2275 ObjCInterfaceDecl *IFace = IFTy->getDecl();
2276
2277 // Search for a declared property first.
|
2265 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Context,
2266 &Member)) {
| 2278 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(&Member)) {
|
2267 // Check whether we can reference this property.
2268 if (DiagnoseUseOfDecl(PD, MemberLoc))
2269 return ExprError();
2270 QualType ResTy = PD->getType();
2271 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
| 2279 // Check whether we can reference this property.
2280 if (DiagnoseUseOfDecl(PD, MemberLoc))
2281 return ExprError();
2282 QualType ResTy = PD->getType();
2283 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
|
2272 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Context, Sel);
| 2284 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
|
2273 if (DiagnosePropertyAccessorMismatch(PD, Getter, MemberLoc))
2274 ResTy = Getter->getResultType();
2275 return Owned(new (Context) ObjCPropertyRefExpr(PD, ResTy,
2276 MemberLoc, BaseExpr));
2277 }
2278
2279 // Check protocols on qualified interfaces.
2280 for (ObjCInterfaceType::qual_iterator I = IFTy->qual_begin(),
2281 E = IFTy->qual_end(); I != E; ++I)
| 2285 if (DiagnosePropertyAccessorMismatch(PD, Getter, MemberLoc))
2286 ResTy = Getter->getResultType();
2287 return Owned(new (Context) ObjCPropertyRefExpr(PD, ResTy,
2288 MemberLoc, BaseExpr));
2289 }
2290
2291 // Check protocols on qualified interfaces.
2292 for (ObjCInterfaceType::qual_iterator I = IFTy->qual_begin(),
2293 E = IFTy->qual_end(); I != E; ++I)
|
2282 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Context,
2283 &Member)) {
| 2294 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(&Member)) {
|
2284 // Check whether we can reference this property.
2285 if (DiagnoseUseOfDecl(PD, MemberLoc))
2286 return ExprError();
2287
2288 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
2289 MemberLoc, BaseExpr));
2290 }
2291
2292 // If that failed, look for an "implicit" property by seeing if the nullary
2293 // selector is implemented.
2294
2295 // FIXME: The logic for looking up nullary and unary selectors should be
2296 // shared with the code in ActOnInstanceMessage.
2297
2298 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
| 2295 // Check whether we can reference this property.
2296 if (DiagnoseUseOfDecl(PD, MemberLoc))
2297 return ExprError();
2298
2299 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
2300 MemberLoc, BaseExpr));
2301 }
2302
2303 // If that failed, look for an "implicit" property by seeing if the nullary
2304 // selector is implemented.
2305
2306 // FIXME: The logic for looking up nullary and unary selectors should be
2307 // shared with the code in ActOnInstanceMessage.
2308
2309 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
|
2299 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Context, Sel);
| 2310 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Sel);
|
2300
2301 // If this reference is in an @implementation, check for 'private' methods.
2302 if (!Getter)
2303 Getter = FindMethodInNestedImplementations(IFace, Sel);
2304
2305 // Look through local category implementations associated with the class.
2306 if (!Getter) {
2307 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Getter; i++) {
2308 if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
| 2311
2312 // If this reference is in an @implementation, check for 'private' methods.
2313 if (!Getter)
2314 Getter = FindMethodInNestedImplementations(IFace, Sel);
2315
2316 // Look through local category implementations associated with the class.
2317 if (!Getter) {
2318 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Getter; i++) {
2319 if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
|
2309 Getter = ObjCCategoryImpls[i]->getInstanceMethod(Context, Sel);
| 2320 Getter = ObjCCategoryImpls[i]->getInstanceMethod(Sel);
|
2310 }
2311 }
2312 if (Getter) {
2313 // Check if we can reference this property.
2314 if (DiagnoseUseOfDecl(Getter, MemberLoc))
2315 return ExprError();
2316 }
2317 // If we found a getter then this may be a valid dot-reference, we
2318 // will look for the matching setter, in case it is needed.
2319 Selector SetterSel =
2320 SelectorTable::constructSetterName(PP.getIdentifierTable(),
2321 PP.getSelectorTable(), &Member);
| 2321 }
2322 }
2323 if (Getter) {
2324 // Check if we can reference this property.
2325 if (DiagnoseUseOfDecl(Getter, MemberLoc))
2326 return ExprError();
2327 }
2328 // If we found a getter then this may be a valid dot-reference, we
2329 // will look for the matching setter, in case it is needed.
2330 Selector SetterSel =
2331 SelectorTable::constructSetterName(PP.getIdentifierTable(),
2332 PP.getSelectorTable(), &Member);
|
2322 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(Context, SetterSel);
| 2333 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(SetterSel);
|
2323 if (!Setter) {
2324 // If this reference is in an @implementation, also check for 'private'
2325 // methods.
2326 Setter = FindMethodInNestedImplementations(IFace, SetterSel);
2327 }
2328 // Look through local category implementations associated with the class.
2329 if (!Setter) {
2330 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) {
2331 if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
| 2334 if (!Setter) {
2335 // If this reference is in an @implementation, also check for 'private'
2336 // methods.
2337 Setter = FindMethodInNestedImplementations(IFace, SetterSel);
2338 }
2339 // Look through local category implementations associated with the class.
2340 if (!Setter) {
2341 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) {
2342 if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
|
2332 Setter = ObjCCategoryImpls[i]->getInstanceMethod(Context, SetterSel);
| 2343 Setter = ObjCCategoryImpls[i]->getInstanceMethod(SetterSel);
|
2333 }
2334 }
2335
2336 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2337 return ExprError();
2338
2339 if (Getter || Setter) {
2340 QualType PType;
2341
2342 if (Getter)
2343 PType = Getter->getResultType();
2344 else {
2345 for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(),
2346 E = Setter->param_end(); PI != E; ++PI)
2347 PType = (*PI)->getType();
2348 }
2349 // FIXME: we must check that the setter has property type.
2350 return Owned(new (Context) ObjCKVCRefExpr(Getter, PType,
2351 Setter, MemberLoc, BaseExpr));
2352 }
2353 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2354 << &Member << BaseType);
2355 }
2356 // Handle properties on qualified "id" protocols.
2357 const ObjCObjectPointerType *QIdTy;
2358 if (OpKind == tok::period && (QIdTy = BaseType->getAsObjCQualifiedIdType())) {
2359 // Check protocols on qualified interfaces.
2360 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
2361 if (Decl *PMDecl = FindGetterNameDecl(QIdTy, Member, Sel, Context)) {
2362 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
2363 // Check the use of this declaration
2364 if (DiagnoseUseOfDecl(PD, MemberLoc))
2365 return ExprError();
2366
2367 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
2368 MemberLoc, BaseExpr));
2369 }
2370 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
2371 // Check the use of this method.
2372 if (DiagnoseUseOfDecl(OMD, MemberLoc))
2373 return ExprError();
2374
2375 return Owned(new (Context) ObjCMessageExpr(BaseExpr, Sel,
2376 OMD->getResultType(),
2377 OMD, OpLoc, MemberLoc,
2378 NULL, 0));
2379 }
2380 }
2381
2382 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2383 << &Member << BaseType);
2384 }
2385 // Handle properties on ObjC 'Class' types.
2386 if (OpKind == tok::period && (BaseType == Context.getObjCClassType())) {
2387 // Also must look for a getter name which uses property syntax.
2388 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
2389 if (ObjCMethodDecl *MD = getCurMethodDecl()) {
2390 ObjCInterfaceDecl *IFace = MD->getClassInterface();
2391 ObjCMethodDecl *Getter;
2392 // FIXME: need to also look locally in the implementation.
| 2344 }
2345 }
2346
2347 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2348 return ExprError();
2349
2350 if (Getter || Setter) {
2351 QualType PType;
2352
2353 if (Getter)
2354 PType = Getter->getResultType();
2355 else {
2356 for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(),
2357 E = Setter->param_end(); PI != E; ++PI)
2358 PType = (*PI)->getType();
2359 }
2360 // FIXME: we must check that the setter has property type.
2361 return Owned(new (Context) ObjCKVCRefExpr(Getter, PType,
2362 Setter, MemberLoc, BaseExpr));
2363 }
2364 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2365 << &Member << BaseType);
2366 }
2367 // Handle properties on qualified "id" protocols.
2368 const ObjCObjectPointerType *QIdTy;
2369 if (OpKind == tok::period && (QIdTy = BaseType->getAsObjCQualifiedIdType())) {
2370 // Check protocols on qualified interfaces.
2371 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
2372 if (Decl *PMDecl = FindGetterNameDecl(QIdTy, Member, Sel, Context)) {
2373 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
2374 // Check the use of this declaration
2375 if (DiagnoseUseOfDecl(PD, MemberLoc))
2376 return ExprError();
2377
2378 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(),
2379 MemberLoc, BaseExpr));
2380 }
2381 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
2382 // Check the use of this method.
2383 if (DiagnoseUseOfDecl(OMD, MemberLoc))
2384 return ExprError();
2385
2386 return Owned(new (Context) ObjCMessageExpr(BaseExpr, Sel,
2387 OMD->getResultType(),
2388 OMD, OpLoc, MemberLoc,
2389 NULL, 0));
2390 }
2391 }
2392
2393 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2394 << &Member << BaseType);
2395 }
2396 // Handle properties on ObjC 'Class' types.
2397 if (OpKind == tok::period && (BaseType == Context.getObjCClassType())) {
2398 // Also must look for a getter name which uses property syntax.
2399 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member);
2400 if (ObjCMethodDecl *MD = getCurMethodDecl()) {
2401 ObjCInterfaceDecl *IFace = MD->getClassInterface();
2402 ObjCMethodDecl *Getter;
2403 // FIXME: need to also look locally in the implementation.
|
2393 if ((Getter = IFace->lookupClassMethod(Context, Sel))) {
| 2404 if ((Getter = IFace->lookupClassMethod(Sel))) {
|
2394 // Check the use of this method.
2395 if (DiagnoseUseOfDecl(Getter, MemberLoc))
2396 return ExprError();
2397 }
2398 // If we found a getter then this may be a valid dot-reference, we
2399 // will look for the matching setter, in case it is needed.
2400 Selector SetterSel =
2401 SelectorTable::constructSetterName(PP.getIdentifierTable(),
2402 PP.getSelectorTable(), &Member);
| 2405 // Check the use of this method.
2406 if (DiagnoseUseOfDecl(Getter, MemberLoc))
2407 return ExprError();
2408 }
2409 // If we found a getter then this may be a valid dot-reference, we
2410 // will look for the matching setter, in case it is needed.
2411 Selector SetterSel =
2412 SelectorTable::constructSetterName(PP.getIdentifierTable(),
2413 PP.getSelectorTable(), &Member);
|
2403 ObjCMethodDecl *Setter = IFace->lookupClassMethod(Context, SetterSel);
| 2414 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
|
2404 if (!Setter) {
2405 // If this reference is in an @implementation, also check for 'private'
2406 // methods.
2407 Setter = FindMethodInNestedImplementations(IFace, SetterSel);
2408 }
2409 // Look through local category implementations associated with the class.
2410 if (!Setter) {
2411 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) {
2412 if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
| 2415 if (!Setter) {
2416 // If this reference is in an @implementation, also check for 'private'
2417 // methods.
2418 Setter = FindMethodInNestedImplementations(IFace, SetterSel);
2419 }
2420 // Look through local category implementations associated with the class.
2421 if (!Setter) {
2422 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) {
2423 if (ObjCCategoryImpls[i]->getClassInterface() == IFace)
|
2413 Setter = ObjCCategoryImpls[i]->getClassMethod(Context, SetterSel);
| 2424 Setter = ObjCCategoryImpls[i]->getClassMethod(SetterSel);
|
2414 }
2415 }
2416
2417 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2418 return ExprError();
2419
2420 if (Getter || Setter) {
2421 QualType PType;
2422
2423 if (Getter)
2424 PType = Getter->getResultType();
2425 else {
2426 for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(),
2427 E = Setter->param_end(); PI != E; ++PI)
2428 PType = (*PI)->getType();
2429 }
2430 // FIXME: we must check that the setter has property type.
2431 return Owned(new (Context) ObjCKVCRefExpr(Getter, PType,
2432 Setter, MemberLoc, BaseExpr));
2433 }
2434 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2435 << &Member << BaseType);
2436 }
2437 }
2438
2439 // Handle 'field access' to vectors, such as 'V.xx'.
2440 if (BaseType->isExtVectorType()) {
2441 QualType ret = CheckExtVectorComponent(BaseType, OpLoc, Member, MemberLoc);
2442 if (ret.isNull())
2443 return ExprError();
2444 return Owned(new (Context) ExtVectorElementExpr(ret, BaseExpr, Member,
2445 MemberLoc));
2446 }
2447
2448 Diag(MemberLoc, diag::err_typecheck_member_reference_struct_union)
2449 << BaseType << BaseExpr->getSourceRange();
2450
2451 // If the user is trying to apply -> or . to a function or function
2452 // pointer, it's probably because they forgot parentheses to call
2453 // the function. Suggest the addition of those parentheses.
2454 if (BaseType == Context.OverloadTy ||
2455 BaseType->isFunctionType() ||
2456 (BaseType->isPointerType() &&
2457 BaseType->getAsPointerType()->isFunctionType())) {
2458 SourceLocation Loc = PP.getLocForEndOfToken(BaseExpr->getLocEnd());
2459 Diag(Loc, diag::note_member_reference_needs_call)
2460 << CodeModificationHint::CreateInsertion(Loc, "()");
2461 }
2462
2463 return ExprError();
2464}
2465
2466/// ConvertArgumentsForCall - Converts the arguments specified in
2467/// Args/NumArgs to the parameter types of the function FDecl with
2468/// function prototype Proto. Call is the call expression itself, and
2469/// Fn is the function expression. For a C++ member function, this
2470/// routine does not attempt to convert the object argument. Returns
2471/// true if the call is ill-formed.
2472bool
2473Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
2474 FunctionDecl *FDecl,
2475 const FunctionProtoType *Proto,
2476 Expr **Args, unsigned NumArgs,
2477 SourceLocation RParenLoc) {
2478 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
2479 // assignment, to the types of the corresponding parameter, ...
2480 unsigned NumArgsInProto = Proto->getNumArgs();
2481 unsigned NumArgsToCheck = NumArgs;
2482 bool Invalid = false;
2483
2484 // If too few arguments are available (and we don't have default
2485 // arguments for the remaining parameters), don't make the call.
2486 if (NumArgs < NumArgsInProto) {
2487 if (!FDecl || NumArgs < FDecl->getMinRequiredArguments())
2488 return Diag(RParenLoc, diag::err_typecheck_call_too_few_args)
2489 << Fn->getType()->isBlockPointerType() << Fn->getSourceRange();
2490 // Use default arguments for missing arguments
2491 NumArgsToCheck = NumArgsInProto;
2492 Call->setNumArgs(Context, NumArgsInProto);
2493 }
2494
2495 // If too many are passed and not variadic, error on the extras and drop
2496 // them.
2497 if (NumArgs > NumArgsInProto) {
2498 if (!Proto->isVariadic()) {
2499 Diag(Args[NumArgsInProto]->getLocStart(),
2500 diag::err_typecheck_call_too_many_args)
2501 << Fn->getType()->isBlockPointerType() << Fn->getSourceRange()
2502 << SourceRange(Args[NumArgsInProto]->getLocStart(),
2503 Args[NumArgs-1]->getLocEnd());
2504 // This deletes the extra arguments.
2505 Call->setNumArgs(Context, NumArgsInProto);
2506 Invalid = true;
2507 }
2508 NumArgsToCheck = NumArgsInProto;
2509 }
2510
2511 // Continue to check argument types (even if we have too few/many args).
2512 for (unsigned i = 0; i != NumArgsToCheck; i++) {
2513 QualType ProtoArgType = Proto->getArgType(i);
2514
2515 Expr *Arg;
2516 if (i < NumArgs) {
2517 Arg = Args[i];
2518
2519 if (RequireCompleteType(Arg->getSourceRange().getBegin(),
2520 ProtoArgType,
2521 diag::err_call_incomplete_argument,
2522 Arg->getSourceRange()))
2523 return true;
2524
2525 // Pass the argument.
2526 if (PerformCopyInitialization(Arg, ProtoArgType, "passing"))
2527 return true;
2528 } else {
2529 if (FDecl->getParamDecl(i)->hasUnparsedDefaultArg()) {
2530 Diag (Call->getSourceRange().getBegin(),
2531 diag::err_use_of_default_argument_to_function_declared_later) <<
2532 FDecl << cast<CXXRecordDecl>(FDecl->getDeclContext())->getDeclName();
2533 Diag(UnparsedDefaultArgLocs[FDecl->getParamDecl(i)],
2534 diag::note_default_argument_declared_here);
2535 } else {
2536 Expr *DefaultExpr = FDecl->getParamDecl(i)->getDefaultArg();
2537
2538 // If the default expression creates temporaries, we need to
2539 // push them to the current stack of expression temporaries so they'll
2540 // be properly destroyed.
2541 if (CXXExprWithTemporaries *E
2542 = dyn_cast_or_null<CXXExprWithTemporaries>(DefaultExpr)) {
2543 assert(!E->shouldDestroyTemporaries() &&
2544 "Can't destroy temporaries in a default argument expr!");
2545 for (unsigned I = 0, N = E->getNumTemporaries(); I != N; ++I)
2546 ExprTemporaries.push_back(E->getTemporary(I));
2547 }
2548 }
2549
2550 // We already type-checked the argument, so we know it works.
2551 Arg = new (Context) CXXDefaultArgExpr(FDecl->getParamDecl(i));
2552 }
2553
2554 QualType ArgType = Arg->getType();
2555
2556 Call->setArg(i, Arg);
2557 }
2558
2559 // If this is a variadic call, handle args passed through "...".
2560 if (Proto->isVariadic()) {
2561 VariadicCallType CallType = VariadicFunction;
2562 if (Fn->getType()->isBlockPointerType())
2563 CallType = VariadicBlock; // Block
2564 else if (isa<MemberExpr>(Fn))
2565 CallType = VariadicMethod;
2566
2567 // Promote the arguments (C99 6.5.2.2p7).
2568 for (unsigned i = NumArgsInProto; i != NumArgs; i++) {
2569 Expr *Arg = Args[i];
2570 Invalid |= DefaultVariadicArgumentPromotion(Arg, CallType);
2571 Call->setArg(i, Arg);
2572 }
2573 }
2574
2575 return Invalid;
2576}
2577
2578/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
2579/// This provides the location of the left/right parens and a list of comma
2580/// locations.
2581Action::OwningExprResult
2582Sema::ActOnCallExpr(Scope *S, ExprArg fn, SourceLocation LParenLoc,
2583 MultiExprArg args,
2584 SourceLocation *CommaLocs, SourceLocation RParenLoc) {
2585 unsigned NumArgs = args.size();
2586 Expr *Fn = fn.takeAs<Expr>();
2587 Expr **Args = reinterpret_cast<Expr**>(args.release());
2588 assert(Fn && "no function call expression");
2589 FunctionDecl *FDecl = NULL;
2590 NamedDecl *NDecl = NULL;
2591 DeclarationName UnqualifiedName;
2592
2593 if (getLangOptions().CPlusPlus) {
2594 // Determine whether this is a dependent call inside a C++ template,
2595 // in which case we won't do any semantic analysis now.
2596 // FIXME: Will need to cache the results of name lookup (including ADL) in
2597 // Fn.
2598 bool Dependent = false;
2599 if (Fn->isTypeDependent())
2600 Dependent = true;
2601 else if (Expr::hasAnyTypeDependentArguments(Args, NumArgs))
2602 Dependent = true;
2603
2604 if (Dependent)
2605 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs,
2606 Context.DependentTy, RParenLoc));
2607
2608 // Determine whether this is a call to an object (C++ [over.call.object]).
2609 if (Fn->getType()->isRecordType())
2610 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs,
2611 CommaLocs, RParenLoc));
2612
2613 // Determine whether this is a call to a member function.
2614 if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(Fn->IgnoreParens())) {
2615 NamedDecl *MemDecl = MemExpr->getMemberDecl();
2616 if (isa<OverloadedFunctionDecl>(MemDecl) ||
2617 isa<CXXMethodDecl>(MemDecl) ||
2618 (isa<FunctionTemplateDecl>(MemDecl) &&
2619 isa<CXXMethodDecl>(
2620 cast<FunctionTemplateDecl>(MemDecl)->getTemplatedDecl())))
2621 return Owned(BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs,
2622 CommaLocs, RParenLoc));
2623 }
2624 }
2625
2626 // If we're directly calling a function, get the appropriate declaration.
| 2425 }
2426 }
2427
2428 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
2429 return ExprError();
2430
2431 if (Getter || Setter) {
2432 QualType PType;
2433
2434 if (Getter)
2435 PType = Getter->getResultType();
2436 else {
2437 for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(),
2438 E = Setter->param_end(); PI != E; ++PI)
2439 PType = (*PI)->getType();
2440 }
2441 // FIXME: we must check that the setter has property type.
2442 return Owned(new (Context) ObjCKVCRefExpr(Getter, PType,
2443 Setter, MemberLoc, BaseExpr));
2444 }
2445 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
2446 << &Member << BaseType);
2447 }
2448 }
2449
2450 // Handle 'field access' to vectors, such as 'V.xx'.
2451 if (BaseType->isExtVectorType()) {
2452 QualType ret = CheckExtVectorComponent(BaseType, OpLoc, Member, MemberLoc);
2453 if (ret.isNull())
2454 return ExprError();
2455 return Owned(new (Context) ExtVectorElementExpr(ret, BaseExpr, Member,
2456 MemberLoc));
2457 }
2458
2459 Diag(MemberLoc, diag::err_typecheck_member_reference_struct_union)
2460 << BaseType << BaseExpr->getSourceRange();
2461
2462 // If the user is trying to apply -> or . to a function or function
2463 // pointer, it's probably because they forgot parentheses to call
2464 // the function. Suggest the addition of those parentheses.
2465 if (BaseType == Context.OverloadTy ||
2466 BaseType->isFunctionType() ||
2467 (BaseType->isPointerType() &&
2468 BaseType->getAsPointerType()->isFunctionType())) {
2469 SourceLocation Loc = PP.getLocForEndOfToken(BaseExpr->getLocEnd());
2470 Diag(Loc, diag::note_member_reference_needs_call)
2471 << CodeModificationHint::CreateInsertion(Loc, "()");
2472 }
2473
2474 return ExprError();
2475}
2476
2477/// ConvertArgumentsForCall - Converts the arguments specified in
2478/// Args/NumArgs to the parameter types of the function FDecl with
2479/// function prototype Proto. Call is the call expression itself, and
2480/// Fn is the function expression. For a C++ member function, this
2481/// routine does not attempt to convert the object argument. Returns
2482/// true if the call is ill-formed.
2483bool
2484Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
2485 FunctionDecl *FDecl,
2486 const FunctionProtoType *Proto,
2487 Expr **Args, unsigned NumArgs,
2488 SourceLocation RParenLoc) {
2489 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
2490 // assignment, to the types of the corresponding parameter, ...
2491 unsigned NumArgsInProto = Proto->getNumArgs();
2492 unsigned NumArgsToCheck = NumArgs;
2493 bool Invalid = false;
2494
2495 // If too few arguments are available (and we don't have default
2496 // arguments for the remaining parameters), don't make the call.
2497 if (NumArgs < NumArgsInProto) {
2498 if (!FDecl || NumArgs < FDecl->getMinRequiredArguments())
2499 return Diag(RParenLoc, diag::err_typecheck_call_too_few_args)
2500 << Fn->getType()->isBlockPointerType() << Fn->getSourceRange();
2501 // Use default arguments for missing arguments
2502 NumArgsToCheck = NumArgsInProto;
2503 Call->setNumArgs(Context, NumArgsInProto);
2504 }
2505
2506 // If too many are passed and not variadic, error on the extras and drop
2507 // them.
2508 if (NumArgs > NumArgsInProto) {
2509 if (!Proto->isVariadic()) {
2510 Diag(Args[NumArgsInProto]->getLocStart(),
2511 diag::err_typecheck_call_too_many_args)
2512 << Fn->getType()->isBlockPointerType() << Fn->getSourceRange()
2513 << SourceRange(Args[NumArgsInProto]->getLocStart(),
2514 Args[NumArgs-1]->getLocEnd());
2515 // This deletes the extra arguments.
2516 Call->setNumArgs(Context, NumArgsInProto);
2517 Invalid = true;
2518 }
2519 NumArgsToCheck = NumArgsInProto;
2520 }
2521
2522 // Continue to check argument types (even if we have too few/many args).
2523 for (unsigned i = 0; i != NumArgsToCheck; i++) {
2524 QualType ProtoArgType = Proto->getArgType(i);
2525
2526 Expr *Arg;
2527 if (i < NumArgs) {
2528 Arg = Args[i];
2529
2530 if (RequireCompleteType(Arg->getSourceRange().getBegin(),
2531 ProtoArgType,
2532 diag::err_call_incomplete_argument,
2533 Arg->getSourceRange()))
2534 return true;
2535
2536 // Pass the argument.
2537 if (PerformCopyInitialization(Arg, ProtoArgType, "passing"))
2538 return true;
2539 } else {
2540 if (FDecl->getParamDecl(i)->hasUnparsedDefaultArg()) {
2541 Diag (Call->getSourceRange().getBegin(),
2542 diag::err_use_of_default_argument_to_function_declared_later) <<
2543 FDecl << cast<CXXRecordDecl>(FDecl->getDeclContext())->getDeclName();
2544 Diag(UnparsedDefaultArgLocs[FDecl->getParamDecl(i)],
2545 diag::note_default_argument_declared_here);
2546 } else {
2547 Expr *DefaultExpr = FDecl->getParamDecl(i)->getDefaultArg();
2548
2549 // If the default expression creates temporaries, we need to
2550 // push them to the current stack of expression temporaries so they'll
2551 // be properly destroyed.
2552 if (CXXExprWithTemporaries *E
2553 = dyn_cast_or_null<CXXExprWithTemporaries>(DefaultExpr)) {
2554 assert(!E->shouldDestroyTemporaries() &&
2555 "Can't destroy temporaries in a default argument expr!");
2556 for (unsigned I = 0, N = E->getNumTemporaries(); I != N; ++I)
2557 ExprTemporaries.push_back(E->getTemporary(I));
2558 }
2559 }
2560
2561 // We already type-checked the argument, so we know it works.
2562 Arg = new (Context) CXXDefaultArgExpr(FDecl->getParamDecl(i));
2563 }
2564
2565 QualType ArgType = Arg->getType();
2566
2567 Call->setArg(i, Arg);
2568 }
2569
2570 // If this is a variadic call, handle args passed through "...".
2571 if (Proto->isVariadic()) {
2572 VariadicCallType CallType = VariadicFunction;
2573 if (Fn->getType()->isBlockPointerType())
2574 CallType = VariadicBlock; // Block
2575 else if (isa<MemberExpr>(Fn))
2576 CallType = VariadicMethod;
2577
2578 // Promote the arguments (C99 6.5.2.2p7).
2579 for (unsigned i = NumArgsInProto; i != NumArgs; i++) {
2580 Expr *Arg = Args[i];
2581 Invalid |= DefaultVariadicArgumentPromotion(Arg, CallType);
2582 Call->setArg(i, Arg);
2583 }
2584 }
2585
2586 return Invalid;
2587}
2588
2589/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
2590/// This provides the location of the left/right parens and a list of comma
2591/// locations.
2592Action::OwningExprResult
2593Sema::ActOnCallExpr(Scope *S, ExprArg fn, SourceLocation LParenLoc,
2594 MultiExprArg args,
2595 SourceLocation *CommaLocs, SourceLocation RParenLoc) {
2596 unsigned NumArgs = args.size();
2597 Expr *Fn = fn.takeAs<Expr>();
2598 Expr **Args = reinterpret_cast<Expr**>(args.release());
2599 assert(Fn && "no function call expression");
2600 FunctionDecl *FDecl = NULL;
2601 NamedDecl *NDecl = NULL;
2602 DeclarationName UnqualifiedName;
2603
2604 if (getLangOptions().CPlusPlus) {
2605 // Determine whether this is a dependent call inside a C++ template,
2606 // in which case we won't do any semantic analysis now.
2607 // FIXME: Will need to cache the results of name lookup (including ADL) in
2608 // Fn.
2609 bool Dependent = false;
2610 if (Fn->isTypeDependent())
2611 Dependent = true;
2612 else if (Expr::hasAnyTypeDependentArguments(Args, NumArgs))
2613 Dependent = true;
2614
2615 if (Dependent)
2616 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs,
2617 Context.DependentTy, RParenLoc));
2618
2619 // Determine whether this is a call to an object (C++ [over.call.object]).
2620 if (Fn->getType()->isRecordType())
2621 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs,
2622 CommaLocs, RParenLoc));
2623
2624 // Determine whether this is a call to a member function.
2625 if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(Fn->IgnoreParens())) {
2626 NamedDecl *MemDecl = MemExpr->getMemberDecl();
2627 if (isa<OverloadedFunctionDecl>(MemDecl) ||
2628 isa<CXXMethodDecl>(MemDecl) ||
2629 (isa<FunctionTemplateDecl>(MemDecl) &&
2630 isa<CXXMethodDecl>(
2631 cast<FunctionTemplateDecl>(MemDecl)->getTemplatedDecl())))
2632 return Owned(BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs,
2633 CommaLocs, RParenLoc));
2634 }
2635 }
2636
2637 // If we're directly calling a function, get the appropriate declaration.
|
2627 DeclRefExpr *DRExpr = NULL;
| 2638 // Also, in C++, keep track of whether we should perform argument-dependent
2639 // lookup and whether there were any explicitly-specified template arguments.
|
2628 Expr *FnExpr = Fn;
2629 bool ADL = true;
| 2640 Expr *FnExpr = Fn;
2641 bool ADL = true;
|
| 2642 bool HasExplicitTemplateArgs = 0;
2643 const TemplateArgument *ExplicitTemplateArgs = 0;
2644 unsigned NumExplicitTemplateArgs = 0;
|
2630 while (true) {
2631 if (ImplicitCastExpr *IcExpr = dyn_cast<ImplicitCastExpr>(FnExpr))
2632 FnExpr = IcExpr->getSubExpr();
2633 else if (ParenExpr *PExpr = dyn_cast<ParenExpr>(FnExpr)) {
2634 // Parentheses around a function disable ADL
2635 // (C++0x [basic.lookup.argdep]p1).
2636 ADL = false;
2637 FnExpr = PExpr->getSubExpr();
2638 } else if (isa<UnaryOperator>(FnExpr) &&
2639 cast<UnaryOperator>(FnExpr)->getOpcode()
2640 == UnaryOperator::AddrOf) {
2641 FnExpr = cast<UnaryOperator>(FnExpr)->getSubExpr();
| 2645 while (true) {
2646 if (ImplicitCastExpr *IcExpr = dyn_cast<ImplicitCastExpr>(FnExpr))
2647 FnExpr = IcExpr->getSubExpr();
2648 else if (ParenExpr *PExpr = dyn_cast<ParenExpr>(FnExpr)) {
2649 // Parentheses around a function disable ADL
2650 // (C++0x [basic.lookup.argdep]p1).
2651 ADL = false;
2652 FnExpr = PExpr->getSubExpr();
2653 } else if (isa<UnaryOperator>(FnExpr) &&
2654 cast<UnaryOperator>(FnExpr)->getOpcode()
2655 == UnaryOperator::AddrOf) {
2656 FnExpr = cast<UnaryOperator>(FnExpr)->getSubExpr();
|
2642 } else if ((DRExpr = dyn_cast<DeclRefExpr>(FnExpr))) {
| 2657 } else if (DeclRefExpr *DRExpr = dyn_cast<DeclRefExpr>(FnExpr)) {
|
2643 // Qualified names disable ADL (C++0x [basic.lookup.argdep]p1).
2644 ADL &= !isa<QualifiedDeclRefExpr>(DRExpr);
| 2658 // Qualified names disable ADL (C++0x [basic.lookup.argdep]p1).
2659 ADL &= !isa<QualifiedDeclRefExpr>(DRExpr);
|
| 2660 NDecl = dyn_cast<NamedDecl>(DRExpr->getDecl());
|
2645 break;
2646 } else if (UnresolvedFunctionNameExpr *DepName
2647 = dyn_cast<UnresolvedFunctionNameExpr>(FnExpr)) {
2648 UnqualifiedName = DepName->getName();
2649 break;
| 2661 break;
2662 } else if (UnresolvedFunctionNameExpr *DepName
2663 = dyn_cast<UnresolvedFunctionNameExpr>(FnExpr)) {
2664 UnqualifiedName = DepName->getName();
2665 break;
|
| 2666 } else if (TemplateIdRefExpr *TemplateIdRef
2667 = dyn_cast<TemplateIdRefExpr>(FnExpr)) {
2668 NDecl = TemplateIdRef->getTemplateName().getAsTemplateDecl();
2669 HasExplicitTemplateArgs = true;
2670 ExplicitTemplateArgs = TemplateIdRef->getTemplateArgs();
2671 NumExplicitTemplateArgs = TemplateIdRef->getNumTemplateArgs();
2672
2673 // C++ [temp.arg.explicit]p6:
2674 // [Note: For simple function names, argument dependent lookup (3.4.2)
2675 // applies even when the function name is not visible within the
2676 // scope of the call. This is because the call still has the syntactic
2677 // form of a function call (3.4.1). But when a function template with
2678 // explicit template arguments is used, the call does not have the
2679 // correct syntactic form unless there is a function template with
2680 // that name visible at the point of the call. If no such name is
2681 // visible, the call is not syntactically well-formed and
2682 // argument-dependent lookup does not apply. If some such name is
2683 // visible, argument dependent lookup applies and additional function
2684 // templates may be found in other namespaces.
2685 //
2686 // The summary of this paragraph is that, if we get to this point and the
2687 // template-id was not a qualified name, then argument-dependent lookup
2688 // is still possible.
2689 if (TemplateIdRef->getQualifier())
2690 ADL = false;
2691 break;
|
2650 } else {
2651 // Any kind of name that does not refer to a declaration (or
2652 // set of declarations) disables ADL (C++0x [basic.lookup.argdep]p3).
2653 ADL = false;
2654 break;
2655 }
2656 }
2657
2658 OverloadedFunctionDecl *Ovl = 0;
2659 FunctionTemplateDecl *FunctionTemplate = 0;
| 2692 } else {
2693 // Any kind of name that does not refer to a declaration (or
2694 // set of declarations) disables ADL (C++0x [basic.lookup.argdep]p3).
2695 ADL = false;
2696 break;
2697 }
2698 }
2699
2700 OverloadedFunctionDecl *Ovl = 0;
2701 FunctionTemplateDecl *FunctionTemplate = 0;
|
2660 if (DRExpr) {
2661 FDecl = dyn_cast<FunctionDecl>(DRExpr->getDecl());
2662 if ((FunctionTemplate = dyn_cast<FunctionTemplateDecl>(DRExpr->getDecl())))
| 2702 if (NDecl) {
2703 FDecl = dyn_cast<FunctionDecl>(NDecl);
2704 if ((FunctionTemplate = dyn_cast<FunctionTemplateDecl>(NDecl)))
|
2663 FDecl = FunctionTemplate->getTemplatedDecl();
2664 else
| 2705 FDecl = FunctionTemplate->getTemplatedDecl();
2706 else
|
2665 FDecl = dyn_cast<FunctionDecl>(DRExpr->getDecl());
2666 Ovl = dyn_cast<OverloadedFunctionDecl>(DRExpr->getDecl());
2667 NDecl = dyn_cast<NamedDecl>(DRExpr->getDecl());
| 2707 FDecl = dyn_cast<FunctionDecl>(NDecl);
2708 Ovl = dyn_cast<OverloadedFunctionDecl>(NDecl);
|
2668 }
2669
2670 if (Ovl || FunctionTemplate ||
2671 (getLangOptions().CPlusPlus && (FDecl || UnqualifiedName))) {
2672 // We don't perform ADL for implicit declarations of builtins.
2673 if (FDecl && FDecl->getBuiltinID(Context) && FDecl->isImplicit())
2674 ADL = false;
2675
2676 // We don't perform ADL in C.
2677 if (!getLangOptions().CPlusPlus)
2678 ADL = false;
2679
2680 if (Ovl || FunctionTemplate || ADL) {
| 2709 }
2710
2711 if (Ovl || FunctionTemplate ||
2712 (getLangOptions().CPlusPlus && (FDecl || UnqualifiedName))) {
2713 // We don't perform ADL for implicit declarations of builtins.
2714 if (FDecl && FDecl->getBuiltinID(Context) && FDecl->isImplicit())
2715 ADL = false;
2716
2717 // We don't perform ADL in C.
2718 if (!getLangOptions().CPlusPlus)
2719 ADL = false;
2720
2721 if (Ovl || FunctionTemplate || ADL) {
|
2681 FDecl = ResolveOverloadedCallFn(Fn, DRExpr? DRExpr->getDecl() : 0,
2682 UnqualifiedName, LParenLoc, Args,
2683 NumArgs, CommaLocs, RParenLoc, ADL);
| 2722 FDecl = ResolveOverloadedCallFn(Fn, NDecl, UnqualifiedName,
2723 HasExplicitTemplateArgs,
2724 ExplicitTemplateArgs,
2725 NumExplicitTemplateArgs,
2726 LParenLoc, Args, NumArgs, CommaLocs,
2727 RParenLoc, ADL);
|
2684 if (!FDecl)
2685 return ExprError();
2686
2687 // Update Fn to refer to the actual function selected.
2688 Expr *NewFn = 0;
2689 if (QualifiedDeclRefExpr *QDRExpr
| 2728 if (!FDecl)
2729 return ExprError();
2730
2731 // Update Fn to refer to the actual function selected.
2732 Expr *NewFn = 0;
2733 if (QualifiedDeclRefExpr *QDRExpr
|
2690 = dyn_cast_or_null<QualifiedDeclRefExpr>(DRExpr))
| 2734 = dyn_cast<QualifiedDeclRefExpr>(FnExpr))
|
2691 NewFn = new (Context) QualifiedDeclRefExpr(FDecl, FDecl->getType(),
2692 QDRExpr->getLocation(),
2693 false, false,
2694 QDRExpr->getQualifierRange(),
2695 QDRExpr->getQualifier());
2696 else
2697 NewFn = new (Context) DeclRefExpr(FDecl, FDecl->getType(),
2698 Fn->getSourceRange().getBegin());
2699 Fn->Destroy(Context);
2700 Fn = NewFn;
2701 }
2702 }
2703
2704 // Promote the function operand.
2705 UsualUnaryConversions(Fn);
2706
2707 // Make the call expr early, before semantic checks. This guarantees cleanup
2708 // of arguments and function on error.
2709 ExprOwningPtr<CallExpr> TheCall(this, new (Context) CallExpr(Context, Fn,
2710 Args, NumArgs,
2711 Context.BoolTy,
2712 RParenLoc));
2713
2714 const FunctionType *FuncT;
2715 if (!Fn->getType()->isBlockPointerType()) {
2716 // C99 6.5.2.2p1 - "The expression that denotes the called function shall
2717 // have type pointer to function".
2718 const PointerType *PT = Fn->getType()->getAsPointerType();
2719 if (PT == 0)
2720 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
2721 << Fn->getType() << Fn->getSourceRange());
2722 FuncT = PT->getPointeeType()->getAsFunctionType();
2723 } else { // This is a block call.
2724 FuncT = Fn->getType()->getAsBlockPointerType()->getPointeeType()->
2725 getAsFunctionType();
2726 }
2727 if (FuncT == 0)
2728 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
2729 << Fn->getType() << Fn->getSourceRange());
2730
2731 // Check for a valid return type
2732 if (!FuncT->getResultType()->isVoidType() &&
2733 RequireCompleteType(Fn->getSourceRange().getBegin(),
2734 FuncT->getResultType(),
2735 diag::err_call_incomplete_return,
2736 TheCall->getSourceRange()))
2737 return ExprError();
2738
2739 // We know the result type of the call, set it.
2740 TheCall->setType(FuncT->getResultType().getNonReferenceType());
2741
2742 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) {
2743 if (ConvertArgumentsForCall(&*TheCall, Fn, FDecl, Proto, Args, NumArgs,
2744 RParenLoc))
2745 return ExprError();
2746 } else {
2747 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
2748
2749 if (FDecl) {
2750 // Check if we have too few/too many template arguments, based
2751 // on our knowledge of the function definition.
2752 const FunctionDecl *Def = 0;
| 2735 NewFn = new (Context) QualifiedDeclRefExpr(FDecl, FDecl->getType(),
2736 QDRExpr->getLocation(),
2737 false, false,
2738 QDRExpr->getQualifierRange(),
2739 QDRExpr->getQualifier());
2740 else
2741 NewFn = new (Context) DeclRefExpr(FDecl, FDecl->getType(),
2742 Fn->getSourceRange().getBegin());
2743 Fn->Destroy(Context);
2744 Fn = NewFn;
2745 }
2746 }
2747
2748 // Promote the function operand.
2749 UsualUnaryConversions(Fn);
2750
2751 // Make the call expr early, before semantic checks. This guarantees cleanup
2752 // of arguments and function on error.
2753 ExprOwningPtr<CallExpr> TheCall(this, new (Context) CallExpr(Context, Fn,
2754 Args, NumArgs,
2755 Context.BoolTy,
2756 RParenLoc));
2757
2758 const FunctionType *FuncT;
2759 if (!Fn->getType()->isBlockPointerType()) {
2760 // C99 6.5.2.2p1 - "The expression that denotes the called function shall
2761 // have type pointer to function".
2762 const PointerType *PT = Fn->getType()->getAsPointerType();
2763 if (PT == 0)
2764 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
2765 << Fn->getType() << Fn->getSourceRange());
2766 FuncT = PT->getPointeeType()->getAsFunctionType();
2767 } else { // This is a block call.
2768 FuncT = Fn->getType()->getAsBlockPointerType()->getPointeeType()->
2769 getAsFunctionType();
2770 }
2771 if (FuncT == 0)
2772 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
2773 << Fn->getType() << Fn->getSourceRange());
2774
2775 // Check for a valid return type
2776 if (!FuncT->getResultType()->isVoidType() &&
2777 RequireCompleteType(Fn->getSourceRange().getBegin(),
2778 FuncT->getResultType(),
2779 diag::err_call_incomplete_return,
2780 TheCall->getSourceRange()))
2781 return ExprError();
2782
2783 // We know the result type of the call, set it.
2784 TheCall->setType(FuncT->getResultType().getNonReferenceType());
2785
2786 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) {
2787 if (ConvertArgumentsForCall(&*TheCall, Fn, FDecl, Proto, Args, NumArgs,
2788 RParenLoc))
2789 return ExprError();
2790 } else {
2791 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
2792
2793 if (FDecl) {
2794 // Check if we have too few/too many template arguments, based
2795 // on our knowledge of the function definition.
2796 const FunctionDecl *Def = 0;
|
2753 if (FDecl->getBody(Context, Def) && NumArgs != Def->param_size()) {
| 2797 if (FDecl->getBody(Def) && NumArgs != Def->param_size()) {
|
2754 const FunctionProtoType *Proto =
2755 Def->getType()->getAsFunctionProtoType();
2756 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) {
2757 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
2758 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange();
2759 }
2760 }
2761 }
2762
2763 // Promote the arguments (C99 6.5.2.2p6).
2764 for (unsigned i = 0; i != NumArgs; i++) {
2765 Expr *Arg = Args[i];
2766 DefaultArgumentPromotion(Arg);
2767 if (RequireCompleteType(Arg->getSourceRange().getBegin(),
2768 Arg->getType(),
2769 diag::err_call_incomplete_argument,
2770 Arg->getSourceRange()))
2771 return ExprError();
2772 TheCall->setArg(i, Arg);
2773 }
2774 }
2775
2776 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
2777 if (!Method->isStatic())
2778 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
2779 << Fn->getSourceRange());
2780
2781 // Check for sentinels
2782 if (NDecl)
2783 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs);
2784 // Do special checking on direct calls to functions.
2785 if (FDecl)
2786 return CheckFunctionCall(FDecl, TheCall.take());
2787 if (NDecl)
2788 return CheckBlockCall(NDecl, TheCall.take());
2789
2790 return Owned(TheCall.take());
2791}
2792
2793Action::OwningExprResult
2794Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, TypeTy *Ty,
2795 SourceLocation RParenLoc, ExprArg InitExpr) {
2796 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type");
2797 QualType literalType = QualType::getFromOpaquePtr(Ty);
2798 // FIXME: put back this assert when initializers are worked out.
2799 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
2800 Expr *literalExpr = static_cast<Expr*>(InitExpr.get());
2801
2802 if (literalType->isArrayType()) {
2803 if (literalType->isVariableArrayType())
2804 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
2805 << SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd()));
2806 } else if (!literalType->isDependentType() &&
2807 RequireCompleteType(LParenLoc, literalType,
2808 diag::err_typecheck_decl_incomplete_type,
2809 SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd())))
2810 return ExprError();
2811
2812 if (CheckInitializerTypes(literalExpr, literalType, LParenLoc,
2813 DeclarationName(), /*FIXME:DirectInit=*/false))
2814 return ExprError();
2815
2816 bool isFileScope = getCurFunctionOrMethodDecl() == 0;
2817 if (isFileScope) { // 6.5.2.5p3
2818 if (CheckForConstantInitializer(literalExpr, literalType))
2819 return ExprError();
2820 }
2821 InitExpr.release();
2822 return Owned(new (Context) CompoundLiteralExpr(LParenLoc, literalType,
2823 literalExpr, isFileScope));
2824}
2825
2826Action::OwningExprResult
2827Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist,
2828 SourceLocation RBraceLoc) {
2829 unsigned NumInit = initlist.size();
2830 Expr **InitList = reinterpret_cast<Expr**>(initlist.release());
2831
2832 // Semantic analysis for initializers is done by ActOnDeclarator() and
2833 // CheckInitializer() - it requires knowledge of the object being intialized.
2834
2835 InitListExpr *E = new (Context) InitListExpr(LBraceLoc, InitList, NumInit,
2836 RBraceLoc);
2837 E->setType(Context.VoidTy); // FIXME: just a place holder for now.
2838 return Owned(E);
2839}
2840
2841/// CheckCastTypes - Check type constraints for casting between types.
2842bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr) {
2843 UsualUnaryConversions(castExpr);
2844
2845 // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
2846 // type needs to be scalar.
2847 if (castType->isVoidType()) {
2848 // Cast to void allows any expr type.
2849 } else if (castType->isDependentType() || castExpr->isTypeDependent()) {
2850 // We can't check any more until template instantiation time.
2851 } else if (!castType->isScalarType() && !castType->isVectorType()) {
2852 if (Context.getCanonicalType(castType).getUnqualifiedType() ==
2853 Context.getCanonicalType(castExpr->getType().getUnqualifiedType()) &&
2854 (castType->isStructureType() || castType->isUnionType())) {
2855 // GCC struct/union extension: allow cast to self.
2856 // FIXME: Check that the cast destination type is complete.
2857 Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar)
2858 << castType << castExpr->getSourceRange();
2859 } else if (castType->isUnionType()) {
2860 // GCC cast to union extension
2861 RecordDecl *RD = castType->getAsRecordType()->getDecl();
2862 RecordDecl::field_iterator Field, FieldEnd;
| 2798 const FunctionProtoType *Proto =
2799 Def->getType()->getAsFunctionProtoType();
2800 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) {
2801 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
2802 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange();
2803 }
2804 }
2805 }
2806
2807 // Promote the arguments (C99 6.5.2.2p6).
2808 for (unsigned i = 0; i != NumArgs; i++) {
2809 Expr *Arg = Args[i];
2810 DefaultArgumentPromotion(Arg);
2811 if (RequireCompleteType(Arg->getSourceRange().getBegin(),
2812 Arg->getType(),
2813 diag::err_call_incomplete_argument,
2814 Arg->getSourceRange()))
2815 return ExprError();
2816 TheCall->setArg(i, Arg);
2817 }
2818 }
2819
2820 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
2821 if (!Method->isStatic())
2822 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
2823 << Fn->getSourceRange());
2824
2825 // Check for sentinels
2826 if (NDecl)
2827 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs);
2828 // Do special checking on direct calls to functions.
2829 if (FDecl)
2830 return CheckFunctionCall(FDecl, TheCall.take());
2831 if (NDecl)
2832 return CheckBlockCall(NDecl, TheCall.take());
2833
2834 return Owned(TheCall.take());
2835}
2836
2837Action::OwningExprResult
2838Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, TypeTy *Ty,
2839 SourceLocation RParenLoc, ExprArg InitExpr) {
2840 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type");
2841 QualType literalType = QualType::getFromOpaquePtr(Ty);
2842 // FIXME: put back this assert when initializers are worked out.
2843 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
2844 Expr *literalExpr = static_cast<Expr*>(InitExpr.get());
2845
2846 if (literalType->isArrayType()) {
2847 if (literalType->isVariableArrayType())
2848 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
2849 << SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd()));
2850 } else if (!literalType->isDependentType() &&
2851 RequireCompleteType(LParenLoc, literalType,
2852 diag::err_typecheck_decl_incomplete_type,
2853 SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd())))
2854 return ExprError();
2855
2856 if (CheckInitializerTypes(literalExpr, literalType, LParenLoc,
2857 DeclarationName(), /*FIXME:DirectInit=*/false))
2858 return ExprError();
2859
2860 bool isFileScope = getCurFunctionOrMethodDecl() == 0;
2861 if (isFileScope) { // 6.5.2.5p3
2862 if (CheckForConstantInitializer(literalExpr, literalType))
2863 return ExprError();
2864 }
2865 InitExpr.release();
2866 return Owned(new (Context) CompoundLiteralExpr(LParenLoc, literalType,
2867 literalExpr, isFileScope));
2868}
2869
2870Action::OwningExprResult
2871Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist,
2872 SourceLocation RBraceLoc) {
2873 unsigned NumInit = initlist.size();
2874 Expr **InitList = reinterpret_cast<Expr**>(initlist.release());
2875
2876 // Semantic analysis for initializers is done by ActOnDeclarator() and
2877 // CheckInitializer() - it requires knowledge of the object being intialized.
2878
2879 InitListExpr *E = new (Context) InitListExpr(LBraceLoc, InitList, NumInit,
2880 RBraceLoc);
2881 E->setType(Context.VoidTy); // FIXME: just a place holder for now.
2882 return Owned(E);
2883}
2884
2885/// CheckCastTypes - Check type constraints for casting between types.
2886bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr) {
2887 UsualUnaryConversions(castExpr);
2888
2889 // C99 6.5.4p2: the cast type needs to be void or scalar and the expression
2890 // type needs to be scalar.
2891 if (castType->isVoidType()) {
2892 // Cast to void allows any expr type.
2893 } else if (castType->isDependentType() || castExpr->isTypeDependent()) {
2894 // We can't check any more until template instantiation time.
2895 } else if (!castType->isScalarType() && !castType->isVectorType()) {
2896 if (Context.getCanonicalType(castType).getUnqualifiedType() ==
2897 Context.getCanonicalType(castExpr->getType().getUnqualifiedType()) &&
2898 (castType->isStructureType() || castType->isUnionType())) {
2899 // GCC struct/union extension: allow cast to self.
2900 // FIXME: Check that the cast destination type is complete.
2901 Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar)
2902 << castType << castExpr->getSourceRange();
2903 } else if (castType->isUnionType()) {
2904 // GCC cast to union extension
2905 RecordDecl *RD = castType->getAsRecordType()->getDecl();
2906 RecordDecl::field_iterator Field, FieldEnd;
|
2863 for (Field = RD->field_begin(Context), FieldEnd = RD->field_end(Context);
| 2907 for (Field = RD->field_begin(), FieldEnd = RD->field_end();
|
2864 Field != FieldEnd; ++Field) {
2865 if (Context.getCanonicalType(Field->getType()).getUnqualifiedType() ==
2866 Context.getCanonicalType(castExpr->getType()).getUnqualifiedType()) {
2867 Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union)
2868 << castExpr->getSourceRange();
2869 break;
2870 }
2871 }
2872 if (Field == FieldEnd)
2873 return Diag(TyR.getBegin(), diag::err_typecheck_cast_to_union_no_type)
2874 << castExpr->getType() << castExpr->getSourceRange();
2875 } else {
2876 // Reject any other conversions to non-scalar types.
2877 return Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar)
2878 << castType << castExpr->getSourceRange();
2879 }
2880 } else if (!castExpr->getType()->isScalarType() &&
2881 !castExpr->getType()->isVectorType()) {
2882 return Diag(castExpr->getLocStart(),
2883 diag::err_typecheck_expect_scalar_operand)
2884 << castExpr->getType() << castExpr->getSourceRange();
2885 } else if (castType->isExtVectorType()) {
2886 if (CheckExtVectorCast(TyR, castType, castExpr->getType()))
2887 return true;
2888 } else if (castType->isVectorType()) {
2889 if (CheckVectorCast(TyR, castType, castExpr->getType()))
2890 return true;
2891 } else if (castExpr->getType()->isVectorType()) {
2892 if (CheckVectorCast(TyR, castExpr->getType(), castType))
2893 return true;
2894 } else if (getLangOptions().ObjC1 && isa<ObjCSuperExpr>(castExpr)) {
2895 return Diag(castExpr->getLocStart(), diag::err_illegal_super_cast) << TyR;
2896 } else if (!castType->isArithmeticType()) {
2897 QualType castExprType = castExpr->getType();
2898 if (!castExprType->isIntegralType() && castExprType->isArithmeticType())
2899 return Diag(castExpr->getLocStart(),
2900 diag::err_cast_pointer_from_non_pointer_int)
2901 << castExprType << castExpr->getSourceRange();
2902 } else if (!castExpr->getType()->isArithmeticType()) {
2903 if (!castType->isIntegralType() && castType->isArithmeticType())
2904 return Diag(castExpr->getLocStart(),
2905 diag::err_cast_pointer_to_non_pointer_int)
2906 << castType << castExpr->getSourceRange();
2907 }
2908 if (isa<ObjCSelectorExpr>(castExpr))
2909 return Diag(castExpr->getLocStart(), diag::err_cast_selector_expr);
2910 return false;
2911}
2912
2913bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty) {
2914 assert(VectorTy->isVectorType() && "Not a vector type!");
2915
2916 if (Ty->isVectorType() || Ty->isIntegerType()) {
2917 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty))
2918 return Diag(R.getBegin(),
2919 Ty->isVectorType() ?
2920 diag::err_invalid_conversion_between_vectors :
2921 diag::err_invalid_conversion_between_vector_and_integer)
2922 << VectorTy << Ty << R;
2923 } else
2924 return Diag(R.getBegin(),
2925 diag::err_invalid_conversion_between_vector_and_scalar)
2926 << VectorTy << Ty << R;
2927
2928 return false;
2929}
2930
2931bool Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, QualType SrcTy) {
2932 assert(DestTy->isExtVectorType() && "Not an extended vector type!");
2933
| 2908 Field != FieldEnd; ++Field) {
2909 if (Context.getCanonicalType(Field->getType()).getUnqualifiedType() ==
2910 Context.getCanonicalType(castExpr->getType()).getUnqualifiedType()) {
2911 Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union)
2912 << castExpr->getSourceRange();
2913 break;
2914 }
2915 }
2916 if (Field == FieldEnd)
2917 return Diag(TyR.getBegin(), diag::err_typecheck_cast_to_union_no_type)
2918 << castExpr->getType() << castExpr->getSourceRange();
2919 } else {
2920 // Reject any other conversions to non-scalar types.
2921 return Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar)
2922 << castType << castExpr->getSourceRange();
2923 }
2924 } else if (!castExpr->getType()->isScalarType() &&
2925 !castExpr->getType()->isVectorType()) {
2926 return Diag(castExpr->getLocStart(),
2927 diag::err_typecheck_expect_scalar_operand)
2928 << castExpr->getType() << castExpr->getSourceRange();
2929 } else if (castType->isExtVectorType()) {
2930 if (CheckExtVectorCast(TyR, castType, castExpr->getType()))
2931 return true;
2932 } else if (castType->isVectorType()) {
2933 if (CheckVectorCast(TyR, castType, castExpr->getType()))
2934 return true;
2935 } else if (castExpr->getType()->isVectorType()) {
2936 if (CheckVectorCast(TyR, castExpr->getType(), castType))
2937 return true;
2938 } else if (getLangOptions().ObjC1 && isa<ObjCSuperExpr>(castExpr)) {
2939 return Diag(castExpr->getLocStart(), diag::err_illegal_super_cast) << TyR;
2940 } else if (!castType->isArithmeticType()) {
2941 QualType castExprType = castExpr->getType();
2942 if (!castExprType->isIntegralType() && castExprType->isArithmeticType())
2943 return Diag(castExpr->getLocStart(),
2944 diag::err_cast_pointer_from_non_pointer_int)
2945 << castExprType << castExpr->getSourceRange();
2946 } else if (!castExpr->getType()->isArithmeticType()) {
2947 if (!castType->isIntegralType() && castType->isArithmeticType())
2948 return Diag(castExpr->getLocStart(),
2949 diag::err_cast_pointer_to_non_pointer_int)
2950 << castType << castExpr->getSourceRange();
2951 }
2952 if (isa<ObjCSelectorExpr>(castExpr))
2953 return Diag(castExpr->getLocStart(), diag::err_cast_selector_expr);
2954 return false;
2955}
2956
2957bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty) {
2958 assert(VectorTy->isVectorType() && "Not a vector type!");
2959
2960 if (Ty->isVectorType() || Ty->isIntegerType()) {
2961 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty))
2962 return Diag(R.getBegin(),
2963 Ty->isVectorType() ?
2964 diag::err_invalid_conversion_between_vectors :
2965 diag::err_invalid_conversion_between_vector_and_integer)
2966 << VectorTy << Ty << R;
2967 } else
2968 return Diag(R.getBegin(),
2969 diag::err_invalid_conversion_between_vector_and_scalar)
2970 << VectorTy << Ty << R;
2971
2972 return false;
2973}
2974
2975bool Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, QualType SrcTy) {
2976 assert(DestTy->isExtVectorType() && "Not an extended vector type!");
2977
|
2934 // If SrcTy is also an ExtVectorType, the types must be identical unless
2935 // lax vector conversions is enabled.
2936 if (SrcTy->isExtVectorType()) {
2937 if (getLangOptions().LaxVectorConversions &&
2938 Context.getTypeSize(DestTy) == Context.getTypeSize(SrcTy))
2939 return false;
2940 if (DestTy != SrcTy)
2941 return Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
2942 << DestTy << SrcTy << R;
2943 return false;
2944 }
2945
2946 // If SrcTy is a VectorType, then only the total size must match.
| 2978 // If SrcTy is a VectorType, the total size must match to explicitly cast to
2979 // an ExtVectorType.
|
2947 if (SrcTy->isVectorType()) {
2948 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy))
2949 return Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
2950 << DestTy << SrcTy << R;
2951 return false;
2952 }
2953
| 2980 if (SrcTy->isVectorType()) {
2981 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy))
2982 return Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
2983 << DestTy << SrcTy << R;
2984 return false;
2985 }
2986
|
2954 // All scalar -> ext vector "c-style" casts are legal; the appropriate
| 2987 // All non-pointer scalars can be cast to ExtVector type. The appropriate
|
2955 // conversion will take place first from scalar to elt type, and then
2956 // splat from elt type to vector.
| 2988 // conversion will take place first from scalar to elt type, and then
2989 // splat from elt type to vector.
|
| 2990 if (SrcTy->isPointerType())
2991 return Diag(R.getBegin(),
2992 diag::err_invalid_conversion_between_vector_and_scalar)
2993 << DestTy << SrcTy << R;
|
2957 return false;
2958}
2959
2960Action::OwningExprResult
2961Sema::ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
2962 SourceLocation RParenLoc, ExprArg Op) {
2963 assert((Ty != 0) && (Op.get() != 0) &&
2964 "ActOnCastExpr(): missing type or expr");
2965
2966 Expr *castExpr = Op.takeAs<Expr>();
2967 QualType castType = QualType::getFromOpaquePtr(Ty);
2968
2969 if (CheckCastTypes(SourceRange(LParenLoc, RParenLoc), castType, castExpr))
2970 return ExprError();
2971 return Owned(new (Context) CStyleCastExpr(castType, castExpr, castType,
2972 LParenLoc, RParenLoc));
2973}
2974
2975/// Note that lhs is not null here, even if this is the gnu "x ?: y" extension.
2976/// In that case, lhs = cond.
2977/// C99 6.5.15
2978QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
2979 SourceLocation QuestionLoc) {
2980 // C++ is sufficiently different to merit its own checker.
2981 if (getLangOptions().CPlusPlus)
2982 return CXXCheckConditionalOperands(Cond, LHS, RHS, QuestionLoc);
2983
2984 UsualUnaryConversions(Cond);
2985 UsualUnaryConversions(LHS);
2986 UsualUnaryConversions(RHS);
2987 QualType CondTy = Cond->getType();
2988 QualType LHSTy = LHS->getType();
2989 QualType RHSTy = RHS->getType();
2990
2991 // first, check the condition.
2992 if (!CondTy->isScalarType()) { // C99 6.5.15p2
2993 Diag(Cond->getLocStart(), diag::err_typecheck_cond_expect_scalar)
2994 << CondTy;
2995 return QualType();
2996 }
2997
2998 // Now check the two expressions.
2999
3000 // If both operands have arithmetic type, do the usual arithmetic conversions
3001 // to find a common type: C99 6.5.15p3,5.
3002 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
3003 UsualArithmeticConversions(LHS, RHS);
3004 return LHS->getType();
3005 }
3006
3007 // If both operands are the same structure or union type, the result is that
3008 // type.
3009 if (const RecordType *LHSRT = LHSTy->getAsRecordType()) { // C99 6.5.15p3
3010 if (const RecordType *RHSRT = RHSTy->getAsRecordType())
3011 if (LHSRT->getDecl() == RHSRT->getDecl())
3012 // "If both the operands have structure or union type, the result has
3013 // that type." This implies that CV qualifiers are dropped.
3014 return LHSTy.getUnqualifiedType();
3015 // FIXME: Type of conditional expression must be complete in C mode.
3016 }
3017
3018 // C99 6.5.15p5: "If both operands have void type, the result has void type."
3019 // The following || allows only one side to be void (a GCC-ism).
3020 if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
3021 if (!LHSTy->isVoidType())
3022 Diag(RHS->getLocStart(), diag::ext_typecheck_cond_one_void)
3023 << RHS->getSourceRange();
3024 if (!RHSTy->isVoidType())
3025 Diag(LHS->getLocStart(), diag::ext_typecheck_cond_one_void)
3026 << LHS->getSourceRange();
3027 ImpCastExprToType(LHS, Context.VoidTy);
3028 ImpCastExprToType(RHS, Context.VoidTy);
3029 return Context.VoidTy;
3030 }
3031 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
3032 // the type of the other operand."
3033 if ((LHSTy->isPointerType() || LHSTy->isBlockPointerType() ||
3034 Context.isObjCObjectPointerType(LHSTy)) &&
3035 RHS->isNullPointerConstant(Context)) {
3036 ImpCastExprToType(RHS, LHSTy); // promote the null to a pointer.
3037 return LHSTy;
3038 }
3039 if ((RHSTy->isPointerType() || RHSTy->isBlockPointerType() ||
3040 Context.isObjCObjectPointerType(RHSTy)) &&
3041 LHS->isNullPointerConstant(Context)) {
3042 ImpCastExprToType(LHS, RHSTy); // promote the null to a pointer.
3043 return RHSTy;
3044 }
| 2994 return false;
2995}
2996
2997Action::OwningExprResult
2998Sema::ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
2999 SourceLocation RParenLoc, ExprArg Op) {
3000 assert((Ty != 0) && (Op.get() != 0) &&
3001 "ActOnCastExpr(): missing type or expr");
3002
3003 Expr *castExpr = Op.takeAs<Expr>();
3004 QualType castType = QualType::getFromOpaquePtr(Ty);
3005
3006 if (CheckCastTypes(SourceRange(LParenLoc, RParenLoc), castType, castExpr))
3007 return ExprError();
3008 return Owned(new (Context) CStyleCastExpr(castType, castExpr, castType,
3009 LParenLoc, RParenLoc));
3010}
3011
3012/// Note that lhs is not null here, even if this is the gnu "x ?: y" extension.
3013/// In that case, lhs = cond.
3014/// C99 6.5.15
3015QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS,
3016 SourceLocation QuestionLoc) {
3017 // C++ is sufficiently different to merit its own checker.
3018 if (getLangOptions().CPlusPlus)
3019 return CXXCheckConditionalOperands(Cond, LHS, RHS, QuestionLoc);
3020
3021 UsualUnaryConversions(Cond);
3022 UsualUnaryConversions(LHS);
3023 UsualUnaryConversions(RHS);
3024 QualType CondTy = Cond->getType();
3025 QualType LHSTy = LHS->getType();
3026 QualType RHSTy = RHS->getType();
3027
3028 // first, check the condition.
3029 if (!CondTy->isScalarType()) { // C99 6.5.15p2
3030 Diag(Cond->getLocStart(), diag::err_typecheck_cond_expect_scalar)
3031 << CondTy;
3032 return QualType();
3033 }
3034
3035 // Now check the two expressions.
3036
3037 // If both operands have arithmetic type, do the usual arithmetic conversions
3038 // to find a common type: C99 6.5.15p3,5.
3039 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
3040 UsualArithmeticConversions(LHS, RHS);
3041 return LHS->getType();
3042 }
3043
3044 // If both operands are the same structure or union type, the result is that
3045 // type.
3046 if (const RecordType *LHSRT = LHSTy->getAsRecordType()) { // C99 6.5.15p3
3047 if (const RecordType *RHSRT = RHSTy->getAsRecordType())
3048 if (LHSRT->getDecl() == RHSRT->getDecl())
3049 // "If both the operands have structure or union type, the result has
3050 // that type." This implies that CV qualifiers are dropped.
3051 return LHSTy.getUnqualifiedType();
3052 // FIXME: Type of conditional expression must be complete in C mode.
3053 }
3054
3055 // C99 6.5.15p5: "If both operands have void type, the result has void type."
3056 // The following || allows only one side to be void (a GCC-ism).
3057 if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
3058 if (!LHSTy->isVoidType())
3059 Diag(RHS->getLocStart(), diag::ext_typecheck_cond_one_void)
3060 << RHS->getSourceRange();
3061 if (!RHSTy->isVoidType())
3062 Diag(LHS->getLocStart(), diag::ext_typecheck_cond_one_void)
3063 << LHS->getSourceRange();
3064 ImpCastExprToType(LHS, Context.VoidTy);
3065 ImpCastExprToType(RHS, Context.VoidTy);
3066 return Context.VoidTy;
3067 }
3068 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
3069 // the type of the other operand."
3070 if ((LHSTy->isPointerType() || LHSTy->isBlockPointerType() ||
3071 Context.isObjCObjectPointerType(LHSTy)) &&
3072 RHS->isNullPointerConstant(Context)) {
3073 ImpCastExprToType(RHS, LHSTy); // promote the null to a pointer.
3074 return LHSTy;
3075 }
3076 if ((RHSTy->isPointerType() || RHSTy->isBlockPointerType() ||
3077 Context.isObjCObjectPointerType(RHSTy)) &&
3078 LHS->isNullPointerConstant(Context)) {
3079 ImpCastExprToType(LHS, RHSTy); // promote the null to a pointer.
3080 return RHSTy;
3081 }
|
| 3082 // Handle block pointer types.
3083 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) {
3084 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) {
3085 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) {
3086 QualType destType = Context.getPointerType(Context.VoidTy);
3087 ImpCastExprToType(LHS, destType);
3088 ImpCastExprToType(RHS, destType);
3089 return destType;
3090 }
3091 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
3092 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3093 return QualType();
3094 }
3095 // We have 2 block pointer types.
3096 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
3097 // Two identical block pointer types are always compatible.
3098 return LHSTy;
3099 }
3100 // The block pointer types aren't identical, continue checking.
3101 QualType lhptee = LHSTy->getAsBlockPointerType()->getPointeeType();
3102 QualType rhptee = RHSTy->getAsBlockPointerType()->getPointeeType();
|
3045
| 3103
|
3046 const PointerType *LHSPT = LHSTy->getAsPointerType();
3047 const PointerType *RHSPT = RHSTy->getAsPointerType();
3048 const BlockPointerType *LHSBPT = LHSTy->getAsBlockPointerType();
3049 const BlockPointerType *RHSBPT = RHSTy->getAsBlockPointerType();
| 3104 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(),
3105 rhptee.getUnqualifiedType())) {
3106 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers)
3107 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3108 // In this situation, we assume void* type. No especially good
3109 // reason, but this is what gcc does, and we do have to pick
3110 // to get a consistent AST.
3111 QualType incompatTy = Context.getPointerType(Context.VoidTy);
3112 ImpCastExprToType(LHS, incompatTy);
3113 ImpCastExprToType(RHS, incompatTy);
3114 return incompatTy;
3115 }
3116 // The block pointer types are compatible.
3117 ImpCastExprToType(LHS, LHSTy);
3118 ImpCastExprToType(RHS, LHSTy);
3119 return LHSTy;
3120 }
3121 // Need to handle "id<xx>" explicitly. Unlike "id", whose canonical type
3122 // evaluates to "struct objc_object *" (and is handled above when comparing
3123 // id with statically typed objects).
3124 if (LHSTy->isObjCQualifiedIdType() || RHSTy->isObjCQualifiedIdType()) {
3125 // GCC allows qualified id and any Objective-C type to devolve to
3126 // id. Currently localizing to here until clear this should be
3127 // part of ObjCQualifiedIdTypesAreCompatible.
3128 if (ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true) ||
3129 (LHSTy->isObjCQualifiedIdType() &&
3130 Context.isObjCObjectPointerType(RHSTy)) ||
3131 (RHSTy->isObjCQualifiedIdType() &&
3132 Context.isObjCObjectPointerType(LHSTy))) {
3133 // FIXME: This is not the correct composite type. This only happens to
3134 // work because id can more or less be used anywhere, however this may
3135 // change the type of method sends.
|
3050
| 3136
|
3051 // Handle the case where both operands are pointers before we handle null
3052 // pointer constants in case both operands are null pointer constants.
3053 if ((LHSPT || LHSBPT) && (RHSPT || RHSBPT)) { // C99 6.5.15p3,6
| 3137 // FIXME: gcc adds some type-checking of the arguments and emits
3138 // (confusing) incompatible comparison warnings in some
3139 // cases. Investigate.
3140 QualType compositeType = Context.getObjCIdType();
3141 ImpCastExprToType(LHS, compositeType);
3142 ImpCastExprToType(RHS, compositeType);
3143 return compositeType;
3144 }
3145 }
3146 // Check constraints for Objective-C object pointers types.
3147 if (Context.isObjCObjectPointerType(LHSTy) &&
3148 Context.isObjCObjectPointerType(RHSTy)) {
3149
3150 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
3151 // Two identical object pointer types are always compatible.
3152 return LHSTy;
3153 }
3154 // No need to check for block pointer types or qualified id types (they
3155 // were handled above).
3156 assert((LHSTy->isPointerType() && RHSTy->isPointerType()) &&
3157 "Sema::CheckConditionalOperands(): Unexpected type");
3158 QualType lhptee = LHSTy->getAsPointerType()->getPointeeType();
3159 QualType rhptee = RHSTy->getAsPointerType()->getPointeeType();
3160
3161 QualType compositeType = LHSTy;
3162
3163 // If both operands are interfaces and either operand can be
3164 // assigned to the other, use that type as the composite
3165 // type. This allows
3166 // xxx ? (A*) a : (B*) b
3167 // where B is a subclass of A.
3168 //
3169 // Additionally, as for assignment, if either type is 'id'
3170 // allow silent coercion. Finally, if the types are
3171 // incompatible then make sure to use 'id' as the composite
3172 // type so the result is acceptable for sending messages to.
3173
3174 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
3175 // It could return the composite type.
3176 const ObjCInterfaceType* LHSIface = lhptee->getAsObjCInterfaceType();
3177 const ObjCInterfaceType* RHSIface = rhptee->getAsObjCInterfaceType();
3178 if (LHSIface && RHSIface &&
3179 Context.canAssignObjCInterfaces(LHSIface, RHSIface)) {
3180 compositeType = LHSTy;
3181 } else if (LHSIface && RHSIface &&
3182 Context.canAssignObjCInterfaces(RHSIface, LHSIface)) {
3183 compositeType = RHSTy;
3184 } else if (Context.isObjCIdStructType(lhptee) ||
3185 Context.isObjCIdStructType(rhptee)) {
3186 compositeType = Context.getObjCIdType();
3187 } else {
3188 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
3189 << LHSTy << RHSTy
3190 << LHS->getSourceRange() << RHS->getSourceRange();
3191 QualType incompatTy = Context.getObjCIdType();
3192 ImpCastExprToType(LHS, incompatTy);
3193 ImpCastExprToType(RHS, incompatTy);
3194 return incompatTy;
3195 }
3196 // The object pointer types are compatible.
3197 ImpCastExprToType(LHS, compositeType);
3198 ImpCastExprToType(RHS, compositeType);
3199 return compositeType;
3200 }
3201 // Check constraints for C object pointers types (C99 6.5.15p3,6).
3202 if (LHSTy->isPointerType() && RHSTy->isPointerType()) {
|
3054 // get the "pointed to" types
| 3203 // get the "pointed to" types
|
3055 QualType lhptee = (LHSPT ? LHSPT->getPointeeType()
3056 : LHSBPT->getPointeeType());
3057 QualType rhptee = (RHSPT ? RHSPT->getPointeeType()
3058 : RHSBPT->getPointeeType());
| 3204 QualType lhptee = LHSTy->getAsPointerType()->getPointeeType();
3205 QualType rhptee = RHSTy->getAsPointerType()->getPointeeType();
|
3059
3060 // ignore qualifiers on void (C99 6.5.15p3, clause 6)
| 3206
3207 // ignore qualifiers on void (C99 6.5.15p3, clause 6)
|
3061 if (lhptee->isVoidType()
3062 && (RHSBPT || rhptee->isIncompleteOrObjectType())) {
| 3208 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
|
3063 // Figure out necessary qualifiers (C99 6.5.15p6)
3064 QualType destPointee=lhptee.getQualifiedType(rhptee.getCVRQualifiers());
3065 QualType destType = Context.getPointerType(destPointee);
3066 ImpCastExprToType(LHS, destType); // add qualifiers if necessary
3067 ImpCastExprToType(RHS, destType); // promote to void*
3068 return destType;
3069 }
| 3209 // Figure out necessary qualifiers (C99 6.5.15p6)
3210 QualType destPointee=lhptee.getQualifiedType(rhptee.getCVRQualifiers());
3211 QualType destType = Context.getPointerType(destPointee);
3212 ImpCastExprToType(LHS, destType); // add qualifiers if necessary
3213 ImpCastExprToType(RHS, destType); // promote to void*
3214 return destType;
3215 }
|
3070 if (rhptee->isVoidType()
3071 && (LHSBPT || lhptee->isIncompleteOrObjectType())) {
| 3216 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
|
3072 QualType destPointee=rhptee.getQualifiedType(lhptee.getCVRQualifiers());
3073 QualType destType = Context.getPointerType(destPointee);
3074 ImpCastExprToType(LHS, destType); // add qualifiers if necessary
3075 ImpCastExprToType(RHS, destType); // promote to void*
3076 return destType;
3077 }
3078
| 3217 QualType destPointee=rhptee.getQualifiedType(lhptee.getCVRQualifiers());
3218 QualType destType = Context.getPointerType(destPointee);
3219 ImpCastExprToType(LHS, destType); // add qualifiers if necessary
3220 ImpCastExprToType(RHS, destType); // promote to void*
3221 return destType;
3222 }
3223
|
3079 bool sameKind = (LHSPT && RHSPT) || (LHSBPT && RHSBPT);
3080 if (sameKind
3081 && Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
| 3224 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
|
3082 // Two identical pointer types are always compatible.
3083 return LHSTy;
3084 }
| 3225 // Two identical pointer types are always compatible.
3226 return LHSTy;
3227 }
|
3085
3086 QualType compositeType = LHSTy;
3087
3088 // If either type is an Objective-C object type then check
3089 // compatibility according to Objective-C.
3090 if (Context.isObjCObjectPointerType(LHSTy) ||
3091 Context.isObjCObjectPointerType(RHSTy)) {
3092 // If both operands are interfaces and either operand can be
3093 // assigned to the other, use that type as the composite
3094 // type. This allows
3095 // xxx ? (A*) a : (B*) b
3096 // where B is a subclass of A.
3097 //
3098 // Additionally, as for assignment, if either type is 'id'
3099 // allow silent coercion. Finally, if the types are
3100 // incompatible then make sure to use 'id' as the composite
3101 // type so the result is acceptable for sending messages to.
3102
3103 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
3104 // It could return the composite type.
3105 const ObjCInterfaceType* LHSIface = lhptee->getAsObjCInterfaceType();
3106 const ObjCInterfaceType* RHSIface = rhptee->getAsObjCInterfaceType();
3107 if (LHSIface && RHSIface &&
3108 Context.canAssignObjCInterfaces(LHSIface, RHSIface)) {
3109 compositeType = LHSTy;
3110 } else if (LHSIface && RHSIface &&
3111 Context.canAssignObjCInterfaces(RHSIface, LHSIface)) {
3112 compositeType = RHSTy;
3113 } else if (Context.isObjCIdStructType(lhptee) ||
3114 Context.isObjCIdStructType(rhptee)) {
3115 compositeType = Context.getObjCIdType();
3116 } else if (LHSBPT || RHSBPT) {
3117 if (!sameKind
3118 || !Context.typesAreCompatible(lhptee.getUnqualifiedType(),
3119 rhptee.getUnqualifiedType()))
3120 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
3121 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3122 return QualType();
3123 } else {
3124 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
3125 << LHSTy << RHSTy
3126 << LHS->getSourceRange() << RHS->getSourceRange();
3127 QualType incompatTy = Context.getObjCIdType();
3128 ImpCastExprToType(LHS, incompatTy);
3129 ImpCastExprToType(RHS, incompatTy);
3130 return incompatTy;
3131 }
3132 } else if (!sameKind
3133 || !Context.typesAreCompatible(lhptee.getUnqualifiedType(),
3134 rhptee.getUnqualifiedType())) {
| 3228 if (!Context.typesAreCompatible(lhptee.getUnqualifiedType(),
3229 rhptee.getUnqualifiedType())) {
|
3135 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers)
3136 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3137 // In this situation, we assume void* type. No especially good
3138 // reason, but this is what gcc does, and we do have to pick
3139 // to get a consistent AST.
3140 QualType incompatTy = Context.getPointerType(Context.VoidTy);
3141 ImpCastExprToType(LHS, incompatTy);
3142 ImpCastExprToType(RHS, incompatTy);
3143 return incompatTy;
3144 }
3145 // The pointer types are compatible.
3146 // C99 6.5.15p6: If both operands are pointers to compatible types *or* to
3147 // differently qualified versions of compatible types, the result type is
3148 // a pointer to an appropriately qualified version of the *composite*
3149 // type.
3150 // FIXME: Need to calculate the composite type.
3151 // FIXME: Need to add qualifiers
| 3230 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers)
3231 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3232 // In this situation, we assume void* type. No especially good
3233 // reason, but this is what gcc does, and we do have to pick
3234 // to get a consistent AST.
3235 QualType incompatTy = Context.getPointerType(Context.VoidTy);
3236 ImpCastExprToType(LHS, incompatTy);
3237 ImpCastExprToType(RHS, incompatTy);
3238 return incompatTy;
3239 }
3240 // The pointer types are compatible.
3241 // C99 6.5.15p6: If both operands are pointers to compatible types *or* to
3242 // differently qualified versions of compatible types, the result type is
3243 // a pointer to an appropriately qualified version of the *composite*
3244 // type.
3245 // FIXME: Need to calculate the composite type.
3246 // FIXME: Need to add qualifiers
|
3152 ImpCastExprToType(LHS, compositeType);
3153 ImpCastExprToType(RHS, compositeType);
3154 return compositeType;
| 3247 ImpCastExprToType(LHS, LHSTy);
3248 ImpCastExprToType(RHS, LHSTy);
3249 return LHSTy;
|
3155 }
| 3250 }
|
3156
| 3251
|
3157 // GCC compatibility: soften pointer/integer mismatch.
3158 if (RHSTy->isPointerType() && LHSTy->isIntegerType()) {
3159 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
3160 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3161 ImpCastExprToType(LHS, RHSTy); // promote the integer to a pointer.
3162 return RHSTy;
3163 }
3164 if (LHSTy->isPointerType() && RHSTy->isIntegerType()) {
3165 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
3166 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3167 ImpCastExprToType(RHS, LHSTy); // promote the integer to a pointer.
3168 return LHSTy;
3169 }
3170
| 3252 // GCC compatibility: soften pointer/integer mismatch.
3253 if (RHSTy->isPointerType() && LHSTy->isIntegerType()) {
3254 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
3255 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3256 ImpCastExprToType(LHS, RHSTy); // promote the integer to a pointer.
3257 return RHSTy;
3258 }
3259 if (LHSTy->isPointerType() && RHSTy->isIntegerType()) {
3260 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch)
3261 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3262 ImpCastExprToType(RHS, LHSTy); // promote the integer to a pointer.
3263 return LHSTy;
3264 }
3265
|
3171 // Need to handle "id<xx>" explicitly. Unlike "id", whose canonical type
3172 // evaluates to "struct objc_object *" (and is handled above when comparing
3173 // id with statically typed objects).
3174 if (LHSTy->isObjCQualifiedIdType() || RHSTy->isObjCQualifiedIdType()) {
3175 // GCC allows qualified id and any Objective-C type to devolve to
3176 // id. Currently localizing to here until clear this should be
3177 // part of ObjCQualifiedIdTypesAreCompatible.
3178 if (ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true) ||
3179 (LHSTy->isObjCQualifiedIdType() &&
3180 Context.isObjCObjectPointerType(RHSTy)) ||
3181 (RHSTy->isObjCQualifiedIdType() &&
3182 Context.isObjCObjectPointerType(LHSTy))) {
3183 // FIXME: This is not the correct composite type. This only happens to
3184 // work because id can more or less be used anywhere, however this may
3185 // change the type of method sends.
3186
3187 // FIXME: gcc adds some type-checking of the arguments and emits
3188 // (confusing) incompatible comparison warnings in some
3189 // cases. Investigate.
3190 QualType compositeType = Context.getObjCIdType();
3191 ImpCastExprToType(LHS, compositeType);
3192 ImpCastExprToType(RHS, compositeType);
3193 return compositeType;
3194 }
3195 }
3196
| |
3197 // Otherwise, the operands are not compatible.
3198 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
3199 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3200 return QualType();
3201}
3202
3203/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
3204/// in the case of a the GNU conditional expr extension.
3205Action::OwningExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
3206 SourceLocation ColonLoc,
3207 ExprArg Cond, ExprArg LHS,
3208 ExprArg RHS) {
3209 Expr *CondExpr = (Expr *) Cond.get();
3210 Expr *LHSExpr = (Expr *) LHS.get(), *RHSExpr = (Expr *) RHS.get();
3211
3212 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
3213 // was the condition.
3214 bool isLHSNull = LHSExpr == 0;
3215 if (isLHSNull)
3216 LHSExpr = CondExpr;
3217
3218 QualType result = CheckConditionalOperands(CondExpr, LHSExpr,
3219 RHSExpr, QuestionLoc);
3220 if (result.isNull())
3221 return ExprError();
3222
3223 Cond.release();
3224 LHS.release();
3225 RHS.release();
3226 return Owned(new (Context) ConditionalOperator(CondExpr,
3227 isLHSNull ? 0 : LHSExpr,
3228 RHSExpr, result));
3229}
3230
3231
3232// CheckPointerTypesForAssignment - This is a very tricky routine (despite
3233// being closely modeled after the C99 spec:-). The odd characteristic of this
3234// routine is it effectively iqnores the qualifiers on the top level pointee.
3235// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
3236// FIXME: add a couple examples in this comment.
3237Sema::AssignConvertType
3238Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) {
3239 QualType lhptee, rhptee;
3240
3241 // get the "pointed to" type (ignoring qualifiers at the top level)
3242 lhptee = lhsType->getAsPointerType()->getPointeeType();
3243 rhptee = rhsType->getAsPointerType()->getPointeeType();
3244
3245 // make sure we operate on the canonical type
3246 lhptee = Context.getCanonicalType(lhptee);
3247 rhptee = Context.getCanonicalType(rhptee);
3248
3249 AssignConvertType ConvTy = Compatible;
3250
3251 // C99 6.5.16.1p1: This following citation is common to constraints
3252 // 3 & 4 (below). ...and the type *pointed to* by the left has all the
3253 // qualifiers of the type *pointed to* by the right;
3254 // FIXME: Handle ExtQualType
3255 if (!lhptee.isAtLeastAsQualifiedAs(rhptee))
3256 ConvTy = CompatiblePointerDiscardsQualifiers;
3257
3258 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
3259 // incomplete type and the other is a pointer to a qualified or unqualified
3260 // version of void...
3261 if (lhptee->isVoidType()) {
3262 if (rhptee->isIncompleteOrObjectType())
3263 return ConvTy;
3264
3265 // As an extension, we allow cast to/from void* to function pointer.
3266 assert(rhptee->isFunctionType());
3267 return FunctionVoidPointer;
3268 }
3269
3270 if (rhptee->isVoidType()) {
3271 if (lhptee->isIncompleteOrObjectType())
3272 return ConvTy;
3273
3274 // As an extension, we allow cast to/from void* to function pointer.
3275 assert(lhptee->isFunctionType());
3276 return FunctionVoidPointer;
3277 }
3278 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
3279 // unqualified versions of compatible types, ...
3280 lhptee = lhptee.getUnqualifiedType();
3281 rhptee = rhptee.getUnqualifiedType();
3282 if (!Context.typesAreCompatible(lhptee, rhptee)) {
3283 // Check if the pointee types are compatible ignoring the sign.
3284 // We explicitly check for char so that we catch "char" vs
3285 // "unsigned char" on systems where "char" is unsigned.
3286 if (lhptee->isCharType()) {
3287 lhptee = Context.UnsignedCharTy;
3288 } else if (lhptee->isSignedIntegerType()) {
3289 lhptee = Context.getCorrespondingUnsignedType(lhptee);
3290 }
3291 if (rhptee->isCharType()) {
3292 rhptee = Context.UnsignedCharTy;
3293 } else if (rhptee->isSignedIntegerType()) {
3294 rhptee = Context.getCorrespondingUnsignedType(rhptee);
3295 }
3296 if (lhptee == rhptee) {
3297 // Types are compatible ignoring the sign. Qualifier incompatibility
3298 // takes priority over sign incompatibility because the sign
3299 // warning can be disabled.
3300 if (ConvTy != Compatible)
3301 return ConvTy;
3302 return IncompatiblePointerSign;
3303 }
3304 // General pointer incompatibility takes priority over qualifiers.
3305 return IncompatiblePointer;
3306 }
3307 return ConvTy;
3308}
3309
3310/// CheckBlockPointerTypesForAssignment - This routine determines whether two
3311/// block pointer types are compatible or whether a block and normal pointer
3312/// are compatible. It is more restrict than comparing two function pointer
3313// types.
3314Sema::AssignConvertType
3315Sema::CheckBlockPointerTypesForAssignment(QualType lhsType,
3316 QualType rhsType) {
3317 QualType lhptee, rhptee;
3318
3319 // get the "pointed to" type (ignoring qualifiers at the top level)
3320 lhptee = lhsType->getAsBlockPointerType()->getPointeeType();
3321 rhptee = rhsType->getAsBlockPointerType()->getPointeeType();
3322
3323 // make sure we operate on the canonical type
3324 lhptee = Context.getCanonicalType(lhptee);
3325 rhptee = Context.getCanonicalType(rhptee);
3326
3327 AssignConvertType ConvTy = Compatible;
3328
3329 // For blocks we enforce that qualifiers are identical.
3330 if (lhptee.getCVRQualifiers() != rhptee.getCVRQualifiers())
3331 ConvTy = CompatiblePointerDiscardsQualifiers;
3332
3333 if (!Context.typesAreCompatible(lhptee, rhptee))
3334 return IncompatibleBlockPointer;
3335 return ConvTy;
3336}
3337
3338/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
3339/// has code to accommodate several GCC extensions when type checking
3340/// pointers. Here are some objectionable examples that GCC considers warnings:
3341///
3342/// int a, *pint;
3343/// short *pshort;
3344/// struct foo *pfoo;
3345///
3346/// pint = pshort; // warning: assignment from incompatible pointer type
3347/// a = pint; // warning: assignment makes integer from pointer without a cast
3348/// pint = a; // warning: assignment makes pointer from integer without a cast
3349/// pint = pfoo; // warning: assignment from incompatible pointer type
3350///
3351/// As a result, the code for dealing with pointers is more complex than the
3352/// C99 spec dictates.
3353///
3354Sema::AssignConvertType
3355Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) {
3356 // Get canonical types. We're not formatting these types, just comparing
3357 // them.
3358 lhsType = Context.getCanonicalType(lhsType).getUnqualifiedType();
3359 rhsType = Context.getCanonicalType(rhsType).getUnqualifiedType();
3360
3361 if (lhsType == rhsType)
3362 return Compatible; // Common case: fast path an exact match.
3363
3364 // If the left-hand side is a reference type, then we are in a
3365 // (rare!) case where we've allowed the use of references in C,
3366 // e.g., as a parameter type in a built-in function. In this case,
3367 // just make sure that the type referenced is compatible with the
3368 // right-hand side type. The caller is responsible for adjusting
3369 // lhsType so that the resulting expression does not have reference
3370 // type.
3371 if (const ReferenceType *lhsTypeRef = lhsType->getAsReferenceType()) {
3372 if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType))
3373 return Compatible;
3374 return Incompatible;
3375 }
3376
3377 if (lhsType->isObjCQualifiedIdType() || rhsType->isObjCQualifiedIdType()) {
3378 if (ObjCQualifiedIdTypesAreCompatible(lhsType, rhsType, false))
3379 return Compatible;
3380 // Relax integer conversions like we do for pointers below.
3381 if (rhsType->isIntegerType())
3382 return IntToPointer;
3383 if (lhsType->isIntegerType())
3384 return PointerToInt;
3385 return IncompatibleObjCQualifiedId;
3386 }
3387
| 3266 // Otherwise, the operands are not compatible.
3267 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
3268 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange();
3269 return QualType();
3270}
3271
3272/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
3273/// in the case of a the GNU conditional expr extension.
3274Action::OwningExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
3275 SourceLocation ColonLoc,
3276 ExprArg Cond, ExprArg LHS,
3277 ExprArg RHS) {
3278 Expr *CondExpr = (Expr *) Cond.get();
3279 Expr *LHSExpr = (Expr *) LHS.get(), *RHSExpr = (Expr *) RHS.get();
3280
3281 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
3282 // was the condition.
3283 bool isLHSNull = LHSExpr == 0;
3284 if (isLHSNull)
3285 LHSExpr = CondExpr;
3286
3287 QualType result = CheckConditionalOperands(CondExpr, LHSExpr,
3288 RHSExpr, QuestionLoc);
3289 if (result.isNull())
3290 return ExprError();
3291
3292 Cond.release();
3293 LHS.release();
3294 RHS.release();
3295 return Owned(new (Context) ConditionalOperator(CondExpr,
3296 isLHSNull ? 0 : LHSExpr,
3297 RHSExpr, result));
3298}
3299
3300
3301// CheckPointerTypesForAssignment - This is a very tricky routine (despite
3302// being closely modeled after the C99 spec:-). The odd characteristic of this
3303// routine is it effectively iqnores the qualifiers on the top level pointee.
3304// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
3305// FIXME: add a couple examples in this comment.
3306Sema::AssignConvertType
3307Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) {
3308 QualType lhptee, rhptee;
3309
3310 // get the "pointed to" type (ignoring qualifiers at the top level)
3311 lhptee = lhsType->getAsPointerType()->getPointeeType();
3312 rhptee = rhsType->getAsPointerType()->getPointeeType();
3313
3314 // make sure we operate on the canonical type
3315 lhptee = Context.getCanonicalType(lhptee);
3316 rhptee = Context.getCanonicalType(rhptee);
3317
3318 AssignConvertType ConvTy = Compatible;
3319
3320 // C99 6.5.16.1p1: This following citation is common to constraints
3321 // 3 & 4 (below). ...and the type *pointed to* by the left has all the
3322 // qualifiers of the type *pointed to* by the right;
3323 // FIXME: Handle ExtQualType
3324 if (!lhptee.isAtLeastAsQualifiedAs(rhptee))
3325 ConvTy = CompatiblePointerDiscardsQualifiers;
3326
3327 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
3328 // incomplete type and the other is a pointer to a qualified or unqualified
3329 // version of void...
3330 if (lhptee->isVoidType()) {
3331 if (rhptee->isIncompleteOrObjectType())
3332 return ConvTy;
3333
3334 // As an extension, we allow cast to/from void* to function pointer.
3335 assert(rhptee->isFunctionType());
3336 return FunctionVoidPointer;
3337 }
3338
3339 if (rhptee->isVoidType()) {
3340 if (lhptee->isIncompleteOrObjectType())
3341 return ConvTy;
3342
3343 // As an extension, we allow cast to/from void* to function pointer.
3344 assert(lhptee->isFunctionType());
3345 return FunctionVoidPointer;
3346 }
3347 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
3348 // unqualified versions of compatible types, ...
3349 lhptee = lhptee.getUnqualifiedType();
3350 rhptee = rhptee.getUnqualifiedType();
3351 if (!Context.typesAreCompatible(lhptee, rhptee)) {
3352 // Check if the pointee types are compatible ignoring the sign.
3353 // We explicitly check for char so that we catch "char" vs
3354 // "unsigned char" on systems where "char" is unsigned.
3355 if (lhptee->isCharType()) {
3356 lhptee = Context.UnsignedCharTy;
3357 } else if (lhptee->isSignedIntegerType()) {
3358 lhptee = Context.getCorrespondingUnsignedType(lhptee);
3359 }
3360 if (rhptee->isCharType()) {
3361 rhptee = Context.UnsignedCharTy;
3362 } else if (rhptee->isSignedIntegerType()) {
3363 rhptee = Context.getCorrespondingUnsignedType(rhptee);
3364 }
3365 if (lhptee == rhptee) {
3366 // Types are compatible ignoring the sign. Qualifier incompatibility
3367 // takes priority over sign incompatibility because the sign
3368 // warning can be disabled.
3369 if (ConvTy != Compatible)
3370 return ConvTy;
3371 return IncompatiblePointerSign;
3372 }
3373 // General pointer incompatibility takes priority over qualifiers.
3374 return IncompatiblePointer;
3375 }
3376 return ConvTy;
3377}
3378
3379/// CheckBlockPointerTypesForAssignment - This routine determines whether two
3380/// block pointer types are compatible or whether a block and normal pointer
3381/// are compatible. It is more restrict than comparing two function pointer
3382// types.
3383Sema::AssignConvertType
3384Sema::CheckBlockPointerTypesForAssignment(QualType lhsType,
3385 QualType rhsType) {
3386 QualType lhptee, rhptee;
3387
3388 // get the "pointed to" type (ignoring qualifiers at the top level)
3389 lhptee = lhsType->getAsBlockPointerType()->getPointeeType();
3390 rhptee = rhsType->getAsBlockPointerType()->getPointeeType();
3391
3392 // make sure we operate on the canonical type
3393 lhptee = Context.getCanonicalType(lhptee);
3394 rhptee = Context.getCanonicalType(rhptee);
3395
3396 AssignConvertType ConvTy = Compatible;
3397
3398 // For blocks we enforce that qualifiers are identical.
3399 if (lhptee.getCVRQualifiers() != rhptee.getCVRQualifiers())
3400 ConvTy = CompatiblePointerDiscardsQualifiers;
3401
3402 if (!Context.typesAreCompatible(lhptee, rhptee))
3403 return IncompatibleBlockPointer;
3404 return ConvTy;
3405}
3406
3407/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
3408/// has code to accommodate several GCC extensions when type checking
3409/// pointers. Here are some objectionable examples that GCC considers warnings:
3410///
3411/// int a, *pint;
3412/// short *pshort;
3413/// struct foo *pfoo;
3414///
3415/// pint = pshort; // warning: assignment from incompatible pointer type
3416/// a = pint; // warning: assignment makes integer from pointer without a cast
3417/// pint = a; // warning: assignment makes pointer from integer without a cast
3418/// pint = pfoo; // warning: assignment from incompatible pointer type
3419///
3420/// As a result, the code for dealing with pointers is more complex than the
3421/// C99 spec dictates.
3422///
3423Sema::AssignConvertType
3424Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) {
3425 // Get canonical types. We're not formatting these types, just comparing
3426 // them.
3427 lhsType = Context.getCanonicalType(lhsType).getUnqualifiedType();
3428 rhsType = Context.getCanonicalType(rhsType).getUnqualifiedType();
3429
3430 if (lhsType == rhsType)
3431 return Compatible; // Common case: fast path an exact match.
3432
3433 // If the left-hand side is a reference type, then we are in a
3434 // (rare!) case where we've allowed the use of references in C,
3435 // e.g., as a parameter type in a built-in function. In this case,
3436 // just make sure that the type referenced is compatible with the
3437 // right-hand side type. The caller is responsible for adjusting
3438 // lhsType so that the resulting expression does not have reference
3439 // type.
3440 if (const ReferenceType *lhsTypeRef = lhsType->getAsReferenceType()) {
3441 if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType))
3442 return Compatible;
3443 return Incompatible;
3444 }
3445
3446 if (lhsType->isObjCQualifiedIdType() || rhsType->isObjCQualifiedIdType()) {
3447 if (ObjCQualifiedIdTypesAreCompatible(lhsType, rhsType, false))
3448 return Compatible;
3449 // Relax integer conversions like we do for pointers below.
3450 if (rhsType->isIntegerType())
3451 return IntToPointer;
3452 if (lhsType->isIntegerType())
3453 return PointerToInt;
3454 return IncompatibleObjCQualifiedId;
3455 }
3456
|
| 3457 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type
3458 // to the same ExtVector type.
3459 if (lhsType->isExtVectorType()) {
3460 if (rhsType->isExtVectorType())
3461 return lhsType == rhsType ? Compatible : Incompatible;
3462 if (!rhsType->isVectorType() && rhsType->isArithmeticType())
3463 return Compatible;
3464 }
3465
|
3388 if (lhsType->isVectorType() || rhsType->isVectorType()) {
| 3466 if (lhsType->isVectorType() || rhsType->isVectorType()) {
|
3389 // For ExtVector, allow vector splats; float -> <n x float>
3390 if (const ExtVectorType *LV = lhsType->getAsExtVectorType())
3391 if (LV->getElementType() == rhsType)
3392 return Compatible;
3393
| |
3394 // If we are allowing lax vector conversions, and LHS and RHS are both
3395 // vectors, the total size only needs to be the same. This is a bitcast;
3396 // no bits are changed but the result type is different.
3397 if (getLangOptions().LaxVectorConversions &&
3398 lhsType->isVectorType() && rhsType->isVectorType()) {
3399 if (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType))
3400 return IncompatibleVectors;
3401 }
3402 return Incompatible;
3403 }
3404
3405 if (lhsType->isArithmeticType() && rhsType->isArithmeticType())
3406 return Compatible;
3407
3408 if (isa<PointerType>(lhsType)) {
3409 if (rhsType->isIntegerType())
3410 return IntToPointer;
3411
3412 if (isa<PointerType>(rhsType))
3413 return CheckPointerTypesForAssignment(lhsType, rhsType);
3414
3415 if (rhsType->getAsBlockPointerType()) {
3416 if (lhsType->getAsPointerType()->getPointeeType()->isVoidType())
3417 return Compatible;
3418
3419 // Treat block pointers as objects.
3420 if (getLangOptions().ObjC1 &&
3421 lhsType == Context.getCanonicalType(Context.getObjCIdType()))
3422 return Compatible;
3423 }
3424 return Incompatible;
3425 }
3426
3427 if (isa<BlockPointerType>(lhsType)) {
3428 if (rhsType->isIntegerType())
3429 return IntToBlockPointer;
3430
3431 // Treat block pointers as objects.
3432 if (getLangOptions().ObjC1 &&
3433 rhsType == Context.getCanonicalType(Context.getObjCIdType()))
3434 return Compatible;
3435
3436 if (rhsType->isBlockPointerType())
3437 return CheckBlockPointerTypesForAssignment(lhsType, rhsType);
3438
3439 if (const PointerType *RHSPT = rhsType->getAsPointerType()) {
3440 if (RHSPT->getPointeeType()->isVoidType())
3441 return Compatible;
3442 }
3443 return Incompatible;
3444 }
3445
3446 if (isa<PointerType>(rhsType)) {
3447 // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer.
3448 if (lhsType == Context.BoolTy)
3449 return Compatible;
3450
3451 if (lhsType->isIntegerType())
3452 return PointerToInt;
3453
3454 if (isa<PointerType>(lhsType))
3455 return CheckPointerTypesForAssignment(lhsType, rhsType);
3456
3457 if (isa<BlockPointerType>(lhsType) &&
3458 rhsType->getAsPointerType()->getPointeeType()->isVoidType())
3459 return Compatible;
3460 return Incompatible;
3461 }
3462
3463 if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) {
3464 if (Context.typesAreCompatible(lhsType, rhsType))
3465 return Compatible;
3466 }
3467 return Incompatible;
3468}
3469
3470/// \brief Constructs a transparent union from an expression that is
3471/// used to initialize the transparent union.
3472static void ConstructTransparentUnion(ASTContext &C, Expr *&E,
3473 QualType UnionType, FieldDecl *Field) {
3474 // Build an initializer list that designates the appropriate member
3475 // of the transparent union.
3476 InitListExpr *Initializer = new (C) InitListExpr(SourceLocation(),
3477 &E, 1,
3478 SourceLocation());
3479 Initializer->setType(UnionType);
3480 Initializer->setInitializedFieldInUnion(Field);
3481
3482 // Build a compound literal constructing a value of the transparent
3483 // union type from this initializer list.
3484 E = new (C) CompoundLiteralExpr(SourceLocation(), UnionType, Initializer,
3485 false);
3486}
3487
3488Sema::AssignConvertType
3489Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, Expr *&rExpr) {
3490 QualType FromType = rExpr->getType();
3491
3492 // If the ArgType is a Union type, we want to handle a potential
3493 // transparent_union GCC extension.
3494 const RecordType *UT = ArgType->getAsUnionType();
| 3467 // If we are allowing lax vector conversions, and LHS and RHS are both
3468 // vectors, the total size only needs to be the same. This is a bitcast;
3469 // no bits are changed but the result type is different.
3470 if (getLangOptions().LaxVectorConversions &&
3471 lhsType->isVectorType() && rhsType->isVectorType()) {
3472 if (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType))
3473 return IncompatibleVectors;
3474 }
3475 return Incompatible;
3476 }
3477
3478 if (lhsType->isArithmeticType() && rhsType->isArithmeticType())
3479 return Compatible;
3480
3481 if (isa<PointerType>(lhsType)) {
3482 if (rhsType->isIntegerType())
3483 return IntToPointer;
3484
3485 if (isa<PointerType>(rhsType))
3486 return CheckPointerTypesForAssignment(lhsType, rhsType);
3487
3488 if (rhsType->getAsBlockPointerType()) {
3489 if (lhsType->getAsPointerType()->getPointeeType()->isVoidType())
3490 return Compatible;
3491
3492 // Treat block pointers as objects.
3493 if (getLangOptions().ObjC1 &&
3494 lhsType == Context.getCanonicalType(Context.getObjCIdType()))
3495 return Compatible;
3496 }
3497 return Incompatible;
3498 }
3499
3500 if (isa<BlockPointerType>(lhsType)) {
3501 if (rhsType->isIntegerType())
3502 return IntToBlockPointer;
3503
3504 // Treat block pointers as objects.
3505 if (getLangOptions().ObjC1 &&
3506 rhsType == Context.getCanonicalType(Context.getObjCIdType()))
3507 return Compatible;
3508
3509 if (rhsType->isBlockPointerType())
3510 return CheckBlockPointerTypesForAssignment(lhsType, rhsType);
3511
3512 if (const PointerType *RHSPT = rhsType->getAsPointerType()) {
3513 if (RHSPT->getPointeeType()->isVoidType())
3514 return Compatible;
3515 }
3516 return Incompatible;
3517 }
3518
3519 if (isa<PointerType>(rhsType)) {
3520 // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer.
3521 if (lhsType == Context.BoolTy)
3522 return Compatible;
3523
3524 if (lhsType->isIntegerType())
3525 return PointerToInt;
3526
3527 if (isa<PointerType>(lhsType))
3528 return CheckPointerTypesForAssignment(lhsType, rhsType);
3529
3530 if (isa<BlockPointerType>(lhsType) &&
3531 rhsType->getAsPointerType()->getPointeeType()->isVoidType())
3532 return Compatible;
3533 return Incompatible;
3534 }
3535
3536 if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) {
3537 if (Context.typesAreCompatible(lhsType, rhsType))
3538 return Compatible;
3539 }
3540 return Incompatible;
3541}
3542
3543/// \brief Constructs a transparent union from an expression that is
3544/// used to initialize the transparent union.
3545static void ConstructTransparentUnion(ASTContext &C, Expr *&E,
3546 QualType UnionType, FieldDecl *Field) {
3547 // Build an initializer list that designates the appropriate member
3548 // of the transparent union.
3549 InitListExpr *Initializer = new (C) InitListExpr(SourceLocation(),
3550 &E, 1,
3551 SourceLocation());
3552 Initializer->setType(UnionType);
3553 Initializer->setInitializedFieldInUnion(Field);
3554
3555 // Build a compound literal constructing a value of the transparent
3556 // union type from this initializer list.
3557 E = new (C) CompoundLiteralExpr(SourceLocation(), UnionType, Initializer,
3558 false);
3559}
3560
3561Sema::AssignConvertType
3562Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, Expr *&rExpr) {
3563 QualType FromType = rExpr->getType();
3564
3565 // If the ArgType is a Union type, we want to handle a potential
3566 // transparent_union GCC extension.
3567 const RecordType *UT = ArgType->getAsUnionType();
|
3495 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>(Context))
| 3568 if (!UT || !UT->getDecl()->hasAttr())
|
3496 return Incompatible;
3497
3498 // The field to initialize within the transparent union.
3499 RecordDecl *UD = UT->getDecl();
3500 FieldDecl *InitField = 0;
3501 // It's compatible if the expression matches any of the fields.
| 3569 return Incompatible;
3570
3571 // The field to initialize within the transparent union.
3572 RecordDecl *UD = UT->getDecl();
3573 FieldDecl *InitField = 0;
3574 // It's compatible if the expression matches any of the fields.
|
3502 for (RecordDecl::field_iterator it = UD->field_begin(Context),
3503 itend = UD->field_end(Context);
| 3575 for (RecordDecl::field_iterator it = UD->field_begin(),
3576 itend = UD->field_end();
|
3504 it != itend; ++it) {
3505 if (it->getType()->isPointerType()) {
3506 // If the transparent union contains a pointer type, we allow:
3507 // 1) void pointer
3508 // 2) null pointer constant
3509 if (FromType->isPointerType())
3510 if (FromType->getAsPointerType()->getPointeeType()->isVoidType()) {
3511 ImpCastExprToType(rExpr, it->getType());
3512 InitField = *it;
3513 break;
3514 }
3515
3516 if (rExpr->isNullPointerConstant(Context)) {
3517 ImpCastExprToType(rExpr, it->getType());
3518 InitField = *it;
3519 break;
3520 }
3521 }
3522
3523 if (CheckAssignmentConstraints(it->getType(), rExpr->getType())
3524 == Compatible) {
3525 InitField = *it;
3526 break;
3527 }
3528 }
3529
3530 if (!InitField)
3531 return Incompatible;
3532
3533 ConstructTransparentUnion(Context, rExpr, ArgType, InitField);
3534 return Compatible;
3535}
3536
3537Sema::AssignConvertType
3538Sema::CheckSingleAssignmentConstraints(QualType lhsType, Expr *&rExpr) {
3539 if (getLangOptions().CPlusPlus) {
3540 if (!lhsType->isRecordType()) {
3541 // C++ 5.17p3: If the left operand is not of class type, the
3542 // expression is implicitly converted (C++ 4) to the
3543 // cv-unqualified type of the left operand.
3544 if (PerformImplicitConversion(rExpr, lhsType.getUnqualifiedType(),
3545 "assigning"))
3546 return Incompatible;
3547 return Compatible;
3548 }
3549
3550 // FIXME: Currently, we fall through and treat C++ classes like C
3551 // structures.
3552 }
3553
3554 // C99 6.5.16.1p1: the left operand is a pointer and the right is
3555 // a null pointer constant.
3556 if ((lhsType->isPointerType() ||
3557 lhsType->isObjCQualifiedIdType() ||
3558 lhsType->isBlockPointerType())
3559 && rExpr->isNullPointerConstant(Context)) {
3560 ImpCastExprToType(rExpr, lhsType);
3561 return Compatible;
3562 }
3563
3564 // This check seems unnatural, however it is necessary to ensure the proper
3565 // conversion of functions/arrays. If the conversion were done for all
3566 // DeclExpr's (created by ActOnIdentifierExpr), it would mess up the unary
3567 // expressions that surpress this implicit conversion (&, sizeof).
3568 //
3569 // Suppress this for references: C++ 8.5.3p5.
3570 if (!lhsType->isReferenceType())
3571 DefaultFunctionArrayConversion(rExpr);
3572
3573 Sema::AssignConvertType result =
3574 CheckAssignmentConstraints(lhsType, rExpr->getType());
3575
3576 // C99 6.5.16.1p2: The value of the right operand is converted to the
3577 // type of the assignment expression.
3578 // CheckAssignmentConstraints allows the left-hand side to be a reference,
3579 // so that we can use references in built-in functions even in C.
3580 // The getNonReferenceType() call makes sure that the resulting expression
3581 // does not have reference type.
3582 if (result != Incompatible && rExpr->getType() != lhsType)
3583 ImpCastExprToType(rExpr, lhsType.getNonReferenceType());
3584 return result;
3585}
3586
3587QualType Sema::InvalidOperands(SourceLocation Loc, Expr *&lex, Expr *&rex) {
3588 Diag(Loc, diag::err_typecheck_invalid_operands)
3589 << lex->getType() << rex->getType()
3590 << lex->getSourceRange() << rex->getSourceRange();
3591 return QualType();
3592}
3593
3594inline QualType Sema::CheckVectorOperands(SourceLocation Loc, Expr *&lex,
3595 Expr *&rex) {
3596 // For conversion purposes, we ignore any qualifiers.
3597 // For example, "const float" and "float" are equivalent.
3598 QualType lhsType =
3599 Context.getCanonicalType(lex->getType()).getUnqualifiedType();
3600 QualType rhsType =
3601 Context.getCanonicalType(rex->getType()).getUnqualifiedType();
3602
3603 // If the vector types are identical, return.
3604 if (lhsType == rhsType)
3605 return lhsType;
3606
3607 // Handle the case of a vector & extvector type of the same size and element
3608 // type. It would be nice if we only had one vector type someday.
3609 if (getLangOptions().LaxVectorConversions) {
3610 // FIXME: Should we warn here?
3611 if (const VectorType *LV = lhsType->getAsVectorType()) {
3612 if (const VectorType *RV = rhsType->getAsVectorType())
3613 if (LV->getElementType() == RV->getElementType() &&
3614 LV->getNumElements() == RV->getNumElements()) {
3615 return lhsType->isExtVectorType() ? lhsType : rhsType;
3616 }
3617 }
3618 }
3619
| 3577 it != itend; ++it) {
3578 if (it->getType()->isPointerType()) {
3579 // If the transparent union contains a pointer type, we allow:
3580 // 1) void pointer
3581 // 2) null pointer constant
3582 if (FromType->isPointerType())
3583 if (FromType->getAsPointerType()->getPointeeType()->isVoidType()) {
3584 ImpCastExprToType(rExpr, it->getType());
3585 InitField = *it;
3586 break;
3587 }
3588
3589 if (rExpr->isNullPointerConstant(Context)) {
3590 ImpCastExprToType(rExpr, it->getType());
3591 InitField = *it;
3592 break;
3593 }
3594 }
3595
3596 if (CheckAssignmentConstraints(it->getType(), rExpr->getType())
3597 == Compatible) {
3598 InitField = *it;
3599 break;
3600 }
3601 }
3602
3603 if (!InitField)
3604 return Incompatible;
3605
3606 ConstructTransparentUnion(Context, rExpr, ArgType, InitField);
3607 return Compatible;
3608}
3609
3610Sema::AssignConvertType
3611Sema::CheckSingleAssignmentConstraints(QualType lhsType, Expr *&rExpr) {
3612 if (getLangOptions().CPlusPlus) {
3613 if (!lhsType->isRecordType()) {
3614 // C++ 5.17p3: If the left operand is not of class type, the
3615 // expression is implicitly converted (C++ 4) to the
3616 // cv-unqualified type of the left operand.
3617 if (PerformImplicitConversion(rExpr, lhsType.getUnqualifiedType(),
3618 "assigning"))
3619 return Incompatible;
3620 return Compatible;
3621 }
3622
3623 // FIXME: Currently, we fall through and treat C++ classes like C
3624 // structures.
3625 }
3626
3627 // C99 6.5.16.1p1: the left operand is a pointer and the right is
3628 // a null pointer constant.
3629 if ((lhsType->isPointerType() ||
3630 lhsType->isObjCQualifiedIdType() ||
3631 lhsType->isBlockPointerType())
3632 && rExpr->isNullPointerConstant(Context)) {
3633 ImpCastExprToType(rExpr, lhsType);
3634 return Compatible;
3635 }
3636
3637 // This check seems unnatural, however it is necessary to ensure the proper
3638 // conversion of functions/arrays. If the conversion were done for all
3639 // DeclExpr's (created by ActOnIdentifierExpr), it would mess up the unary
3640 // expressions that surpress this implicit conversion (&, sizeof).
3641 //
3642 // Suppress this for references: C++ 8.5.3p5.
3643 if (!lhsType->isReferenceType())
3644 DefaultFunctionArrayConversion(rExpr);
3645
3646 Sema::AssignConvertType result =
3647 CheckAssignmentConstraints(lhsType, rExpr->getType());
3648
3649 // C99 6.5.16.1p2: The value of the right operand is converted to the
3650 // type of the assignment expression.
3651 // CheckAssignmentConstraints allows the left-hand side to be a reference,
3652 // so that we can use references in built-in functions even in C.
3653 // The getNonReferenceType() call makes sure that the resulting expression
3654 // does not have reference type.
3655 if (result != Incompatible && rExpr->getType() != lhsType)
3656 ImpCastExprToType(rExpr, lhsType.getNonReferenceType());
3657 return result;
3658}
3659
3660QualType Sema::InvalidOperands(SourceLocation Loc, Expr *&lex, Expr *&rex) {
3661 Diag(Loc, diag::err_typecheck_invalid_operands)
3662 << lex->getType() << rex->getType()
3663 << lex->getSourceRange() << rex->getSourceRange();
3664 return QualType();
3665}
3666
3667inline QualType Sema::CheckVectorOperands(SourceLocation Loc, Expr *&lex,
3668 Expr *&rex) {
3669 // For conversion purposes, we ignore any qualifiers.
3670 // For example, "const float" and "float" are equivalent.
3671 QualType lhsType =
3672 Context.getCanonicalType(lex->getType()).getUnqualifiedType();
3673 QualType rhsType =
3674 Context.getCanonicalType(rex->getType()).getUnqualifiedType();
3675
3676 // If the vector types are identical, return.
3677 if (lhsType == rhsType)
3678 return lhsType;
3679
3680 // Handle the case of a vector & extvector type of the same size and element
3681 // type. It would be nice if we only had one vector type someday.
3682 if (getLangOptions().LaxVectorConversions) {
3683 // FIXME: Should we warn here?
3684 if (const VectorType *LV = lhsType->getAsVectorType()) {
3685 if (const VectorType *RV = rhsType->getAsVectorType())
3686 if (LV->getElementType() == RV->getElementType() &&
3687 LV->getNumElements() == RV->getNumElements()) {
3688 return lhsType->isExtVectorType() ? lhsType : rhsType;
3689 }
3690 }
3691 }
3692
|
3620 // If the lhs is an extended vector and the rhs is a scalar of the same type
3621 // or a literal, promote the rhs to the vector type.
3622 if (const ExtVectorType *V = lhsType->getAsExtVectorType()) {
3623 QualType eltType = V->getElementType();
3624
3625 if ((eltType->getAsBuiltinType() == rhsType->getAsBuiltinType()) ||
3626 (eltType->isIntegerType() && isa<IntegerLiteral>(rex)) ||
3627 (eltType->isFloatingType() && isa<FloatingLiteral>(rex))) {
3628 ImpCastExprToType(rex, lhsType);
3629 return lhsType;
3630 }
| 3693 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can
3694 // swap back (so that we don't reverse the inputs to a subtract, for instance.
3695 bool swapped = false;
3696 if (rhsType->isExtVectorType()) {
3697 swapped = true;
3698 std::swap(rex, lex);
3699 std::swap(rhsType, lhsType);
|
3631 }
| 3700 }
|
3632
3633 // If the rhs is an extended vector and the lhs is a scalar of the same type,
3634 // promote the lhs to the vector type.
3635 if (const ExtVectorType *V = rhsType->getAsExtVectorType()) {
3636 QualType eltType = V->getElementType();
3637
3638 if ((eltType->getAsBuiltinType() == lhsType->getAsBuiltinType()) ||
3639 (eltType->isIntegerType() && isa<IntegerLiteral>(lex)) ||
3640 (eltType->isFloatingType() && isa<FloatingLiteral>(lex))) {
3641 ImpCastExprToType(lex, rhsType);
3642 return rhsType;
| 3701
3702 // Handle the case of an ext vector and scalar.
3703 if (const ExtVectorType *LV = lhsType->getAsExtVectorType()) {
3704 QualType EltTy = LV->getElementType();
3705 if (EltTy->isIntegralType() && rhsType->isIntegralType()) {
3706 if (Context.getIntegerTypeOrder(EltTy, rhsType) >= 0) {
3707 ImpCastExprToType(rex, lhsType);
3708 if (swapped) std::swap(rex, lex);
3709 return lhsType;
3710 }
|
3643 }
| 3711 }
|
| 3712 if (EltTy->isRealFloatingType() && rhsType->isScalarType() &&
3713 rhsType->isRealFloatingType()) {
3714 if (Context.getFloatingTypeOrder(EltTy, rhsType) >= 0) {
3715 ImpCastExprToType(rex, lhsType);
3716 if (swapped) std::swap(rex, lex);
3717 return lhsType;
3718 }
3719 }
|
3644 }
| 3720 }
|
3645
3646 // You cannot convert between vector values of different size.
| 3721
3722 // Vectors of different size or scalar and non-ext-vector are errors.
|
3647 Diag(Loc, diag::err_typecheck_vector_not_convertable)
3648 << lex->getType() << rex->getType()
3649 << lex->getSourceRange() << rex->getSourceRange();
3650 return QualType();
3651}
3652
3653inline QualType Sema::CheckMultiplyDivideOperands(
3654 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
3655{
3656 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
3657 return CheckVectorOperands(Loc, lex, rex);
3658
3659 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
3660
3661 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
3662 return compType;
3663 return InvalidOperands(Loc, lex, rex);
3664}
3665
3666inline QualType Sema::CheckRemainderOperands(
3667 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
3668{
3669 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3670 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
3671 return CheckVectorOperands(Loc, lex, rex);
3672 return InvalidOperands(Loc, lex, rex);
3673 }
3674
3675 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
3676
3677 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
3678 return compType;
3679 return InvalidOperands(Loc, lex, rex);
3680}
3681
3682inline QualType Sema::CheckAdditionOperands( // C99 6.5.6
3683 Expr *&lex, Expr *&rex, SourceLocation Loc, QualType* CompLHSTy)
3684{
3685 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3686 QualType compType = CheckVectorOperands(Loc, lex, rex);
3687 if (CompLHSTy) *CompLHSTy = compType;
3688 return compType;
3689 }
3690
3691 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
3692
3693 // handle the common case first (both operands are arithmetic).
3694 if (lex->getType()->isArithmeticType() &&
3695 rex->getType()->isArithmeticType()) {
3696 if (CompLHSTy) *CompLHSTy = compType;
3697 return compType;
3698 }
3699
3700 // Put any potential pointer into PExp
3701 Expr* PExp = lex, *IExp = rex;
3702 if (IExp->getType()->isPointerType())
3703 std::swap(PExp, IExp);
3704
3705 if (const PointerType *PTy = PExp->getType()->getAsPointerType()) {
3706 if (IExp->getType()->isIntegerType()) {
3707 QualType PointeeTy = PTy->getPointeeType();
3708 // Check for arithmetic on pointers to incomplete types.
3709 if (PointeeTy->isVoidType()) {
3710 if (getLangOptions().CPlusPlus) {
3711 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3712 << lex->getSourceRange() << rex->getSourceRange();
3713 return QualType();
3714 }
3715
3716 // GNU extension: arithmetic on pointer to void
3717 Diag(Loc, diag::ext_gnu_void_ptr)
3718 << lex->getSourceRange() << rex->getSourceRange();
3719 } else if (PointeeTy->isFunctionType()) {
3720 if (getLangOptions().CPlusPlus) {
3721 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3722 << lex->getType() << lex->getSourceRange();
3723 return QualType();
3724 }
3725
3726 // GNU extension: arithmetic on pointer to function
3727 Diag(Loc, diag::ext_gnu_ptr_func_arith)
3728 << lex->getType() << lex->getSourceRange();
3729 } else if (!PTy->isDependentType() &&
3730 RequireCompleteType(Loc, PointeeTy,
3731 diag::err_typecheck_arithmetic_incomplete_type,
3732 PExp->getSourceRange(), SourceRange(),
3733 PExp->getType()))
3734 return QualType();
3735
3736 // Diagnose bad cases where we step over interface counts.
3737 if (PointeeTy->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
3738 Diag(Loc, diag::err_arithmetic_nonfragile_interface)
3739 << PointeeTy << PExp->getSourceRange();
3740 return QualType();
3741 }
3742
3743 if (CompLHSTy) {
3744 QualType LHSTy = lex->getType();
3745 if (LHSTy->isPromotableIntegerType())
3746 LHSTy = Context.IntTy;
3747 else {
3748 QualType T = isPromotableBitField(lex, Context);
3749 if (!T.isNull())
3750 LHSTy = T;
3751 }
3752
3753 *CompLHSTy = LHSTy;
3754 }
3755 return PExp->getType();
3756 }
3757 }
3758
3759 return InvalidOperands(Loc, lex, rex);
3760}
3761
3762// C99 6.5.6
3763QualType Sema::CheckSubtractionOperands(Expr *&lex, Expr *&rex,
3764 SourceLocation Loc, QualType* CompLHSTy) {
3765 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3766 QualType compType = CheckVectorOperands(Loc, lex, rex);
3767 if (CompLHSTy) *CompLHSTy = compType;
3768 return compType;
3769 }
3770
3771 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
3772
3773 // Enforce type constraints: C99 6.5.6p3.
3774
3775 // Handle the common case first (both operands are arithmetic).
3776 if (lex->getType()->isArithmeticType()
3777 && rex->getType()->isArithmeticType()) {
3778 if (CompLHSTy) *CompLHSTy = compType;
3779 return compType;
3780 }
3781
3782 // Either ptr - int or ptr - ptr.
3783 if (const PointerType *LHSPTy = lex->getType()->getAsPointerType()) {
3784 QualType lpointee = LHSPTy->getPointeeType();
3785
3786 // The LHS must be an completely-defined object type.
3787
3788 bool ComplainAboutVoid = false;
3789 Expr *ComplainAboutFunc = 0;
3790 if (lpointee->isVoidType()) {
3791 if (getLangOptions().CPlusPlus) {
3792 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3793 << lex->getSourceRange() << rex->getSourceRange();
3794 return QualType();
3795 }
3796
3797 // GNU C extension: arithmetic on pointer to void
3798 ComplainAboutVoid = true;
3799 } else if (lpointee->isFunctionType()) {
3800 if (getLangOptions().CPlusPlus) {
3801 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3802 << lex->getType() << lex->getSourceRange();
3803 return QualType();
3804 }
3805
3806 // GNU C extension: arithmetic on pointer to function
3807 ComplainAboutFunc = lex;
3808 } else if (!lpointee->isDependentType() &&
3809 RequireCompleteType(Loc, lpointee,
3810 diag::err_typecheck_sub_ptr_object,
3811 lex->getSourceRange(),
3812 SourceRange(),
3813 lex->getType()))
3814 return QualType();
3815
3816 // Diagnose bad cases where we step over interface counts.
3817 if (lpointee->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
3818 Diag(Loc, diag::err_arithmetic_nonfragile_interface)
3819 << lpointee << lex->getSourceRange();
3820 return QualType();
3821 }
3822
3823 // The result type of a pointer-int computation is the pointer type.
3824 if (rex->getType()->isIntegerType()) {
3825 if (ComplainAboutVoid)
3826 Diag(Loc, diag::ext_gnu_void_ptr)
3827 << lex->getSourceRange() << rex->getSourceRange();
3828 if (ComplainAboutFunc)
3829 Diag(Loc, diag::ext_gnu_ptr_func_arith)
3830 << ComplainAboutFunc->getType()
3831 << ComplainAboutFunc->getSourceRange();
3832
3833 if (CompLHSTy) *CompLHSTy = lex->getType();
3834 return lex->getType();
3835 }
3836
3837 // Handle pointer-pointer subtractions.
3838 if (const PointerType *RHSPTy = rex->getType()->getAsPointerType()) {
3839 QualType rpointee = RHSPTy->getPointeeType();
3840
3841 // RHS must be a completely-type object type.
3842 // Handle the GNU void* extension.
3843 if (rpointee->isVoidType()) {
3844 if (getLangOptions().CPlusPlus) {
3845 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3846 << lex->getSourceRange() << rex->getSourceRange();
3847 return QualType();
3848 }
3849
3850 ComplainAboutVoid = true;
3851 } else if (rpointee->isFunctionType()) {
3852 if (getLangOptions().CPlusPlus) {
3853 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3854 << rex->getType() << rex->getSourceRange();
3855 return QualType();
3856 }
3857
3858 // GNU extension: arithmetic on pointer to function
3859 if (!ComplainAboutFunc)
3860 ComplainAboutFunc = rex;
3861 } else if (!rpointee->isDependentType() &&
3862 RequireCompleteType(Loc, rpointee,
3863 diag::err_typecheck_sub_ptr_object,
3864 rex->getSourceRange(),
3865 SourceRange(),
3866 rex->getType()))
3867 return QualType();
3868
3869 if (getLangOptions().CPlusPlus) {
3870 // Pointee types must be the same: C++ [expr.add]
3871 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
3872 Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
3873 << lex->getType() << rex->getType()
3874 << lex->getSourceRange() << rex->getSourceRange();
3875 return QualType();
3876 }
3877 } else {
3878 // Pointee types must be compatible C99 6.5.6p3
3879 if (!Context.typesAreCompatible(
3880 Context.getCanonicalType(lpointee).getUnqualifiedType(),
3881 Context.getCanonicalType(rpointee).getUnqualifiedType())) {
3882 Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
3883 << lex->getType() << rex->getType()
3884 << lex->getSourceRange() << rex->getSourceRange();
3885 return QualType();
3886 }
3887 }
3888
3889 if (ComplainAboutVoid)
3890 Diag(Loc, diag::ext_gnu_void_ptr)
3891 << lex->getSourceRange() << rex->getSourceRange();
3892 if (ComplainAboutFunc)
3893 Diag(Loc, diag::ext_gnu_ptr_func_arith)
3894 << ComplainAboutFunc->getType()
3895 << ComplainAboutFunc->getSourceRange();
3896
3897 if (CompLHSTy) *CompLHSTy = lex->getType();
3898 return Context.getPointerDiffType();
3899 }
3900 }
3901
3902 return InvalidOperands(Loc, lex, rex);
3903}
3904
3905// C99 6.5.7
3906QualType Sema::CheckShiftOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
3907 bool isCompAssign) {
3908 // C99 6.5.7p2: Each of the operands shall have integer type.
3909 if (!lex->getType()->isIntegerType() || !rex->getType()->isIntegerType())
3910 return InvalidOperands(Loc, lex, rex);
3911
3912 // Shifts don't perform usual arithmetic conversions, they just do integer
3913 // promotions on each operand. C99 6.5.7p3
3914 QualType LHSTy;
3915 if (lex->getType()->isPromotableIntegerType())
3916 LHSTy = Context.IntTy;
3917 else {
3918 LHSTy = isPromotableBitField(lex, Context);
3919 if (LHSTy.isNull())
3920 LHSTy = lex->getType();
3921 }
3922 if (!isCompAssign)
3923 ImpCastExprToType(lex, LHSTy);
3924
3925 UsualUnaryConversions(rex);
3926
3927 // "The type of the result is that of the promoted left operand."
3928 return LHSTy;
3929}
3930
3931// C99 6.5.8, C++ [expr.rel]
3932QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
3933 unsigned OpaqueOpc, bool isRelational) {
3934 BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)OpaqueOpc;
3935
3936 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
3937 return CheckVectorCompareOperands(lex, rex, Loc, isRelational);
3938
3939 // C99 6.5.8p3 / C99 6.5.9p4
3940 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
3941 UsualArithmeticConversions(lex, rex);
3942 else {
3943 UsualUnaryConversions(lex);
3944 UsualUnaryConversions(rex);
3945 }
3946 QualType lType = lex->getType();
3947 QualType rType = rex->getType();
3948
3949 if (!lType->isFloatingType()
3950 && !(lType->isBlockPointerType() && isRelational)) {
3951 // For non-floating point types, check for self-comparisons of the form
3952 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
3953 // often indicate logic errors in the program.
3954 // NOTE: Don't warn about comparisons of enum constants. These can arise
3955 // from macro expansions, and are usually quite deliberate.
3956 Expr *LHSStripped = lex->IgnoreParens();
3957 Expr *RHSStripped = rex->IgnoreParens();
3958 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped))
3959 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped))
3960 if (DRL->getDecl() == DRR->getDecl() &&
3961 !isa<EnumConstantDecl>(DRL->getDecl()))
3962 Diag(Loc, diag::warn_selfcomparison);
3963
3964 if (isa<CastExpr>(LHSStripped))
3965 LHSStripped = LHSStripped->IgnoreParenCasts();
3966 if (isa<CastExpr>(RHSStripped))
3967 RHSStripped = RHSStripped->IgnoreParenCasts();
3968
3969 // Warn about comparisons against a string constant (unless the other
3970 // operand is null), the user probably wants strcmp.
3971 Expr *literalString = 0;
3972 Expr *literalStringStripped = 0;
3973 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
3974 !RHSStripped->isNullPointerConstant(Context)) {
3975 literalString = lex;
3976 literalStringStripped = LHSStripped;
3977 }
3978 else if ((isa<StringLiteral>(RHSStripped) ||
3979 isa<ObjCEncodeExpr>(RHSStripped)) &&
3980 !LHSStripped->isNullPointerConstant(Context)) {
3981 literalString = rex;
3982 literalStringStripped = RHSStripped;
3983 }
3984
3985 if (literalString) {
3986 std::string resultComparison;
3987 switch (Opc) {
3988 case BinaryOperator::LT: resultComparison = ") < 0"; break;
3989 case BinaryOperator::GT: resultComparison = ") > 0"; break;
3990 case BinaryOperator::LE: resultComparison = ") <= 0"; break;
3991 case BinaryOperator::GE: resultComparison = ") >= 0"; break;
3992 case BinaryOperator::EQ: resultComparison = ") == 0"; break;
3993 case BinaryOperator::NE: resultComparison = ") != 0"; break;
3994 default: assert(false && "Invalid comparison operator");
3995 }
3996 Diag(Loc, diag::warn_stringcompare)
3997 << isa<ObjCEncodeExpr>(literalStringStripped)
3998 << literalString->getSourceRange()
3999 << CodeModificationHint::CreateReplacement(SourceRange(Loc), ", ")
4000 << CodeModificationHint::CreateInsertion(lex->getLocStart(),
4001 "strcmp(")
4002 << CodeModificationHint::CreateInsertion(
4003 PP.getLocForEndOfToken(rex->getLocEnd()),
4004 resultComparison);
4005 }
4006 }
4007
4008 // The result of comparisons is 'bool' in C++, 'int' in C.
4009 QualType ResultTy = getLangOptions().CPlusPlus? Context.BoolTy :Context.IntTy;
4010
4011 if (isRelational) {
4012 if (lType->isRealType() && rType->isRealType())
4013 return ResultTy;
4014 } else {
4015 // Check for comparisons of floating point operands using != and ==.
4016 if (lType->isFloatingType()) {
4017 assert(rType->isFloatingType());
4018 CheckFloatComparison(Loc,lex,rex);
4019 }
4020
4021 if (lType->isArithmeticType() && rType->isArithmeticType())
4022 return ResultTy;
4023 }
4024
4025 bool LHSIsNull = lex->isNullPointerConstant(Context);
4026 bool RHSIsNull = rex->isNullPointerConstant(Context);
4027
4028 // All of the following pointer related warnings are GCC extensions, except
4029 // when handling null pointer constants. One day, we can consider making them
4030 // errors (when -pedantic-errors is enabled).
4031 if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2
4032 QualType LCanPointeeTy =
4033 Context.getCanonicalType(lType->getAsPointerType()->getPointeeType());
4034 QualType RCanPointeeTy =
4035 Context.getCanonicalType(rType->getAsPointerType()->getPointeeType());
4036
| 3723 Diag(Loc, diag::err_typecheck_vector_not_convertable)
3724 << lex->getType() << rex->getType()
3725 << lex->getSourceRange() << rex->getSourceRange();
3726 return QualType();
3727}
3728
3729inline QualType Sema::CheckMultiplyDivideOperands(
3730 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
3731{
3732 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
3733 return CheckVectorOperands(Loc, lex, rex);
3734
3735 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
3736
3737 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
3738 return compType;
3739 return InvalidOperands(Loc, lex, rex);
3740}
3741
3742inline QualType Sema::CheckRemainderOperands(
3743 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
3744{
3745 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3746 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
3747 return CheckVectorOperands(Loc, lex, rex);
3748 return InvalidOperands(Loc, lex, rex);
3749 }
3750
3751 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
3752
3753 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
3754 return compType;
3755 return InvalidOperands(Loc, lex, rex);
3756}
3757
3758inline QualType Sema::CheckAdditionOperands( // C99 6.5.6
3759 Expr *&lex, Expr *&rex, SourceLocation Loc, QualType* CompLHSTy)
3760{
3761 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3762 QualType compType = CheckVectorOperands(Loc, lex, rex);
3763 if (CompLHSTy) *CompLHSTy = compType;
3764 return compType;
3765 }
3766
3767 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
3768
3769 // handle the common case first (both operands are arithmetic).
3770 if (lex->getType()->isArithmeticType() &&
3771 rex->getType()->isArithmeticType()) {
3772 if (CompLHSTy) *CompLHSTy = compType;
3773 return compType;
3774 }
3775
3776 // Put any potential pointer into PExp
3777 Expr* PExp = lex, *IExp = rex;
3778 if (IExp->getType()->isPointerType())
3779 std::swap(PExp, IExp);
3780
3781 if (const PointerType *PTy = PExp->getType()->getAsPointerType()) {
3782 if (IExp->getType()->isIntegerType()) {
3783 QualType PointeeTy = PTy->getPointeeType();
3784 // Check for arithmetic on pointers to incomplete types.
3785 if (PointeeTy->isVoidType()) {
3786 if (getLangOptions().CPlusPlus) {
3787 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3788 << lex->getSourceRange() << rex->getSourceRange();
3789 return QualType();
3790 }
3791
3792 // GNU extension: arithmetic on pointer to void
3793 Diag(Loc, diag::ext_gnu_void_ptr)
3794 << lex->getSourceRange() << rex->getSourceRange();
3795 } else if (PointeeTy->isFunctionType()) {
3796 if (getLangOptions().CPlusPlus) {
3797 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3798 << lex->getType() << lex->getSourceRange();
3799 return QualType();
3800 }
3801
3802 // GNU extension: arithmetic on pointer to function
3803 Diag(Loc, diag::ext_gnu_ptr_func_arith)
3804 << lex->getType() << lex->getSourceRange();
3805 } else if (!PTy->isDependentType() &&
3806 RequireCompleteType(Loc, PointeeTy,
3807 diag::err_typecheck_arithmetic_incomplete_type,
3808 PExp->getSourceRange(), SourceRange(),
3809 PExp->getType()))
3810 return QualType();
3811
3812 // Diagnose bad cases where we step over interface counts.
3813 if (PointeeTy->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
3814 Diag(Loc, diag::err_arithmetic_nonfragile_interface)
3815 << PointeeTy << PExp->getSourceRange();
3816 return QualType();
3817 }
3818
3819 if (CompLHSTy) {
3820 QualType LHSTy = lex->getType();
3821 if (LHSTy->isPromotableIntegerType())
3822 LHSTy = Context.IntTy;
3823 else {
3824 QualType T = isPromotableBitField(lex, Context);
3825 if (!T.isNull())
3826 LHSTy = T;
3827 }
3828
3829 *CompLHSTy = LHSTy;
3830 }
3831 return PExp->getType();
3832 }
3833 }
3834
3835 return InvalidOperands(Loc, lex, rex);
3836}
3837
3838// C99 6.5.6
3839QualType Sema::CheckSubtractionOperands(Expr *&lex, Expr *&rex,
3840 SourceLocation Loc, QualType* CompLHSTy) {
3841 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) {
3842 QualType compType = CheckVectorOperands(Loc, lex, rex);
3843 if (CompLHSTy) *CompLHSTy = compType;
3844 return compType;
3845 }
3846
3847 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy);
3848
3849 // Enforce type constraints: C99 6.5.6p3.
3850
3851 // Handle the common case first (both operands are arithmetic).
3852 if (lex->getType()->isArithmeticType()
3853 && rex->getType()->isArithmeticType()) {
3854 if (CompLHSTy) *CompLHSTy = compType;
3855 return compType;
3856 }
3857
3858 // Either ptr - int or ptr - ptr.
3859 if (const PointerType *LHSPTy = lex->getType()->getAsPointerType()) {
3860 QualType lpointee = LHSPTy->getPointeeType();
3861
3862 // The LHS must be an completely-defined object type.
3863
3864 bool ComplainAboutVoid = false;
3865 Expr *ComplainAboutFunc = 0;
3866 if (lpointee->isVoidType()) {
3867 if (getLangOptions().CPlusPlus) {
3868 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3869 << lex->getSourceRange() << rex->getSourceRange();
3870 return QualType();
3871 }
3872
3873 // GNU C extension: arithmetic on pointer to void
3874 ComplainAboutVoid = true;
3875 } else if (lpointee->isFunctionType()) {
3876 if (getLangOptions().CPlusPlus) {
3877 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3878 << lex->getType() << lex->getSourceRange();
3879 return QualType();
3880 }
3881
3882 // GNU C extension: arithmetic on pointer to function
3883 ComplainAboutFunc = lex;
3884 } else if (!lpointee->isDependentType() &&
3885 RequireCompleteType(Loc, lpointee,
3886 diag::err_typecheck_sub_ptr_object,
3887 lex->getSourceRange(),
3888 SourceRange(),
3889 lex->getType()))
3890 return QualType();
3891
3892 // Diagnose bad cases where we step over interface counts.
3893 if (lpointee->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) {
3894 Diag(Loc, diag::err_arithmetic_nonfragile_interface)
3895 << lpointee << lex->getSourceRange();
3896 return QualType();
3897 }
3898
3899 // The result type of a pointer-int computation is the pointer type.
3900 if (rex->getType()->isIntegerType()) {
3901 if (ComplainAboutVoid)
3902 Diag(Loc, diag::ext_gnu_void_ptr)
3903 << lex->getSourceRange() << rex->getSourceRange();
3904 if (ComplainAboutFunc)
3905 Diag(Loc, diag::ext_gnu_ptr_func_arith)
3906 << ComplainAboutFunc->getType()
3907 << ComplainAboutFunc->getSourceRange();
3908
3909 if (CompLHSTy) *CompLHSTy = lex->getType();
3910 return lex->getType();
3911 }
3912
3913 // Handle pointer-pointer subtractions.
3914 if (const PointerType *RHSPTy = rex->getType()->getAsPointerType()) {
3915 QualType rpointee = RHSPTy->getPointeeType();
3916
3917 // RHS must be a completely-type object type.
3918 // Handle the GNU void* extension.
3919 if (rpointee->isVoidType()) {
3920 if (getLangOptions().CPlusPlus) {
3921 Diag(Loc, diag::err_typecheck_pointer_arith_void_type)
3922 << lex->getSourceRange() << rex->getSourceRange();
3923 return QualType();
3924 }
3925
3926 ComplainAboutVoid = true;
3927 } else if (rpointee->isFunctionType()) {
3928 if (getLangOptions().CPlusPlus) {
3929 Diag(Loc, diag::err_typecheck_pointer_arith_function_type)
3930 << rex->getType() << rex->getSourceRange();
3931 return QualType();
3932 }
3933
3934 // GNU extension: arithmetic on pointer to function
3935 if (!ComplainAboutFunc)
3936 ComplainAboutFunc = rex;
3937 } else if (!rpointee->isDependentType() &&
3938 RequireCompleteType(Loc, rpointee,
3939 diag::err_typecheck_sub_ptr_object,
3940 rex->getSourceRange(),
3941 SourceRange(),
3942 rex->getType()))
3943 return QualType();
3944
3945 if (getLangOptions().CPlusPlus) {
3946 // Pointee types must be the same: C++ [expr.add]
3947 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
3948 Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
3949 << lex->getType() << rex->getType()
3950 << lex->getSourceRange() << rex->getSourceRange();
3951 return QualType();
3952 }
3953 } else {
3954 // Pointee types must be compatible C99 6.5.6p3
3955 if (!Context.typesAreCompatible(
3956 Context.getCanonicalType(lpointee).getUnqualifiedType(),
3957 Context.getCanonicalType(rpointee).getUnqualifiedType())) {
3958 Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
3959 << lex->getType() << rex->getType()
3960 << lex->getSourceRange() << rex->getSourceRange();
3961 return QualType();
3962 }
3963 }
3964
3965 if (ComplainAboutVoid)
3966 Diag(Loc, diag::ext_gnu_void_ptr)
3967 << lex->getSourceRange() << rex->getSourceRange();
3968 if (ComplainAboutFunc)
3969 Diag(Loc, diag::ext_gnu_ptr_func_arith)
3970 << ComplainAboutFunc->getType()
3971 << ComplainAboutFunc->getSourceRange();
3972
3973 if (CompLHSTy) *CompLHSTy = lex->getType();
3974 return Context.getPointerDiffType();
3975 }
3976 }
3977
3978 return InvalidOperands(Loc, lex, rex);
3979}
3980
3981// C99 6.5.7
3982QualType Sema::CheckShiftOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
3983 bool isCompAssign) {
3984 // C99 6.5.7p2: Each of the operands shall have integer type.
3985 if (!lex->getType()->isIntegerType() || !rex->getType()->isIntegerType())
3986 return InvalidOperands(Loc, lex, rex);
3987
3988 // Shifts don't perform usual arithmetic conversions, they just do integer
3989 // promotions on each operand. C99 6.5.7p3
3990 QualType LHSTy;
3991 if (lex->getType()->isPromotableIntegerType())
3992 LHSTy = Context.IntTy;
3993 else {
3994 LHSTy = isPromotableBitField(lex, Context);
3995 if (LHSTy.isNull())
3996 LHSTy = lex->getType();
3997 }
3998 if (!isCompAssign)
3999 ImpCastExprToType(lex, LHSTy);
4000
4001 UsualUnaryConversions(rex);
4002
4003 // "The type of the result is that of the promoted left operand."
4004 return LHSTy;
4005}
4006
4007// C99 6.5.8, C++ [expr.rel]
4008QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc,
4009 unsigned OpaqueOpc, bool isRelational) {
4010 BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)OpaqueOpc;
4011
4012 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
4013 return CheckVectorCompareOperands(lex, rex, Loc, isRelational);
4014
4015 // C99 6.5.8p3 / C99 6.5.9p4
4016 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType())
4017 UsualArithmeticConversions(lex, rex);
4018 else {
4019 UsualUnaryConversions(lex);
4020 UsualUnaryConversions(rex);
4021 }
4022 QualType lType = lex->getType();
4023 QualType rType = rex->getType();
4024
4025 if (!lType->isFloatingType()
4026 && !(lType->isBlockPointerType() && isRelational)) {
4027 // For non-floating point types, check for self-comparisons of the form
4028 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
4029 // often indicate logic errors in the program.
4030 // NOTE: Don't warn about comparisons of enum constants. These can arise
4031 // from macro expansions, and are usually quite deliberate.
4032 Expr *LHSStripped = lex->IgnoreParens();
4033 Expr *RHSStripped = rex->IgnoreParens();
4034 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped))
4035 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped))
4036 if (DRL->getDecl() == DRR->getDecl() &&
4037 !isa<EnumConstantDecl>(DRL->getDecl()))
4038 Diag(Loc, diag::warn_selfcomparison);
4039
4040 if (isa<CastExpr>(LHSStripped))
4041 LHSStripped = LHSStripped->IgnoreParenCasts();
4042 if (isa<CastExpr>(RHSStripped))
4043 RHSStripped = RHSStripped->IgnoreParenCasts();
4044
4045 // Warn about comparisons against a string constant (unless the other
4046 // operand is null), the user probably wants strcmp.
4047 Expr *literalString = 0;
4048 Expr *literalStringStripped = 0;
4049 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
4050 !RHSStripped->isNullPointerConstant(Context)) {
4051 literalString = lex;
4052 literalStringStripped = LHSStripped;
4053 }
4054 else if ((isa<StringLiteral>(RHSStripped) ||
4055 isa<ObjCEncodeExpr>(RHSStripped)) &&
4056 !LHSStripped->isNullPointerConstant(Context)) {
4057 literalString = rex;
4058 literalStringStripped = RHSStripped;
4059 }
4060
4061 if (literalString) {
4062 std::string resultComparison;
4063 switch (Opc) {
4064 case BinaryOperator::LT: resultComparison = ") < 0"; break;
4065 case BinaryOperator::GT: resultComparison = ") > 0"; break;
4066 case BinaryOperator::LE: resultComparison = ") <= 0"; break;
4067 case BinaryOperator::GE: resultComparison = ") >= 0"; break;
4068 case BinaryOperator::EQ: resultComparison = ") == 0"; break;
4069 case BinaryOperator::NE: resultComparison = ") != 0"; break;
4070 default: assert(false && "Invalid comparison operator");
4071 }
4072 Diag(Loc, diag::warn_stringcompare)
4073 << isa<ObjCEncodeExpr>(literalStringStripped)
4074 << literalString->getSourceRange()
4075 << CodeModificationHint::CreateReplacement(SourceRange(Loc), ", ")
4076 << CodeModificationHint::CreateInsertion(lex->getLocStart(),
4077 "strcmp(")
4078 << CodeModificationHint::CreateInsertion(
4079 PP.getLocForEndOfToken(rex->getLocEnd()),
4080 resultComparison);
4081 }
4082 }
4083
4084 // The result of comparisons is 'bool' in C++, 'int' in C.
4085 QualType ResultTy = getLangOptions().CPlusPlus? Context.BoolTy :Context.IntTy;
4086
4087 if (isRelational) {
4088 if (lType->isRealType() && rType->isRealType())
4089 return ResultTy;
4090 } else {
4091 // Check for comparisons of floating point operands using != and ==.
4092 if (lType->isFloatingType()) {
4093 assert(rType->isFloatingType());
4094 CheckFloatComparison(Loc,lex,rex);
4095 }
4096
4097 if (lType->isArithmeticType() && rType->isArithmeticType())
4098 return ResultTy;
4099 }
4100
4101 bool LHSIsNull = lex->isNullPointerConstant(Context);
4102 bool RHSIsNull = rex->isNullPointerConstant(Context);
4103
4104 // All of the following pointer related warnings are GCC extensions, except
4105 // when handling null pointer constants. One day, we can consider making them
4106 // errors (when -pedantic-errors is enabled).
4107 if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2
4108 QualType LCanPointeeTy =
4109 Context.getCanonicalType(lType->getAsPointerType()->getPointeeType());
4110 QualType RCanPointeeTy =
4111 Context.getCanonicalType(rType->getAsPointerType()->getPointeeType());
4112
|
| 4113 if (rType->isFunctionPointerType() || lType->isFunctionPointerType()) {
4114 if (isRelational) {
4115 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers)
4116 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4117 }
4118 }
4119 if (((!LHSIsNull || isRelational) && LCanPointeeTy->isVoidType()) !=
4120 ((!RHSIsNull || isRelational) && RCanPointeeTy->isVoidType())) {
4121 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
4122 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4123 }
|
4037 // Simple check: if the pointee types are identical, we're done.
4038 if (LCanPointeeTy == RCanPointeeTy)
4039 return ResultTy;
4040
4041 if (getLangOptions().CPlusPlus) {
4042 // C++ [expr.rel]p2:
4043 // [...] Pointer conversions (4.10) and qualification
4044 // conversions (4.4) are performed on pointer operands (or on
4045 // a pointer operand and a null pointer constant) to bring
4046 // them to their composite pointer type. [...]
4047 //
4048 // C++ [expr.eq]p2 uses the same notion for (in)equality
4049 // comparisons of pointers.
4050 QualType T = FindCompositePointerType(lex, rex);
4051 if (T.isNull()) {
4052 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers)
4053 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4054 return QualType();
4055 }
4056
4057 ImpCastExprToType(lex, T);
4058 ImpCastExprToType(rex, T);
4059 return ResultTy;
4060 }
4061
4062 if (!LHSIsNull && !RHSIsNull && // C99 6.5.9p2
4063 !LCanPointeeTy->isVoidType() && !RCanPointeeTy->isVoidType() &&
4064 !Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
4065 RCanPointeeTy.getUnqualifiedType()) &&
4066 !Context.areComparableObjCPointerTypes(lType, rType)) {
4067 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
4068 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4069 }
4070 ImpCastExprToType(rex, lType); // promote the pointer to pointer
4071 return ResultTy;
4072 }
4073 // C++ allows comparison of pointers with null pointer constants.
4074 if (getLangOptions().CPlusPlus) {
4075 if (lType->isPointerType() && RHSIsNull) {
4076 ImpCastExprToType(rex, lType);
4077 return ResultTy;
4078 }
4079 if (rType->isPointerType() && LHSIsNull) {
4080 ImpCastExprToType(lex, rType);
4081 return ResultTy;
4082 }
4083 // And comparison of nullptr_t with itself.
4084 if (lType->isNullPtrType() && rType->isNullPtrType())
4085 return ResultTy;
4086 }
4087 // Handle block pointer types.
4088 if (!isRelational && lType->isBlockPointerType() && rType->isBlockPointerType()) {
4089 QualType lpointee = lType->getAsBlockPointerType()->getPointeeType();
4090 QualType rpointee = rType->getAsBlockPointerType()->getPointeeType();
4091
4092 if (!LHSIsNull && !RHSIsNull &&
4093 !Context.typesAreCompatible(lpointee, rpointee)) {
4094 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
4095 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4096 }
4097 ImpCastExprToType(rex, lType); // promote the pointer to pointer
4098 return ResultTy;
4099 }
4100 // Allow block pointers to be compared with null pointer constants.
4101 if (!isRelational
4102 && ((lType->isBlockPointerType() && rType->isPointerType())
4103 || (lType->isPointerType() && rType->isBlockPointerType()))) {
4104 if (!LHSIsNull && !RHSIsNull) {
4105 if (!((rType->isPointerType() && rType->getAsPointerType()
4106 ->getPointeeType()->isVoidType())
4107 || (lType->isPointerType() && lType->getAsPointerType()
4108 ->getPointeeType()->isVoidType())))
4109 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
4110 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4111 }
4112 ImpCastExprToType(rex, lType); // promote the pointer to pointer
4113 return ResultTy;
4114 }
4115
4116 if ((lType->isObjCQualifiedIdType() || rType->isObjCQualifiedIdType())) {
4117 if (lType->isPointerType() || rType->isPointerType()) {
4118 const PointerType *LPT = lType->getAsPointerType();
4119 const PointerType *RPT = rType->getAsPointerType();
4120 bool LPtrToVoid = LPT ?
4121 Context.getCanonicalType(LPT->getPointeeType())->isVoidType() : false;
4122 bool RPtrToVoid = RPT ?
4123 Context.getCanonicalType(RPT->getPointeeType())->isVoidType() : false;
4124
4125 if (!LPtrToVoid && !RPtrToVoid &&
4126 !Context.typesAreCompatible(lType, rType)) {
4127 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
4128 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4129 ImpCastExprToType(rex, lType);
4130 return ResultTy;
4131 }
4132 ImpCastExprToType(rex, lType);
4133 return ResultTy;
4134 }
4135 if (ObjCQualifiedIdTypesAreCompatible(lType, rType, true)) {
4136 ImpCastExprToType(rex, lType);
4137 return ResultTy;
4138 } else {
4139 if ((lType->isObjCQualifiedIdType() && rType->isObjCQualifiedIdType())) {
4140 Diag(Loc, diag::warn_incompatible_qualified_id_operands)
4141 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4142 ImpCastExprToType(rex, lType);
4143 return ResultTy;
4144 }
4145 }
4146 }
4147 if ((lType->isPointerType() || lType->isObjCQualifiedIdType()) &&
4148 rType->isIntegerType()) {
| 4124 // Simple check: if the pointee types are identical, we're done.
4125 if (LCanPointeeTy == RCanPointeeTy)
4126 return ResultTy;
4127
4128 if (getLangOptions().CPlusPlus) {
4129 // C++ [expr.rel]p2:
4130 // [...] Pointer conversions (4.10) and qualification
4131 // conversions (4.4) are performed on pointer operands (or on
4132 // a pointer operand and a null pointer constant) to bring
4133 // them to their composite pointer type. [...]
4134 //
4135 // C++ [expr.eq]p2 uses the same notion for (in)equality
4136 // comparisons of pointers.
4137 QualType T = FindCompositePointerType(lex, rex);
4138 if (T.isNull()) {
4139 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers)
4140 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4141 return QualType();
4142 }
4143
4144 ImpCastExprToType(lex, T);
4145 ImpCastExprToType(rex, T);
4146 return ResultTy;
4147 }
4148
4149 if (!LHSIsNull && !RHSIsNull && // C99 6.5.9p2
4150 !LCanPointeeTy->isVoidType() && !RCanPointeeTy->isVoidType() &&
4151 !Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
4152 RCanPointeeTy.getUnqualifiedType()) &&
4153 !Context.areComparableObjCPointerTypes(lType, rType)) {
4154 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
4155 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4156 }
4157 ImpCastExprToType(rex, lType); // promote the pointer to pointer
4158 return ResultTy;
4159 }
4160 // C++ allows comparison of pointers with null pointer constants.
4161 if (getLangOptions().CPlusPlus) {
4162 if (lType->isPointerType() && RHSIsNull) {
4163 ImpCastExprToType(rex, lType);
4164 return ResultTy;
4165 }
4166 if (rType->isPointerType() && LHSIsNull) {
4167 ImpCastExprToType(lex, rType);
4168 return ResultTy;
4169 }
4170 // And comparison of nullptr_t with itself.
4171 if (lType->isNullPtrType() && rType->isNullPtrType())
4172 return ResultTy;
4173 }
4174 // Handle block pointer types.
4175 if (!isRelational && lType->isBlockPointerType() && rType->isBlockPointerType()) {
4176 QualType lpointee = lType->getAsBlockPointerType()->getPointeeType();
4177 QualType rpointee = rType->getAsBlockPointerType()->getPointeeType();
4178
4179 if (!LHSIsNull && !RHSIsNull &&
4180 !Context.typesAreCompatible(lpointee, rpointee)) {
4181 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
4182 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4183 }
4184 ImpCastExprToType(rex, lType); // promote the pointer to pointer
4185 return ResultTy;
4186 }
4187 // Allow block pointers to be compared with null pointer constants.
4188 if (!isRelational
4189 && ((lType->isBlockPointerType() && rType->isPointerType())
4190 || (lType->isPointerType() && rType->isBlockPointerType()))) {
4191 if (!LHSIsNull && !RHSIsNull) {
4192 if (!((rType->isPointerType() && rType->getAsPointerType()
4193 ->getPointeeType()->isVoidType())
4194 || (lType->isPointerType() && lType->getAsPointerType()
4195 ->getPointeeType()->isVoidType())))
4196 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
4197 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4198 }
4199 ImpCastExprToType(rex, lType); // promote the pointer to pointer
4200 return ResultTy;
4201 }
4202
4203 if ((lType->isObjCQualifiedIdType() || rType->isObjCQualifiedIdType())) {
4204 if (lType->isPointerType() || rType->isPointerType()) {
4205 const PointerType *LPT = lType->getAsPointerType();
4206 const PointerType *RPT = rType->getAsPointerType();
4207 bool LPtrToVoid = LPT ?
4208 Context.getCanonicalType(LPT->getPointeeType())->isVoidType() : false;
4209 bool RPtrToVoid = RPT ?
4210 Context.getCanonicalType(RPT->getPointeeType())->isVoidType() : false;
4211
4212 if (!LPtrToVoid && !RPtrToVoid &&
4213 !Context.typesAreCompatible(lType, rType)) {
4214 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers)
4215 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4216 ImpCastExprToType(rex, lType);
4217 return ResultTy;
4218 }
4219 ImpCastExprToType(rex, lType);
4220 return ResultTy;
4221 }
4222 if (ObjCQualifiedIdTypesAreCompatible(lType, rType, true)) {
4223 ImpCastExprToType(rex, lType);
4224 return ResultTy;
4225 } else {
4226 if ((lType->isObjCQualifiedIdType() && rType->isObjCQualifiedIdType())) {
4227 Diag(Loc, diag::warn_incompatible_qualified_id_operands)
4228 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4229 ImpCastExprToType(rex, lType);
4230 return ResultTy;
4231 }
4232 }
4233 }
4234 if ((lType->isPointerType() || lType->isObjCQualifiedIdType()) &&
4235 rType->isIntegerType()) {
|
4149 if (!RHSIsNull)
| 4236 if (isRelational)
4237 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_pointer_integer)
4238 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4239 else if (!RHSIsNull)
|
4150 Diag(Loc, diag::ext_typecheck_comparison_of_pointer_integer)
4151 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4152 ImpCastExprToType(rex, lType); // promote the integer to pointer
4153 return ResultTy;
4154 }
4155 if (lType->isIntegerType() &&
4156 (rType->isPointerType() || rType->isObjCQualifiedIdType())) {
| 4240 Diag(Loc, diag::ext_typecheck_comparison_of_pointer_integer)
4241 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4242 ImpCastExprToType(rex, lType); // promote the integer to pointer
4243 return ResultTy;
4244 }
4245 if (lType->isIntegerType() &&
4246 (rType->isPointerType() || rType->isObjCQualifiedIdType())) {
|
4157 if (!LHSIsNull)
| 4247 if (isRelational)
4248 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_pointer_integer)
4249 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4250 else if (!LHSIsNull)
|
4158 Diag(Loc, diag::ext_typecheck_comparison_of_pointer_integer)
4159 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4160 ImpCastExprToType(lex, rType); // promote the integer to pointer
4161 return ResultTy;
4162 }
4163 // Handle block pointers.
4164 if (!isRelational && RHSIsNull
4165 && lType->isBlockPointerType() && rType->isIntegerType()) {
4166 ImpCastExprToType(rex, lType); // promote the integer to pointer
4167 return ResultTy;
4168 }
4169 if (!isRelational && LHSIsNull
4170 && lType->isIntegerType() && rType->isBlockPointerType()) {
4171 ImpCastExprToType(lex, rType); // promote the integer to pointer
4172 return ResultTy;
4173 }
4174 return InvalidOperands(Loc, lex, rex);
4175}
4176
4177/// CheckVectorCompareOperands - vector comparisons are a clang extension that
4178/// operates on extended vector types. Instead of producing an IntTy result,
4179/// like a scalar comparison, a vector comparison produces a vector of integer
4180/// types.
4181QualType Sema::CheckVectorCompareOperands(Expr *&lex, Expr *&rex,
4182 SourceLocation Loc,
4183 bool isRelational) {
4184 // Check to make sure we're operating on vectors of the same type and width,
4185 // Allowing one side to be a scalar of element type.
4186 QualType vType = CheckVectorOperands(Loc, lex, rex);
4187 if (vType.isNull())
4188 return vType;
4189
4190 QualType lType = lex->getType();
4191 QualType rType = rex->getType();
4192
4193 // For non-floating point types, check for self-comparisons of the form
4194 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
4195 // often indicate logic errors in the program.
4196 if (!lType->isFloatingType()) {
4197 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex->IgnoreParens()))
4198 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex->IgnoreParens()))
4199 if (DRL->getDecl() == DRR->getDecl())
4200 Diag(Loc, diag::warn_selfcomparison);
4201 }
4202
4203 // Check for comparisons of floating point operands using != and ==.
4204 if (!isRelational && lType->isFloatingType()) {
4205 assert (rType->isFloatingType());
4206 CheckFloatComparison(Loc,lex,rex);
4207 }
4208
4209 // FIXME: Vector compare support in the LLVM backend is not fully reliable,
4210 // just reject all vector comparisons for now.
4211 if (1) {
4212 Diag(Loc, diag::err_typecheck_vector_comparison)
4213 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4214 return QualType();
4215 }
4216
4217 // Return the type for the comparison, which is the same as vector type for
4218 // integer vectors, or an integer type of identical size and number of
4219 // elements for floating point vectors.
4220 if (lType->isIntegerType())
4221 return lType;
4222
4223 const VectorType *VTy = lType->getAsVectorType();
4224 unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
4225 if (TypeSize == Context.getTypeSize(Context.IntTy))
4226 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
4227 if (TypeSize == Context.getTypeSize(Context.LongTy))
4228 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
4229
4230 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
4231 "Unhandled vector element size in vector compare");
4232 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
4233}
4234
4235inline QualType Sema::CheckBitwiseOperands(
4236 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
4237{
4238 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
4239 return CheckVectorOperands(Loc, lex, rex);
4240
4241 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
4242
4243 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
4244 return compType;
4245 return InvalidOperands(Loc, lex, rex);
4246}
4247
4248inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14]
4249 Expr *&lex, Expr *&rex, SourceLocation Loc)
4250{
4251 UsualUnaryConversions(lex);
4252 UsualUnaryConversions(rex);
4253
4254 if (lex->getType()->isScalarType() && rex->getType()->isScalarType())
4255 return Context.IntTy;
4256 return InvalidOperands(Loc, lex, rex);
4257}
4258
4259/// IsReadonlyProperty - Verify that otherwise a valid l-value expression
4260/// is a read-only property; return true if so. A readonly property expression
4261/// depends on various declarations and thus must be treated specially.
4262///
4263static bool IsReadonlyProperty(Expr *E, Sema &S)
4264{
4265 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) {
4266 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E);
4267 if (ObjCPropertyDecl *PDecl = PropExpr->getProperty()) {
4268 QualType BaseType = PropExpr->getBase()->getType();
4269 if (const PointerType *PTy = BaseType->getAsPointerType())
4270 if (const ObjCInterfaceType *IFTy =
4271 PTy->getPointeeType()->getAsObjCInterfaceType())
4272 if (ObjCInterfaceDecl *IFace = IFTy->getDecl())
4273 if (S.isPropertyReadonly(PDecl, IFace))
4274 return true;
4275 }
4276 }
4277 return false;
4278}
4279
4280/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not,
4281/// emit an error and return true. If so, return false.
4282static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
4283 SourceLocation OrigLoc = Loc;
4284 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
4285 &Loc);
4286 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S))
4287 IsLV = Expr::MLV_ReadonlyProperty;
4288 if (IsLV == Expr::MLV_Valid)
4289 return false;
4290
4291 unsigned Diag = 0;
4292 bool NeedType = false;
4293 switch (IsLV) { // C99 6.5.16p2
4294 default: assert(0 && "Unknown result from isModifiableLvalue!");
4295 case Expr::MLV_ConstQualified: Diag = diag::err_typecheck_assign_const; break;
4296 case Expr::MLV_ArrayType:
4297 Diag = diag::err_typecheck_array_not_modifiable_lvalue;
4298 NeedType = true;
4299 break;
4300 case Expr::MLV_NotObjectType:
4301 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue;
4302 NeedType = true;
4303 break;
4304 case Expr::MLV_LValueCast:
4305 Diag = diag::err_typecheck_lvalue_casts_not_supported;
4306 break;
4307 case Expr::MLV_InvalidExpression:
4308 Diag = diag::err_typecheck_expression_not_modifiable_lvalue;
4309 break;
4310 case Expr::MLV_IncompleteType:
4311 case Expr::MLV_IncompleteVoidType:
4312 return S.RequireCompleteType(Loc, E->getType(),
4313 diag::err_typecheck_incomplete_type_not_modifiable_lvalue,
4314 E->getSourceRange());
4315 case Expr::MLV_DuplicateVectorComponents:
4316 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
4317 break;
4318 case Expr::MLV_NotBlockQualified:
4319 Diag = diag::err_block_decl_ref_not_modifiable_lvalue;
4320 break;
4321 case Expr::MLV_ReadonlyProperty:
4322 Diag = diag::error_readonly_property_assignment;
4323 break;
4324 case Expr::MLV_NoSetterProperty:
4325 Diag = diag::error_nosetter_property_assignment;
4326 break;
4327 }
4328
4329 SourceRange Assign;
4330 if (Loc != OrigLoc)
4331 Assign = SourceRange(OrigLoc, OrigLoc);
4332 if (NeedType)
4333 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign;
4334 else
4335 S.Diag(Loc, Diag) << E->getSourceRange() << Assign;
4336 return true;
4337}
4338
4339
4340
4341// C99 6.5.16.1
4342QualType Sema::CheckAssignmentOperands(Expr *LHS, Expr *&RHS,
4343 SourceLocation Loc,
4344 QualType CompoundType) {
4345 // Verify that LHS is a modifiable lvalue, and emit error if not.
4346 if (CheckForModifiableLvalue(LHS, Loc, *this))
4347 return QualType();
4348
4349 QualType LHSType = LHS->getType();
4350 QualType RHSType = CompoundType.isNull() ? RHS->getType() : CompoundType;
4351
4352 AssignConvertType ConvTy;
4353 if (CompoundType.isNull()) {
4354 // Simple assignment "x = y".
4355 ConvTy = CheckSingleAssignmentConstraints(LHSType, RHS);
4356 // Special case of NSObject attributes on c-style pointer types.
4357 if (ConvTy == IncompatiblePointer &&
4358 ((Context.isObjCNSObjectType(LHSType) &&
4359 Context.isObjCObjectPointerType(RHSType)) ||
4360 (Context.isObjCNSObjectType(RHSType) &&
4361 Context.isObjCObjectPointerType(LHSType))))
4362 ConvTy = Compatible;
4363
4364 // If the RHS is a unary plus or minus, check to see if they = and + are
4365 // right next to each other. If so, the user may have typo'd "x =+ 4"
4366 // instead of "x += 4".
4367 Expr *RHSCheck = RHS;
4368 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
4369 RHSCheck = ICE->getSubExpr();
4370 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
4371 if ((UO->getOpcode() == UnaryOperator::Plus ||
4372 UO->getOpcode() == UnaryOperator::Minus) &&
4373 Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
4374 // Only if the two operators are exactly adjacent.
4375 Loc.getFileLocWithOffset(1) == UO->getOperatorLoc() &&
4376 // And there is a space or other character before the subexpr of the
4377 // unary +/-. We don't want to warn on "x=-1".
4378 Loc.getFileLocWithOffset(2) != UO->getSubExpr()->getLocStart() &&
4379 UO->getSubExpr()->getLocStart().isFileID()) {
4380 Diag(Loc, diag::warn_not_compound_assign)
4381 << (UO->getOpcode() == UnaryOperator::Plus ? "+" : "-")
4382 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
4383 }
4384 }
4385 } else {
4386 // Compound assignment "x += y"
4387 ConvTy = CheckAssignmentConstraints(LHSType, RHSType);
4388 }
4389
4390 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
4391 RHS, "assigning"))
4392 return QualType();
4393
4394 // C99 6.5.16p3: The type of an assignment expression is the type of the
4395 // left operand unless the left operand has qualified type, in which case
4396 // it is the unqualified version of the type of the left operand.
4397 // C99 6.5.16.1p2: In simple assignment, the value of the right operand
4398 // is converted to the type of the assignment expression (above).
4399 // C++ 5.17p1: the type of the assignment expression is that of its left
4400 // operand.
4401 return LHSType.getUnqualifiedType();
4402}
4403
4404// C99 6.5.17
4405QualType Sema::CheckCommaOperands(Expr *LHS, Expr *&RHS, SourceLocation Loc) {
4406 // Comma performs lvalue conversion (C99 6.3.2.1), but not unary conversions.
4407 DefaultFunctionArrayConversion(RHS);
4408
4409 // FIXME: Check that RHS type is complete in C mode (it's legal for it to be
4410 // incomplete in C++).
4411
4412 return RHS->getType();
4413}
4414
4415/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
4416/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
4417QualType Sema::CheckIncrementDecrementOperand(Expr *Op, SourceLocation OpLoc,
4418 bool isInc) {
4419 if (Op->isTypeDependent())
4420 return Context.DependentTy;
4421
4422 QualType ResType = Op->getType();
4423 assert(!ResType.isNull() && "no type for increment/decrement expression");
4424
4425 if (getLangOptions().CPlusPlus && ResType->isBooleanType()) {
4426 // Decrement of bool is not allowed.
4427 if (!isInc) {
4428 Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
4429 return QualType();
4430 }
4431 // Increment of bool sets it to true, but is deprecated.
4432 Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange();
4433 } else if (ResType->isRealType()) {
4434 // OK!
4435 } else if (const PointerType *PT = ResType->getAsPointerType()) {
4436 // C99 6.5.2.4p2, 6.5.6p2
4437 if (PT->getPointeeType()->isVoidType()) {
4438 if (getLangOptions().CPlusPlus) {
4439 Diag(OpLoc, diag::err_typecheck_pointer_arith_void_type)
4440 << Op->getSourceRange();
4441 return QualType();
4442 }
4443
4444 // Pointer to void is a GNU extension in C.
4445 Diag(OpLoc, diag::ext_gnu_void_ptr) << Op->getSourceRange();
4446 } else if (PT->getPointeeType()->isFunctionType()) {
4447 if (getLangOptions().CPlusPlus) {
4448 Diag(OpLoc, diag::err_typecheck_pointer_arith_function_type)
4449 << Op->getType() << Op->getSourceRange();
4450 return QualType();
4451 }
4452
4453 Diag(OpLoc, diag::ext_gnu_ptr_func_arith)
4454 << ResType << Op->getSourceRange();
4455 } else if (RequireCompleteType(OpLoc, PT->getPointeeType(),
4456 diag::err_typecheck_arithmetic_incomplete_type,
4457 Op->getSourceRange(), SourceRange(),
4458 ResType))
4459 return QualType();
4460 } else if (ResType->isComplexType()) {
4461 // C99 does not support ++/-- on complex types, we allow as an extension.
4462 Diag(OpLoc, diag::ext_integer_increment_complex)
4463 << ResType << Op->getSourceRange();
4464 } else {
4465 Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
4466 << ResType << Op->getSourceRange();
4467 return QualType();
4468 }
4469 // At this point, we know we have a real, complex or pointer type.
4470 // Now make sure the operand is a modifiable lvalue.
4471 if (CheckForModifiableLvalue(Op, OpLoc, *this))
4472 return QualType();
4473 return ResType;
4474}
4475
4476/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
4477/// This routine allows us to typecheck complex/recursive expressions
4478/// where the declaration is needed for type checking. We only need to
4479/// handle cases when the expression references a function designator
4480/// or is an lvalue. Here are some examples:
4481/// - &(x) => x
4482/// - &*****f => f for f a function designator.
4483/// - &s.xx => s
4484/// - &s.zz[1].yy -> s, if zz is an array
4485/// - *(x + 1) -> x, if x is an array
4486/// - &"123"[2] -> 0
4487/// - & __real__ x -> x
4488static NamedDecl *getPrimaryDecl(Expr *E) {
4489 switch (E->getStmtClass()) {
4490 case Stmt::DeclRefExprClass:
4491 case Stmt::QualifiedDeclRefExprClass:
4492 return cast<DeclRefExpr>(E)->getDecl();
4493 case Stmt::MemberExprClass:
4494 // If this is an arrow operator, the address is an offset from
4495 // the base's value, so the object the base refers to is
4496 // irrelevant.
4497 if (cast<MemberExpr>(E)->isArrow())
4498 return 0;
4499 // Otherwise, the expression refers to a part of the base
4500 return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
4501 case Stmt::ArraySubscriptExprClass: {
4502 // FIXME: This code shouldn't be necessary! We should catch the implicit
4503 // promotion of register arrays earlier.
4504 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
4505 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
4506 if (ICE->getSubExpr()->getType()->isArrayType())
4507 return getPrimaryDecl(ICE->getSubExpr());
4508 }
4509 return 0;
4510 }
4511 case Stmt::UnaryOperatorClass: {
4512 UnaryOperator *UO = cast<UnaryOperator>(E);
4513
4514 switch(UO->getOpcode()) {
4515 case UnaryOperator::Real:
4516 case UnaryOperator::Imag:
4517 case UnaryOperator::Extension:
4518 return getPrimaryDecl(UO->getSubExpr());
4519 default:
4520 return 0;
4521 }
4522 }
4523 case Stmt::ParenExprClass:
4524 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
4525 case Stmt::ImplicitCastExprClass:
4526 // If the result of an implicit cast is an l-value, we care about
4527 // the sub-expression; otherwise, the result here doesn't matter.
4528 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
4529 default:
4530 return 0;
4531 }
4532}
4533
4534/// CheckAddressOfOperand - The operand of & must be either a function
4535/// designator or an lvalue designating an object. If it is an lvalue, the
4536/// object cannot be declared with storage class register or be a bit field.
4537/// Note: The usual conversions are *not* applied to the operand of the &
4538/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
4539/// In C++, the operand might be an overloaded function name, in which case
4540/// we allow the '&' but retain the overloaded-function type.
4541QualType Sema::CheckAddressOfOperand(Expr *op, SourceLocation OpLoc) {
4542 // Make sure to ignore parentheses in subsequent checks
4543 op = op->IgnoreParens();
4544
4545 if (op->isTypeDependent())
4546 return Context.DependentTy;
4547
4548 if (getLangOptions().C99) {
4549 // Implement C99-only parts of addressof rules.
4550 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
4551 if (uOp->getOpcode() == UnaryOperator::Deref)
4552 // Per C99 6.5.3.2, the address of a deref always returns a valid result
4553 // (assuming the deref expression is valid).
4554 return uOp->getSubExpr()->getType();
4555 }
4556 // Technically, there should be a check for array subscript
4557 // expressions here, but the result of one is always an lvalue anyway.
4558 }
4559 NamedDecl *dcl = getPrimaryDecl(op);
4560 Expr::isLvalueResult lval = op->isLvalue(Context);
4561
4562 if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
4563 // C99 6.5.3.2p1
4564 // The operand must be either an l-value or a function designator
4565 if (!op->getType()->isFunctionType()) {
4566 // FIXME: emit more specific diag...
4567 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
4568 << op->getSourceRange();
4569 return QualType();
4570 }
4571 } else if (op->getBitField()) { // C99 6.5.3.2p1
4572 // The operand cannot be a bit-field
4573 Diag(OpLoc, diag::err_typecheck_address_of)
4574 << "bit-field" << op->getSourceRange();
4575 return QualType();
4576 } else if (isa<ExtVectorElementExpr>(op) || (isa<ArraySubscriptExpr>(op) &&
4577 cast<ArraySubscriptExpr>(op)->getBase()->getType()->isVectorType())){
4578 // The operand cannot be an element of a vector
4579 Diag(OpLoc, diag::err_typecheck_address_of)
4580 << "vector element" << op->getSourceRange();
4581 return QualType();
4582 } else if (dcl) { // C99 6.5.3.2p1
4583 // We have an lvalue with a decl. Make sure the decl is not declared
4584 // with the register storage-class specifier.
4585 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
4586 if (vd->getStorageClass() == VarDecl::Register) {
4587 Diag(OpLoc, diag::err_typecheck_address_of)
4588 << "register variable" << op->getSourceRange();
4589 return QualType();
4590 }
4591 } else if (isa<OverloadedFunctionDecl>(dcl)) {
4592 return Context.OverloadTy;
4593 } else if (isa<FieldDecl>(dcl)) {
4594 // Okay: we can take the address of a field.
4595 // Could be a pointer to member, though, if there is an explicit
4596 // scope qualifier for the class.
4597 if (isa<QualifiedDeclRefExpr>(op)) {
4598 DeclContext *Ctx = dcl->getDeclContext();
4599 if (Ctx && Ctx->isRecord())
4600 return Context.getMemberPointerType(op->getType(),
4601 Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
4602 }
4603 } else if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(dcl)) {
4604 // Okay: we can take the address of a function.
4605 // As above.
4606 if (isa<QualifiedDeclRefExpr>(op) && MD->isInstance())
4607 return Context.getMemberPointerType(op->getType(),
4608 Context.getTypeDeclType(MD->getParent()).getTypePtr());
4609 } else if (!isa<FunctionDecl>(dcl))
4610 assert(0 && "Unknown/unexpected decl type");
4611 }
4612
4613 if (lval == Expr::LV_IncompleteVoidType) {
4614 // Taking the address of a void variable is technically illegal, but we
4615 // allow it in cases which are otherwise valid.
4616 // Example: "extern void x; void* y = &x;".
4617 Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
4618 }
4619
4620 // If the operand has type "type", the result has type "pointer to type".
4621 return Context.getPointerType(op->getType());
4622}
4623
4624QualType Sema::CheckIndirectionOperand(Expr *Op, SourceLocation OpLoc) {
4625 if (Op->isTypeDependent())
4626 return Context.DependentTy;
4627
4628 UsualUnaryConversions(Op);
4629 QualType Ty = Op->getType();
4630
4631 // Note that per both C89 and C99, this is always legal, even if ptype is an
4632 // incomplete type or void. It would be possible to warn about dereferencing
4633 // a void pointer, but it's completely well-defined, and such a warning is
4634 // unlikely to catch any mistakes.
4635 if (const PointerType *PT = Ty->getAsPointerType())
4636 return PT->getPointeeType();
4637
4638 Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
4639 << Ty << Op->getSourceRange();
4640 return QualType();
4641}
4642
4643static inline BinaryOperator::Opcode ConvertTokenKindToBinaryOpcode(
4644 tok::TokenKind Kind) {
4645 BinaryOperator::Opcode Opc;
4646 switch (Kind) {
4647 default: assert(0 && "Unknown binop!");
4648 case tok::periodstar: Opc = BinaryOperator::PtrMemD; break;
4649 case tok::arrowstar: Opc = BinaryOperator::PtrMemI; break;
4650 case tok::star: Opc = BinaryOperator::Mul; break;
4651 case tok::slash: Opc = BinaryOperator::Div; break;
4652 case tok::percent: Opc = BinaryOperator::Rem; break;
4653 case tok::plus: Opc = BinaryOperator::Add; break;
4654 case tok::minus: Opc = BinaryOperator::Sub; break;
4655 case tok::lessless: Opc = BinaryOperator::Shl; break;
4656 case tok::greatergreater: Opc = BinaryOperator::Shr; break;
4657 case tok::lessequal: Opc = BinaryOperator::LE; break;
4658 case tok::less: Opc = BinaryOperator::LT; break;
4659 case tok::greaterequal: Opc = BinaryOperator::GE; break;
4660 case tok::greater: Opc = BinaryOperator::GT; break;
4661 case tok::exclaimequal: Opc = BinaryOperator::NE; break;
4662 case tok::equalequal: Opc = BinaryOperator::EQ; break;
4663 case tok::amp: Opc = BinaryOperator::And; break;
4664 case tok::caret: Opc = BinaryOperator::Xor; break;
4665 case tok::pipe: Opc = BinaryOperator::Or; break;
4666 case tok::ampamp: Opc = BinaryOperator::LAnd; break;
4667 case tok::pipepipe: Opc = BinaryOperator::LOr; break;
4668 case tok::equal: Opc = BinaryOperator::Assign; break;
4669 case tok::starequal: Opc = BinaryOperator::MulAssign; break;
4670 case tok::slashequal: Opc = BinaryOperator::DivAssign; break;
4671 case tok::percentequal: Opc = BinaryOperator::RemAssign; break;
4672 case tok::plusequal: Opc = BinaryOperator::AddAssign; break;
4673 case tok::minusequal: Opc = BinaryOperator::SubAssign; break;
4674 case tok::lesslessequal: Opc = BinaryOperator::ShlAssign; break;
4675 case tok::greatergreaterequal: Opc = BinaryOperator::ShrAssign; break;
4676 case tok::ampequal: Opc = BinaryOperator::AndAssign; break;
4677 case tok::caretequal: Opc = BinaryOperator::XorAssign; break;
4678 case tok::pipeequal: Opc = BinaryOperator::OrAssign; break;
4679 case tok::comma: Opc = BinaryOperator::Comma; break;
4680 }
4681 return Opc;
4682}
4683
4684static inline UnaryOperator::Opcode ConvertTokenKindToUnaryOpcode(
4685 tok::TokenKind Kind) {
4686 UnaryOperator::Opcode Opc;
4687 switch (Kind) {
4688 default: assert(0 && "Unknown unary op!");
4689 case tok::plusplus: Opc = UnaryOperator::PreInc; break;
4690 case tok::minusminus: Opc = UnaryOperator::PreDec; break;
4691 case tok::amp: Opc = UnaryOperator::AddrOf; break;
4692 case tok::star: Opc = UnaryOperator::Deref; break;
4693 case tok::plus: Opc = UnaryOperator::Plus; break;
4694 case tok::minus: Opc = UnaryOperator::Minus; break;
4695 case tok::tilde: Opc = UnaryOperator::Not; break;
4696 case tok::exclaim: Opc = UnaryOperator::LNot; break;
4697 case tok::kw___real: Opc = UnaryOperator::Real; break;
4698 case tok::kw___imag: Opc = UnaryOperator::Imag; break;
4699 case tok::kw___extension__: Opc = UnaryOperator::Extension; break;
4700 }
4701 return Opc;
4702}
4703
4704/// CreateBuiltinBinOp - Creates a new built-in binary operation with
4705/// operator @p Opc at location @c TokLoc. This routine only supports
4706/// built-in operations; ActOnBinOp handles overloaded operators.
4707Action::OwningExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
4708 unsigned Op,
4709 Expr *lhs, Expr *rhs) {
4710 QualType ResultTy; // Result type of the binary operator.
4711 BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)Op;
4712 // The following two variables are used for compound assignment operators
4713 QualType CompLHSTy; // Type of LHS after promotions for computation
4714 QualType CompResultTy; // Type of computation result
4715
4716 switch (Opc) {
4717 case BinaryOperator::Assign:
4718 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, QualType());
4719 break;
4720 case BinaryOperator::PtrMemD:
4721 case BinaryOperator::PtrMemI:
4722 ResultTy = CheckPointerToMemberOperands(lhs, rhs, OpLoc,
4723 Opc == BinaryOperator::PtrMemI);
4724 break;
4725 case BinaryOperator::Mul:
4726 case BinaryOperator::Div:
4727 ResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc);
4728 break;
4729 case BinaryOperator::Rem:
4730 ResultTy = CheckRemainderOperands(lhs, rhs, OpLoc);
4731 break;
4732 case BinaryOperator::Add:
4733 ResultTy = CheckAdditionOperands(lhs, rhs, OpLoc);
4734 break;
4735 case BinaryOperator::Sub:
4736 ResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc);
4737 break;
4738 case BinaryOperator::Shl:
4739 case BinaryOperator::Shr:
4740 ResultTy = CheckShiftOperands(lhs, rhs, OpLoc);
4741 break;
4742 case BinaryOperator::LE:
4743 case BinaryOperator::LT:
4744 case BinaryOperator::GE:
4745 case BinaryOperator::GT:
4746 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, true);
4747 break;
4748 case BinaryOperator::EQ:
4749 case BinaryOperator::NE:
4750 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, false);
4751 break;
4752 case BinaryOperator::And:
4753 case BinaryOperator::Xor:
4754 case BinaryOperator::Or:
4755 ResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc);
4756 break;
4757 case BinaryOperator::LAnd:
4758 case BinaryOperator::LOr:
4759 ResultTy = CheckLogicalOperands(lhs, rhs, OpLoc);
4760 break;
4761 case BinaryOperator::MulAssign:
4762 case BinaryOperator::DivAssign:
4763 CompResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, true);
4764 CompLHSTy = CompResultTy;
4765 if (!CompResultTy.isNull())
4766 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4767 break;
4768 case BinaryOperator::RemAssign:
4769 CompResultTy = CheckRemainderOperands(lhs, rhs, OpLoc, true);
4770 CompLHSTy = CompResultTy;
4771 if (!CompResultTy.isNull())
4772 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4773 break;
4774 case BinaryOperator::AddAssign:
4775 CompResultTy = CheckAdditionOperands(lhs, rhs, OpLoc, &CompLHSTy);
4776 if (!CompResultTy.isNull())
4777 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4778 break;
4779 case BinaryOperator::SubAssign:
4780 CompResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc, &CompLHSTy);
4781 if (!CompResultTy.isNull())
4782 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4783 break;
4784 case BinaryOperator::ShlAssign:
4785 case BinaryOperator::ShrAssign:
4786 CompResultTy = CheckShiftOperands(lhs, rhs, OpLoc, true);
4787 CompLHSTy = CompResultTy;
4788 if (!CompResultTy.isNull())
4789 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4790 break;
4791 case BinaryOperator::AndAssign:
4792 case BinaryOperator::XorAssign:
4793 case BinaryOperator::OrAssign:
4794 CompResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc, true);
4795 CompLHSTy = CompResultTy;
4796 if (!CompResultTy.isNull())
4797 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4798 break;
4799 case BinaryOperator::Comma:
4800 ResultTy = CheckCommaOperands(lhs, rhs, OpLoc);
4801 break;
4802 }
4803 if (ResultTy.isNull())
4804 return ExprError();
4805 if (CompResultTy.isNull())
4806 return Owned(new (Context) BinaryOperator(lhs, rhs, Opc, ResultTy, OpLoc));
4807 else
4808 return Owned(new (Context) CompoundAssignOperator(lhs, rhs, Opc, ResultTy,
4809 CompLHSTy, CompResultTy,
4810 OpLoc));
4811}
4812
4813// Binary Operators. 'Tok' is the token for the operator.
4814Action::OwningExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
4815 tok::TokenKind Kind,
4816 ExprArg LHS, ExprArg RHS) {
4817 BinaryOperator::Opcode Opc = ConvertTokenKindToBinaryOpcode(Kind);
4818 Expr *lhs = LHS.takeAs<Expr>(), *rhs = RHS.takeAs<Expr>();
4819
4820 assert((lhs != 0) && "ActOnBinOp(): missing left expression");
4821 assert((rhs != 0) && "ActOnBinOp(): missing right expression");
4822
4823 if (getLangOptions().CPlusPlus &&
4824 (lhs->getType()->isOverloadableType() ||
4825 rhs->getType()->isOverloadableType())) {
4826 // Find all of the overloaded operators visible from this
4827 // point. We perform both an operator-name lookup from the local
4828 // scope and an argument-dependent lookup based on the types of
4829 // the arguments.
4830 FunctionSet Functions;
4831 OverloadedOperatorKind OverOp = BinaryOperator::getOverloadedOperator(Opc);
4832 if (OverOp != OO_None) {
4833 LookupOverloadedOperatorName(OverOp, S, lhs->getType(), rhs->getType(),
4834 Functions);
4835 Expr *Args[2] = { lhs, rhs };
4836 DeclarationName OpName
4837 = Context.DeclarationNames.getCXXOperatorName(OverOp);
4838 ArgumentDependentLookup(OpName, Args, 2, Functions);
4839 }
4840
4841 // Build the (potentially-overloaded, potentially-dependent)
4842 // binary operation.
4843 return CreateOverloadedBinOp(TokLoc, Opc, Functions, lhs, rhs);
4844 }
4845
4846 // Build a built-in binary operation.
4847 return CreateBuiltinBinOp(TokLoc, Opc, lhs, rhs);
4848}
4849
4850Action::OwningExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
4851 unsigned OpcIn,
4852 ExprArg InputArg) {
4853 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn);
4854
4855 // FIXME: Input is modified below, but InputArg is not updated appropriately.
4856 Expr *Input = (Expr *)InputArg.get();
4857 QualType resultType;
4858 switch (Opc) {
4859 case UnaryOperator::PostInc:
4860 case UnaryOperator::PostDec:
4861 case UnaryOperator::OffsetOf:
4862 assert(false && "Invalid unary operator");
4863 break;
4864
4865 case UnaryOperator::PreInc:
4866 case UnaryOperator::PreDec:
4867 resultType = CheckIncrementDecrementOperand(Input, OpLoc,
4868 Opc == UnaryOperator::PreInc);
4869 break;
4870 case UnaryOperator::AddrOf:
4871 resultType = CheckAddressOfOperand(Input, OpLoc);
4872 break;
4873 case UnaryOperator::Deref:
4874 DefaultFunctionArrayConversion(Input);
4875 resultType = CheckIndirectionOperand(Input, OpLoc);
4876 break;
4877 case UnaryOperator::Plus:
4878 case UnaryOperator::Minus:
4879 UsualUnaryConversions(Input);
4880 resultType = Input->getType();
4881 if (resultType->isDependentType())
4882 break;
4883 if (resultType->isArithmeticType()) // C99 6.5.3.3p1
4884 break;
4885 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6-7
4886 resultType->isEnumeralType())
4887 break;
4888 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6
4889 Opc == UnaryOperator::Plus &&
4890 resultType->isPointerType())
4891 break;
4892
4893 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
4894 << resultType << Input->getSourceRange());
4895 case UnaryOperator::Not: // bitwise complement
4896 UsualUnaryConversions(Input);
4897 resultType = Input->getType();
4898 if (resultType->isDependentType())
4899 break;
4900 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
4901 if (resultType->isComplexType() || resultType->isComplexIntegerType())
4902 // C99 does not support '~' for complex conjugation.
4903 Diag(OpLoc, diag::ext_integer_complement_complex)
4904 << resultType << Input->getSourceRange();
4905 else if (!resultType->isIntegerType())
4906 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
4907 << resultType << Input->getSourceRange());
4908 break;
4909 case UnaryOperator::LNot: // logical negation
4910 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
4911 DefaultFunctionArrayConversion(Input);
4912 resultType = Input->getType();
4913 if (resultType->isDependentType())
4914 break;
4915 if (!resultType->isScalarType()) // C99 6.5.3.3p1
4916 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
4917 << resultType << Input->getSourceRange());
4918 // LNot always has type int. C99 6.5.3.3p5.
4919 // In C++, it's bool. C++ 5.3.1p8
4920 resultType = getLangOptions().CPlusPlus ? Context.BoolTy : Context.IntTy;
4921 break;
4922 case UnaryOperator::Real:
4923 case UnaryOperator::Imag:
4924 resultType = CheckRealImagOperand(Input, OpLoc, Opc == UnaryOperator::Real);
4925 break;
4926 case UnaryOperator::Extension:
4927 resultType = Input->getType();
4928 break;
4929 }
4930 if (resultType.isNull())
4931 return ExprError();
4932
4933 InputArg.release();
4934 return Owned(new (Context) UnaryOperator(Input, Opc, resultType, OpLoc));
4935}
4936
4937// Unary Operators. 'Tok' is the token for the operator.
4938Action::OwningExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
4939 tok::TokenKind Op, ExprArg input) {
4940 Expr *Input = (Expr*)input.get();
4941 UnaryOperator::Opcode Opc = ConvertTokenKindToUnaryOpcode(Op);
4942
4943 if (getLangOptions().CPlusPlus && Input->getType()->isOverloadableType()) {
4944 // Find all of the overloaded operators visible from this
4945 // point. We perform both an operator-name lookup from the local
4946 // scope and an argument-dependent lookup based on the types of
4947 // the arguments.
4948 FunctionSet Functions;
4949 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
4950 if (OverOp != OO_None) {
4951 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
4952 Functions);
4953 DeclarationName OpName
4954 = Context.DeclarationNames.getCXXOperatorName(OverOp);
4955 ArgumentDependentLookup(OpName, &Input, 1, Functions);
4956 }
4957
4958 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(input));
4959 }
4960
4961 return CreateBuiltinUnaryOp(OpLoc, Opc, move(input));
4962}
4963
4964/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
4965Sema::OwningExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc,
4966 SourceLocation LabLoc,
4967 IdentifierInfo *LabelII) {
4968 // Look up the record for this label identifier.
4969 LabelStmt *&LabelDecl = getLabelMap()[LabelII];
4970
4971 // If we haven't seen this label yet, create a forward reference. It
4972 // will be validated and/or cleaned up in ActOnFinishFunctionBody.
4973 if (LabelDecl == 0)
4974 LabelDecl = new (Context) LabelStmt(LabLoc, LabelII, 0);
4975
4976 // Create the AST node. The address of a label always has type 'void*'.
4977 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, LabelDecl,
4978 Context.getPointerType(Context.VoidTy)));
4979}
4980
4981Sema::OwningExprResult
4982Sema::ActOnStmtExpr(SourceLocation LPLoc, StmtArg substmt,
4983 SourceLocation RPLoc) { // "({..})"
4984 Stmt *SubStmt = static_cast<Stmt*>(substmt.get());
4985 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
4986 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
4987
4988 bool isFileScope = getCurFunctionOrMethodDecl() == 0;
4989 if (isFileScope)
4990 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope));
4991
4992 // FIXME: there are a variety of strange constraints to enforce here, for
4993 // example, it is not possible to goto into a stmt expression apparently.
4994 // More semantic analysis is needed.
4995
4996 // If there are sub stmts in the compound stmt, take the type of the last one
4997 // as the type of the stmtexpr.
4998 QualType Ty = Context.VoidTy;
4999
5000 if (!Compound->body_empty()) {
5001 Stmt *LastStmt = Compound->body_back();
5002 // If LastStmt is a label, skip down through into the body.
5003 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt))
5004 LastStmt = Label->getSubStmt();
5005
5006 if (Expr *LastExpr = dyn_cast<Expr>(LastStmt))
5007 Ty = LastExpr->getType();
5008 }
5009
5010 // FIXME: Check that expression type is complete/non-abstract; statement
5011 // expressions are not lvalues.
5012
5013 substmt.release();
5014 return Owned(new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc));
5015}
5016
5017Sema::OwningExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
5018 SourceLocation BuiltinLoc,
5019 SourceLocation TypeLoc,
5020 TypeTy *argty,
5021 OffsetOfComponent *CompPtr,
5022 unsigned NumComponents,
5023 SourceLocation RPLoc) {
5024 // FIXME: This function leaks all expressions in the offset components on
5025 // error.
5026 QualType ArgTy = QualType::getFromOpaquePtr(argty);
5027 assert(!ArgTy.isNull() && "Missing type argument!");
5028
5029 bool Dependent = ArgTy->isDependentType();
5030
5031 // We must have at least one component that refers to the type, and the first
5032 // one is known to be a field designator. Verify that the ArgTy represents
5033 // a struct/union/class.
5034 if (!Dependent && !ArgTy->isRecordType())
5035 return ExprError(Diag(TypeLoc, diag::err_offsetof_record_type) << ArgTy);
5036
5037 // FIXME: Type must be complete per C99 7.17p3 because a declaring a variable
5038 // with an incomplete type would be illegal.
5039
5040 // Otherwise, create a null pointer as the base, and iteratively process
5041 // the offsetof designators.
5042 QualType ArgTyPtr = Context.getPointerType(ArgTy);
5043 Expr* Res = new (Context) ImplicitValueInitExpr(ArgTyPtr);
5044 Res = new (Context) UnaryOperator(Res, UnaryOperator::Deref,
5045 ArgTy, SourceLocation());
5046
5047 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a
5048 // GCC extension, diagnose them.
5049 // FIXME: This diagnostic isn't actually visible because the location is in
5050 // a system header!
5051 if (NumComponents != 1)
5052 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator)
5053 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd);
5054
5055 if (!Dependent) {
5056 bool DidWarnAboutNonPOD = false;
5057
5058 // FIXME: Dependent case loses a lot of information here. And probably
5059 // leaks like a sieve.
5060 for (unsigned i = 0; i != NumComponents; ++i) {
5061 const OffsetOfComponent &OC = CompPtr[i];
5062 if (OC.isBrackets) {
5063 // Offset of an array sub-field. TODO: Should we allow vector elements?
5064 const ArrayType *AT = Context.getAsArrayType(Res->getType());
5065 if (!AT) {
5066 Res->Destroy(Context);
5067 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
5068 << Res->getType());
5069 }
5070
5071 // FIXME: C++: Verify that operator[] isn't overloaded.
5072
5073 // Promote the array so it looks more like a normal array subscript
5074 // expression.
5075 DefaultFunctionArrayConversion(Res);
5076
5077 // C99 6.5.2.1p1
5078 Expr *Idx = static_cast<Expr*>(OC.U.E);
5079 // FIXME: Leaks Res
5080 if (!Idx->isTypeDependent() && !Idx->getType()->isIntegerType())
5081 return ExprError(Diag(Idx->getLocStart(),
5082 diag::err_typecheck_subscript_not_integer)
5083 << Idx->getSourceRange());
5084
5085 Res = new (Context) ArraySubscriptExpr(Res, Idx, AT->getElementType(),
5086 OC.LocEnd);
5087 continue;
5088 }
5089
5090 const RecordType *RC = Res->getType()->getAsRecordType();
5091 if (!RC) {
5092 Res->Destroy(Context);
5093 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
5094 << Res->getType());
5095 }
5096
5097 // Get the decl corresponding to this.
5098 RecordDecl *RD = RC->getDecl();
5099 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
5100 if (!CRD->isPOD() && !DidWarnAboutNonPOD) {
5101 ExprError(Diag(BuiltinLoc, diag::warn_offsetof_non_pod_type)
5102 << SourceRange(CompPtr[0].LocStart, OC.LocEnd)
5103 << Res->getType());
5104 DidWarnAboutNonPOD = true;
5105 }
5106 }
5107
5108 FieldDecl *MemberDecl
5109 = dyn_cast_or_null<FieldDecl>(LookupQualifiedName(RD, OC.U.IdentInfo,
5110 LookupMemberName)
5111 .getAsDecl());
5112 // FIXME: Leaks Res
5113 if (!MemberDecl)
5114 return ExprError(Diag(BuiltinLoc, diag::err_typecheck_no_member)
5115 << OC.U.IdentInfo << SourceRange(OC.LocStart, OC.LocEnd));
5116
5117 // FIXME: C++: Verify that MemberDecl isn't a static field.
5118 // FIXME: Verify that MemberDecl isn't a bitfield.
5119 if (cast<RecordDecl>(MemberDecl->getDeclContext())->isAnonymousStructOrUnion()) {
5120 Res = BuildAnonymousStructUnionMemberReference(
5121 SourceLocation(), MemberDecl, Res, SourceLocation()).takeAs<Expr>();
5122 } else {
5123 // MemberDecl->getType() doesn't get the right qualifiers, but it
5124 // doesn't matter here.
5125 Res = new (Context) MemberExpr(Res, false, MemberDecl, OC.LocEnd,
5126 MemberDecl->getType().getNonReferenceType());
5127 }
5128 }
5129 }
5130
5131 return Owned(new (Context) UnaryOperator(Res, UnaryOperator::OffsetOf,
5132 Context.getSizeType(), BuiltinLoc));
5133}
5134
5135
5136Sema::OwningExprResult Sema::ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
5137 TypeTy *arg1,TypeTy *arg2,
5138 SourceLocation RPLoc) {
5139 QualType argT1 = QualType::getFromOpaquePtr(arg1);
5140 QualType argT2 = QualType::getFromOpaquePtr(arg2);
5141
5142 assert((!argT1.isNull() && !argT2.isNull()) && "Missing type argument(s)");
5143
5144 if (getLangOptions().CPlusPlus) {
5145 Diag(BuiltinLoc, diag::err_types_compatible_p_in_cplusplus)
5146 << SourceRange(BuiltinLoc, RPLoc);
5147 return ExprError();
5148 }
5149
5150 return Owned(new (Context) TypesCompatibleExpr(Context.IntTy, BuiltinLoc,
5151 argT1, argT2, RPLoc));
5152}
5153
5154Sema::OwningExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
5155 ExprArg cond,
5156 ExprArg expr1, ExprArg expr2,
5157 SourceLocation RPLoc) {
5158 Expr *CondExpr = static_cast<Expr*>(cond.get());
5159 Expr *LHSExpr = static_cast<Expr*>(expr1.get());
5160 Expr *RHSExpr = static_cast<Expr*>(expr2.get());
5161
5162 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
5163
5164 QualType resType;
5165 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
5166 resType = Context.DependentTy;
5167 } else {
5168 // The conditional expression is required to be a constant expression.
5169 llvm::APSInt condEval(32);
5170 SourceLocation ExpLoc;
5171 if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc))
5172 return ExprError(Diag(ExpLoc,
5173 diag::err_typecheck_choose_expr_requires_constant)
5174 << CondExpr->getSourceRange());
5175
5176 // If the condition is > zero, then the AST type is the same as the LSHExpr.
5177 resType = condEval.getZExtValue() ? LHSExpr->getType() : RHSExpr->getType();
5178 }
5179
5180 cond.release(); expr1.release(); expr2.release();
5181 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr,
5182 resType, RPLoc));
5183}
5184
5185//===----------------------------------------------------------------------===//
5186// Clang Extensions.
5187//===----------------------------------------------------------------------===//
5188
5189/// ActOnBlockStart - This callback is invoked when a block literal is started.
5190void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope) {
5191 // Analyze block parameters.
5192 BlockSemaInfo *BSI = new BlockSemaInfo();
5193
5194 // Add BSI to CurBlock.
5195 BSI->PrevBlockInfo = CurBlock;
5196 CurBlock = BSI;
5197
5198 BSI->ReturnType = QualType();
5199 BSI->TheScope = BlockScope;
5200 BSI->hasBlockDeclRefExprs = false;
5201 BSI->SavedFunctionNeedsScopeChecking = CurFunctionNeedsScopeChecking;
5202 CurFunctionNeedsScopeChecking = false;
5203
5204 BSI->TheDecl = BlockDecl::Create(Context, CurContext, CaretLoc);
5205 PushDeclContext(BlockScope, BSI->TheDecl);
5206}
5207
5208void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) {
5209 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!");
5210
5211 if (ParamInfo.getNumTypeObjects() == 0
5212 || ParamInfo.getTypeObject(0).Kind != DeclaratorChunk::Function) {
5213 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
5214 QualType T = GetTypeForDeclarator(ParamInfo, CurScope);
5215
5216 if (T->isArrayType()) {
5217 Diag(ParamInfo.getSourceRange().getBegin(),
5218 diag::err_block_returns_array);
5219 return;
5220 }
5221
5222 // The parameter list is optional, if there was none, assume ().
5223 if (!T->isFunctionType())
5224 T = Context.getFunctionType(T, NULL, 0, 0, 0);
5225
5226 CurBlock->hasPrototype = true;
5227 CurBlock->isVariadic = false;
5228 // Check for a valid sentinel attribute on this block.
| 4251 Diag(Loc, diag::ext_typecheck_comparison_of_pointer_integer)
4252 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4253 ImpCastExprToType(lex, rType); // promote the integer to pointer
4254 return ResultTy;
4255 }
4256 // Handle block pointers.
4257 if (!isRelational && RHSIsNull
4258 && lType->isBlockPointerType() && rType->isIntegerType()) {
4259 ImpCastExprToType(rex, lType); // promote the integer to pointer
4260 return ResultTy;
4261 }
4262 if (!isRelational && LHSIsNull
4263 && lType->isIntegerType() && rType->isBlockPointerType()) {
4264 ImpCastExprToType(lex, rType); // promote the integer to pointer
4265 return ResultTy;
4266 }
4267 return InvalidOperands(Loc, lex, rex);
4268}
4269
4270/// CheckVectorCompareOperands - vector comparisons are a clang extension that
4271/// operates on extended vector types. Instead of producing an IntTy result,
4272/// like a scalar comparison, a vector comparison produces a vector of integer
4273/// types.
4274QualType Sema::CheckVectorCompareOperands(Expr *&lex, Expr *&rex,
4275 SourceLocation Loc,
4276 bool isRelational) {
4277 // Check to make sure we're operating on vectors of the same type and width,
4278 // Allowing one side to be a scalar of element type.
4279 QualType vType = CheckVectorOperands(Loc, lex, rex);
4280 if (vType.isNull())
4281 return vType;
4282
4283 QualType lType = lex->getType();
4284 QualType rType = rex->getType();
4285
4286 // For non-floating point types, check for self-comparisons of the form
4287 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
4288 // often indicate logic errors in the program.
4289 if (!lType->isFloatingType()) {
4290 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex->IgnoreParens()))
4291 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex->IgnoreParens()))
4292 if (DRL->getDecl() == DRR->getDecl())
4293 Diag(Loc, diag::warn_selfcomparison);
4294 }
4295
4296 // Check for comparisons of floating point operands using != and ==.
4297 if (!isRelational && lType->isFloatingType()) {
4298 assert (rType->isFloatingType());
4299 CheckFloatComparison(Loc,lex,rex);
4300 }
4301
4302 // FIXME: Vector compare support in the LLVM backend is not fully reliable,
4303 // just reject all vector comparisons for now.
4304 if (1) {
4305 Diag(Loc, diag::err_typecheck_vector_comparison)
4306 << lType << rType << lex->getSourceRange() << rex->getSourceRange();
4307 return QualType();
4308 }
4309
4310 // Return the type for the comparison, which is the same as vector type for
4311 // integer vectors, or an integer type of identical size and number of
4312 // elements for floating point vectors.
4313 if (lType->isIntegerType())
4314 return lType;
4315
4316 const VectorType *VTy = lType->getAsVectorType();
4317 unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
4318 if (TypeSize == Context.getTypeSize(Context.IntTy))
4319 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
4320 if (TypeSize == Context.getTypeSize(Context.LongTy))
4321 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
4322
4323 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
4324 "Unhandled vector element size in vector compare");
4325 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
4326}
4327
4328inline QualType Sema::CheckBitwiseOperands(
4329 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign)
4330{
4331 if (lex->getType()->isVectorType() || rex->getType()->isVectorType())
4332 return CheckVectorOperands(Loc, lex, rex);
4333
4334 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign);
4335
4336 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType())
4337 return compType;
4338 return InvalidOperands(Loc, lex, rex);
4339}
4340
4341inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14]
4342 Expr *&lex, Expr *&rex, SourceLocation Loc)
4343{
4344 UsualUnaryConversions(lex);
4345 UsualUnaryConversions(rex);
4346
4347 if (lex->getType()->isScalarType() && rex->getType()->isScalarType())
4348 return Context.IntTy;
4349 return InvalidOperands(Loc, lex, rex);
4350}
4351
4352/// IsReadonlyProperty - Verify that otherwise a valid l-value expression
4353/// is a read-only property; return true if so. A readonly property expression
4354/// depends on various declarations and thus must be treated specially.
4355///
4356static bool IsReadonlyProperty(Expr *E, Sema &S)
4357{
4358 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) {
4359 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E);
4360 if (ObjCPropertyDecl *PDecl = PropExpr->getProperty()) {
4361 QualType BaseType = PropExpr->getBase()->getType();
4362 if (const PointerType *PTy = BaseType->getAsPointerType())
4363 if (const ObjCInterfaceType *IFTy =
4364 PTy->getPointeeType()->getAsObjCInterfaceType())
4365 if (ObjCInterfaceDecl *IFace = IFTy->getDecl())
4366 if (S.isPropertyReadonly(PDecl, IFace))
4367 return true;
4368 }
4369 }
4370 return false;
4371}
4372
4373/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not,
4374/// emit an error and return true. If so, return false.
4375static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
4376 SourceLocation OrigLoc = Loc;
4377 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
4378 &Loc);
4379 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S))
4380 IsLV = Expr::MLV_ReadonlyProperty;
4381 if (IsLV == Expr::MLV_Valid)
4382 return false;
4383
4384 unsigned Diag = 0;
4385 bool NeedType = false;
4386 switch (IsLV) { // C99 6.5.16p2
4387 default: assert(0 && "Unknown result from isModifiableLvalue!");
4388 case Expr::MLV_ConstQualified: Diag = diag::err_typecheck_assign_const; break;
4389 case Expr::MLV_ArrayType:
4390 Diag = diag::err_typecheck_array_not_modifiable_lvalue;
4391 NeedType = true;
4392 break;
4393 case Expr::MLV_NotObjectType:
4394 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue;
4395 NeedType = true;
4396 break;
4397 case Expr::MLV_LValueCast:
4398 Diag = diag::err_typecheck_lvalue_casts_not_supported;
4399 break;
4400 case Expr::MLV_InvalidExpression:
4401 Diag = diag::err_typecheck_expression_not_modifiable_lvalue;
4402 break;
4403 case Expr::MLV_IncompleteType:
4404 case Expr::MLV_IncompleteVoidType:
4405 return S.RequireCompleteType(Loc, E->getType(),
4406 diag::err_typecheck_incomplete_type_not_modifiable_lvalue,
4407 E->getSourceRange());
4408 case Expr::MLV_DuplicateVectorComponents:
4409 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
4410 break;
4411 case Expr::MLV_NotBlockQualified:
4412 Diag = diag::err_block_decl_ref_not_modifiable_lvalue;
4413 break;
4414 case Expr::MLV_ReadonlyProperty:
4415 Diag = diag::error_readonly_property_assignment;
4416 break;
4417 case Expr::MLV_NoSetterProperty:
4418 Diag = diag::error_nosetter_property_assignment;
4419 break;
4420 }
4421
4422 SourceRange Assign;
4423 if (Loc != OrigLoc)
4424 Assign = SourceRange(OrigLoc, OrigLoc);
4425 if (NeedType)
4426 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign;
4427 else
4428 S.Diag(Loc, Diag) << E->getSourceRange() << Assign;
4429 return true;
4430}
4431
4432
4433
4434// C99 6.5.16.1
4435QualType Sema::CheckAssignmentOperands(Expr *LHS, Expr *&RHS,
4436 SourceLocation Loc,
4437 QualType CompoundType) {
4438 // Verify that LHS is a modifiable lvalue, and emit error if not.
4439 if (CheckForModifiableLvalue(LHS, Loc, *this))
4440 return QualType();
4441
4442 QualType LHSType = LHS->getType();
4443 QualType RHSType = CompoundType.isNull() ? RHS->getType() : CompoundType;
4444
4445 AssignConvertType ConvTy;
4446 if (CompoundType.isNull()) {
4447 // Simple assignment "x = y".
4448 ConvTy = CheckSingleAssignmentConstraints(LHSType, RHS);
4449 // Special case of NSObject attributes on c-style pointer types.
4450 if (ConvTy == IncompatiblePointer &&
4451 ((Context.isObjCNSObjectType(LHSType) &&
4452 Context.isObjCObjectPointerType(RHSType)) ||
4453 (Context.isObjCNSObjectType(RHSType) &&
4454 Context.isObjCObjectPointerType(LHSType))))
4455 ConvTy = Compatible;
4456
4457 // If the RHS is a unary plus or minus, check to see if they = and + are
4458 // right next to each other. If so, the user may have typo'd "x =+ 4"
4459 // instead of "x += 4".
4460 Expr *RHSCheck = RHS;
4461 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
4462 RHSCheck = ICE->getSubExpr();
4463 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
4464 if ((UO->getOpcode() == UnaryOperator::Plus ||
4465 UO->getOpcode() == UnaryOperator::Minus) &&
4466 Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
4467 // Only if the two operators are exactly adjacent.
4468 Loc.getFileLocWithOffset(1) == UO->getOperatorLoc() &&
4469 // And there is a space or other character before the subexpr of the
4470 // unary +/-. We don't want to warn on "x=-1".
4471 Loc.getFileLocWithOffset(2) != UO->getSubExpr()->getLocStart() &&
4472 UO->getSubExpr()->getLocStart().isFileID()) {
4473 Diag(Loc, diag::warn_not_compound_assign)
4474 << (UO->getOpcode() == UnaryOperator::Plus ? "+" : "-")
4475 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
4476 }
4477 }
4478 } else {
4479 // Compound assignment "x += y"
4480 ConvTy = CheckAssignmentConstraints(LHSType, RHSType);
4481 }
4482
4483 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
4484 RHS, "assigning"))
4485 return QualType();
4486
4487 // C99 6.5.16p3: The type of an assignment expression is the type of the
4488 // left operand unless the left operand has qualified type, in which case
4489 // it is the unqualified version of the type of the left operand.
4490 // C99 6.5.16.1p2: In simple assignment, the value of the right operand
4491 // is converted to the type of the assignment expression (above).
4492 // C++ 5.17p1: the type of the assignment expression is that of its left
4493 // operand.
4494 return LHSType.getUnqualifiedType();
4495}
4496
4497// C99 6.5.17
4498QualType Sema::CheckCommaOperands(Expr *LHS, Expr *&RHS, SourceLocation Loc) {
4499 // Comma performs lvalue conversion (C99 6.3.2.1), but not unary conversions.
4500 DefaultFunctionArrayConversion(RHS);
4501
4502 // FIXME: Check that RHS type is complete in C mode (it's legal for it to be
4503 // incomplete in C++).
4504
4505 return RHS->getType();
4506}
4507
4508/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
4509/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
4510QualType Sema::CheckIncrementDecrementOperand(Expr *Op, SourceLocation OpLoc,
4511 bool isInc) {
4512 if (Op->isTypeDependent())
4513 return Context.DependentTy;
4514
4515 QualType ResType = Op->getType();
4516 assert(!ResType.isNull() && "no type for increment/decrement expression");
4517
4518 if (getLangOptions().CPlusPlus && ResType->isBooleanType()) {
4519 // Decrement of bool is not allowed.
4520 if (!isInc) {
4521 Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
4522 return QualType();
4523 }
4524 // Increment of bool sets it to true, but is deprecated.
4525 Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange();
4526 } else if (ResType->isRealType()) {
4527 // OK!
4528 } else if (const PointerType *PT = ResType->getAsPointerType()) {
4529 // C99 6.5.2.4p2, 6.5.6p2
4530 if (PT->getPointeeType()->isVoidType()) {
4531 if (getLangOptions().CPlusPlus) {
4532 Diag(OpLoc, diag::err_typecheck_pointer_arith_void_type)
4533 << Op->getSourceRange();
4534 return QualType();
4535 }
4536
4537 // Pointer to void is a GNU extension in C.
4538 Diag(OpLoc, diag::ext_gnu_void_ptr) << Op->getSourceRange();
4539 } else if (PT->getPointeeType()->isFunctionType()) {
4540 if (getLangOptions().CPlusPlus) {
4541 Diag(OpLoc, diag::err_typecheck_pointer_arith_function_type)
4542 << Op->getType() << Op->getSourceRange();
4543 return QualType();
4544 }
4545
4546 Diag(OpLoc, diag::ext_gnu_ptr_func_arith)
4547 << ResType << Op->getSourceRange();
4548 } else if (RequireCompleteType(OpLoc, PT->getPointeeType(),
4549 diag::err_typecheck_arithmetic_incomplete_type,
4550 Op->getSourceRange(), SourceRange(),
4551 ResType))
4552 return QualType();
4553 } else if (ResType->isComplexType()) {
4554 // C99 does not support ++/-- on complex types, we allow as an extension.
4555 Diag(OpLoc, diag::ext_integer_increment_complex)
4556 << ResType << Op->getSourceRange();
4557 } else {
4558 Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
4559 << ResType << Op->getSourceRange();
4560 return QualType();
4561 }
4562 // At this point, we know we have a real, complex or pointer type.
4563 // Now make sure the operand is a modifiable lvalue.
4564 if (CheckForModifiableLvalue(Op, OpLoc, *this))
4565 return QualType();
4566 return ResType;
4567}
4568
4569/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
4570/// This routine allows us to typecheck complex/recursive expressions
4571/// where the declaration is needed for type checking. We only need to
4572/// handle cases when the expression references a function designator
4573/// or is an lvalue. Here are some examples:
4574/// - &(x) => x
4575/// - &*****f => f for f a function designator.
4576/// - &s.xx => s
4577/// - &s.zz[1].yy -> s, if zz is an array
4578/// - *(x + 1) -> x, if x is an array
4579/// - &"123"[2] -> 0
4580/// - & __real__ x -> x
4581static NamedDecl *getPrimaryDecl(Expr *E) {
4582 switch (E->getStmtClass()) {
4583 case Stmt::DeclRefExprClass:
4584 case Stmt::QualifiedDeclRefExprClass:
4585 return cast<DeclRefExpr>(E)->getDecl();
4586 case Stmt::MemberExprClass:
4587 // If this is an arrow operator, the address is an offset from
4588 // the base's value, so the object the base refers to is
4589 // irrelevant.
4590 if (cast<MemberExpr>(E)->isArrow())
4591 return 0;
4592 // Otherwise, the expression refers to a part of the base
4593 return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
4594 case Stmt::ArraySubscriptExprClass: {
4595 // FIXME: This code shouldn't be necessary! We should catch the implicit
4596 // promotion of register arrays earlier.
4597 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
4598 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
4599 if (ICE->getSubExpr()->getType()->isArrayType())
4600 return getPrimaryDecl(ICE->getSubExpr());
4601 }
4602 return 0;
4603 }
4604 case Stmt::UnaryOperatorClass: {
4605 UnaryOperator *UO = cast<UnaryOperator>(E);
4606
4607 switch(UO->getOpcode()) {
4608 case UnaryOperator::Real:
4609 case UnaryOperator::Imag:
4610 case UnaryOperator::Extension:
4611 return getPrimaryDecl(UO->getSubExpr());
4612 default:
4613 return 0;
4614 }
4615 }
4616 case Stmt::ParenExprClass:
4617 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
4618 case Stmt::ImplicitCastExprClass:
4619 // If the result of an implicit cast is an l-value, we care about
4620 // the sub-expression; otherwise, the result here doesn't matter.
4621 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
4622 default:
4623 return 0;
4624 }
4625}
4626
4627/// CheckAddressOfOperand - The operand of & must be either a function
4628/// designator or an lvalue designating an object. If it is an lvalue, the
4629/// object cannot be declared with storage class register or be a bit field.
4630/// Note: The usual conversions are *not* applied to the operand of the &
4631/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
4632/// In C++, the operand might be an overloaded function name, in which case
4633/// we allow the '&' but retain the overloaded-function type.
4634QualType Sema::CheckAddressOfOperand(Expr *op, SourceLocation OpLoc) {
4635 // Make sure to ignore parentheses in subsequent checks
4636 op = op->IgnoreParens();
4637
4638 if (op->isTypeDependent())
4639 return Context.DependentTy;
4640
4641 if (getLangOptions().C99) {
4642 // Implement C99-only parts of addressof rules.
4643 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
4644 if (uOp->getOpcode() == UnaryOperator::Deref)
4645 // Per C99 6.5.3.2, the address of a deref always returns a valid result
4646 // (assuming the deref expression is valid).
4647 return uOp->getSubExpr()->getType();
4648 }
4649 // Technically, there should be a check for array subscript
4650 // expressions here, but the result of one is always an lvalue anyway.
4651 }
4652 NamedDecl *dcl = getPrimaryDecl(op);
4653 Expr::isLvalueResult lval = op->isLvalue(Context);
4654
4655 if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
4656 // C99 6.5.3.2p1
4657 // The operand must be either an l-value or a function designator
4658 if (!op->getType()->isFunctionType()) {
4659 // FIXME: emit more specific diag...
4660 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
4661 << op->getSourceRange();
4662 return QualType();
4663 }
4664 } else if (op->getBitField()) { // C99 6.5.3.2p1
4665 // The operand cannot be a bit-field
4666 Diag(OpLoc, diag::err_typecheck_address_of)
4667 << "bit-field" << op->getSourceRange();
4668 return QualType();
4669 } else if (isa<ExtVectorElementExpr>(op) || (isa<ArraySubscriptExpr>(op) &&
4670 cast<ArraySubscriptExpr>(op)->getBase()->getType()->isVectorType())){
4671 // The operand cannot be an element of a vector
4672 Diag(OpLoc, diag::err_typecheck_address_of)
4673 << "vector element" << op->getSourceRange();
4674 return QualType();
4675 } else if (dcl) { // C99 6.5.3.2p1
4676 // We have an lvalue with a decl. Make sure the decl is not declared
4677 // with the register storage-class specifier.
4678 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
4679 if (vd->getStorageClass() == VarDecl::Register) {
4680 Diag(OpLoc, diag::err_typecheck_address_of)
4681 << "register variable" << op->getSourceRange();
4682 return QualType();
4683 }
4684 } else if (isa<OverloadedFunctionDecl>(dcl)) {
4685 return Context.OverloadTy;
4686 } else if (isa<FieldDecl>(dcl)) {
4687 // Okay: we can take the address of a field.
4688 // Could be a pointer to member, though, if there is an explicit
4689 // scope qualifier for the class.
4690 if (isa<QualifiedDeclRefExpr>(op)) {
4691 DeclContext *Ctx = dcl->getDeclContext();
4692 if (Ctx && Ctx->isRecord())
4693 return Context.getMemberPointerType(op->getType(),
4694 Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
4695 }
4696 } else if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(dcl)) {
4697 // Okay: we can take the address of a function.
4698 // As above.
4699 if (isa<QualifiedDeclRefExpr>(op) && MD->isInstance())
4700 return Context.getMemberPointerType(op->getType(),
4701 Context.getTypeDeclType(MD->getParent()).getTypePtr());
4702 } else if (!isa<FunctionDecl>(dcl))
4703 assert(0 && "Unknown/unexpected decl type");
4704 }
4705
4706 if (lval == Expr::LV_IncompleteVoidType) {
4707 // Taking the address of a void variable is technically illegal, but we
4708 // allow it in cases which are otherwise valid.
4709 // Example: "extern void x; void* y = &x;".
4710 Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
4711 }
4712
4713 // If the operand has type "type", the result has type "pointer to type".
4714 return Context.getPointerType(op->getType());
4715}
4716
4717QualType Sema::CheckIndirectionOperand(Expr *Op, SourceLocation OpLoc) {
4718 if (Op->isTypeDependent())
4719 return Context.DependentTy;
4720
4721 UsualUnaryConversions(Op);
4722 QualType Ty = Op->getType();
4723
4724 // Note that per both C89 and C99, this is always legal, even if ptype is an
4725 // incomplete type or void. It would be possible to warn about dereferencing
4726 // a void pointer, but it's completely well-defined, and such a warning is
4727 // unlikely to catch any mistakes.
4728 if (const PointerType *PT = Ty->getAsPointerType())
4729 return PT->getPointeeType();
4730
4731 Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
4732 << Ty << Op->getSourceRange();
4733 return QualType();
4734}
4735
4736static inline BinaryOperator::Opcode ConvertTokenKindToBinaryOpcode(
4737 tok::TokenKind Kind) {
4738 BinaryOperator::Opcode Opc;
4739 switch (Kind) {
4740 default: assert(0 && "Unknown binop!");
4741 case tok::periodstar: Opc = BinaryOperator::PtrMemD; break;
4742 case tok::arrowstar: Opc = BinaryOperator::PtrMemI; break;
4743 case tok::star: Opc = BinaryOperator::Mul; break;
4744 case tok::slash: Opc = BinaryOperator::Div; break;
4745 case tok::percent: Opc = BinaryOperator::Rem; break;
4746 case tok::plus: Opc = BinaryOperator::Add; break;
4747 case tok::minus: Opc = BinaryOperator::Sub; break;
4748 case tok::lessless: Opc = BinaryOperator::Shl; break;
4749 case tok::greatergreater: Opc = BinaryOperator::Shr; break;
4750 case tok::lessequal: Opc = BinaryOperator::LE; break;
4751 case tok::less: Opc = BinaryOperator::LT; break;
4752 case tok::greaterequal: Opc = BinaryOperator::GE; break;
4753 case tok::greater: Opc = BinaryOperator::GT; break;
4754 case tok::exclaimequal: Opc = BinaryOperator::NE; break;
4755 case tok::equalequal: Opc = BinaryOperator::EQ; break;
4756 case tok::amp: Opc = BinaryOperator::And; break;
4757 case tok::caret: Opc = BinaryOperator::Xor; break;
4758 case tok::pipe: Opc = BinaryOperator::Or; break;
4759 case tok::ampamp: Opc = BinaryOperator::LAnd; break;
4760 case tok::pipepipe: Opc = BinaryOperator::LOr; break;
4761 case tok::equal: Opc = BinaryOperator::Assign; break;
4762 case tok::starequal: Opc = BinaryOperator::MulAssign; break;
4763 case tok::slashequal: Opc = BinaryOperator::DivAssign; break;
4764 case tok::percentequal: Opc = BinaryOperator::RemAssign; break;
4765 case tok::plusequal: Opc = BinaryOperator::AddAssign; break;
4766 case tok::minusequal: Opc = BinaryOperator::SubAssign; break;
4767 case tok::lesslessequal: Opc = BinaryOperator::ShlAssign; break;
4768 case tok::greatergreaterequal: Opc = BinaryOperator::ShrAssign; break;
4769 case tok::ampequal: Opc = BinaryOperator::AndAssign; break;
4770 case tok::caretequal: Opc = BinaryOperator::XorAssign; break;
4771 case tok::pipeequal: Opc = BinaryOperator::OrAssign; break;
4772 case tok::comma: Opc = BinaryOperator::Comma; break;
4773 }
4774 return Opc;
4775}
4776
4777static inline UnaryOperator::Opcode ConvertTokenKindToUnaryOpcode(
4778 tok::TokenKind Kind) {
4779 UnaryOperator::Opcode Opc;
4780 switch (Kind) {
4781 default: assert(0 && "Unknown unary op!");
4782 case tok::plusplus: Opc = UnaryOperator::PreInc; break;
4783 case tok::minusminus: Opc = UnaryOperator::PreDec; break;
4784 case tok::amp: Opc = UnaryOperator::AddrOf; break;
4785 case tok::star: Opc = UnaryOperator::Deref; break;
4786 case tok::plus: Opc = UnaryOperator::Plus; break;
4787 case tok::minus: Opc = UnaryOperator::Minus; break;
4788 case tok::tilde: Opc = UnaryOperator::Not; break;
4789 case tok::exclaim: Opc = UnaryOperator::LNot; break;
4790 case tok::kw___real: Opc = UnaryOperator::Real; break;
4791 case tok::kw___imag: Opc = UnaryOperator::Imag; break;
4792 case tok::kw___extension__: Opc = UnaryOperator::Extension; break;
4793 }
4794 return Opc;
4795}
4796
4797/// CreateBuiltinBinOp - Creates a new built-in binary operation with
4798/// operator @p Opc at location @c TokLoc. This routine only supports
4799/// built-in operations; ActOnBinOp handles overloaded operators.
4800Action::OwningExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
4801 unsigned Op,
4802 Expr *lhs, Expr *rhs) {
4803 QualType ResultTy; // Result type of the binary operator.
4804 BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)Op;
4805 // The following two variables are used for compound assignment operators
4806 QualType CompLHSTy; // Type of LHS after promotions for computation
4807 QualType CompResultTy; // Type of computation result
4808
4809 switch (Opc) {
4810 case BinaryOperator::Assign:
4811 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, QualType());
4812 break;
4813 case BinaryOperator::PtrMemD:
4814 case BinaryOperator::PtrMemI:
4815 ResultTy = CheckPointerToMemberOperands(lhs, rhs, OpLoc,
4816 Opc == BinaryOperator::PtrMemI);
4817 break;
4818 case BinaryOperator::Mul:
4819 case BinaryOperator::Div:
4820 ResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc);
4821 break;
4822 case BinaryOperator::Rem:
4823 ResultTy = CheckRemainderOperands(lhs, rhs, OpLoc);
4824 break;
4825 case BinaryOperator::Add:
4826 ResultTy = CheckAdditionOperands(lhs, rhs, OpLoc);
4827 break;
4828 case BinaryOperator::Sub:
4829 ResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc);
4830 break;
4831 case BinaryOperator::Shl:
4832 case BinaryOperator::Shr:
4833 ResultTy = CheckShiftOperands(lhs, rhs, OpLoc);
4834 break;
4835 case BinaryOperator::LE:
4836 case BinaryOperator::LT:
4837 case BinaryOperator::GE:
4838 case BinaryOperator::GT:
4839 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, true);
4840 break;
4841 case BinaryOperator::EQ:
4842 case BinaryOperator::NE:
4843 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, false);
4844 break;
4845 case BinaryOperator::And:
4846 case BinaryOperator::Xor:
4847 case BinaryOperator::Or:
4848 ResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc);
4849 break;
4850 case BinaryOperator::LAnd:
4851 case BinaryOperator::LOr:
4852 ResultTy = CheckLogicalOperands(lhs, rhs, OpLoc);
4853 break;
4854 case BinaryOperator::MulAssign:
4855 case BinaryOperator::DivAssign:
4856 CompResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, true);
4857 CompLHSTy = CompResultTy;
4858 if (!CompResultTy.isNull())
4859 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4860 break;
4861 case BinaryOperator::RemAssign:
4862 CompResultTy = CheckRemainderOperands(lhs, rhs, OpLoc, true);
4863 CompLHSTy = CompResultTy;
4864 if (!CompResultTy.isNull())
4865 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4866 break;
4867 case BinaryOperator::AddAssign:
4868 CompResultTy = CheckAdditionOperands(lhs, rhs, OpLoc, &CompLHSTy);
4869 if (!CompResultTy.isNull())
4870 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4871 break;
4872 case BinaryOperator::SubAssign:
4873 CompResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc, &CompLHSTy);
4874 if (!CompResultTy.isNull())
4875 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4876 break;
4877 case BinaryOperator::ShlAssign:
4878 case BinaryOperator::ShrAssign:
4879 CompResultTy = CheckShiftOperands(lhs, rhs, OpLoc, true);
4880 CompLHSTy = CompResultTy;
4881 if (!CompResultTy.isNull())
4882 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4883 break;
4884 case BinaryOperator::AndAssign:
4885 case BinaryOperator::XorAssign:
4886 case BinaryOperator::OrAssign:
4887 CompResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc, true);
4888 CompLHSTy = CompResultTy;
4889 if (!CompResultTy.isNull())
4890 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy);
4891 break;
4892 case BinaryOperator::Comma:
4893 ResultTy = CheckCommaOperands(lhs, rhs, OpLoc);
4894 break;
4895 }
4896 if (ResultTy.isNull())
4897 return ExprError();
4898 if (CompResultTy.isNull())
4899 return Owned(new (Context) BinaryOperator(lhs, rhs, Opc, ResultTy, OpLoc));
4900 else
4901 return Owned(new (Context) CompoundAssignOperator(lhs, rhs, Opc, ResultTy,
4902 CompLHSTy, CompResultTy,
4903 OpLoc));
4904}
4905
4906// Binary Operators. 'Tok' is the token for the operator.
4907Action::OwningExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
4908 tok::TokenKind Kind,
4909 ExprArg LHS, ExprArg RHS) {
4910 BinaryOperator::Opcode Opc = ConvertTokenKindToBinaryOpcode(Kind);
4911 Expr *lhs = LHS.takeAs<Expr>(), *rhs = RHS.takeAs<Expr>();
4912
4913 assert((lhs != 0) && "ActOnBinOp(): missing left expression");
4914 assert((rhs != 0) && "ActOnBinOp(): missing right expression");
4915
4916 if (getLangOptions().CPlusPlus &&
4917 (lhs->getType()->isOverloadableType() ||
4918 rhs->getType()->isOverloadableType())) {
4919 // Find all of the overloaded operators visible from this
4920 // point. We perform both an operator-name lookup from the local
4921 // scope and an argument-dependent lookup based on the types of
4922 // the arguments.
4923 FunctionSet Functions;
4924 OverloadedOperatorKind OverOp = BinaryOperator::getOverloadedOperator(Opc);
4925 if (OverOp != OO_None) {
4926 LookupOverloadedOperatorName(OverOp, S, lhs->getType(), rhs->getType(),
4927 Functions);
4928 Expr *Args[2] = { lhs, rhs };
4929 DeclarationName OpName
4930 = Context.DeclarationNames.getCXXOperatorName(OverOp);
4931 ArgumentDependentLookup(OpName, Args, 2, Functions);
4932 }
4933
4934 // Build the (potentially-overloaded, potentially-dependent)
4935 // binary operation.
4936 return CreateOverloadedBinOp(TokLoc, Opc, Functions, lhs, rhs);
4937 }
4938
4939 // Build a built-in binary operation.
4940 return CreateBuiltinBinOp(TokLoc, Opc, lhs, rhs);
4941}
4942
4943Action::OwningExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
4944 unsigned OpcIn,
4945 ExprArg InputArg) {
4946 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn);
4947
4948 // FIXME: Input is modified below, but InputArg is not updated appropriately.
4949 Expr *Input = (Expr *)InputArg.get();
4950 QualType resultType;
4951 switch (Opc) {
4952 case UnaryOperator::PostInc:
4953 case UnaryOperator::PostDec:
4954 case UnaryOperator::OffsetOf:
4955 assert(false && "Invalid unary operator");
4956 break;
4957
4958 case UnaryOperator::PreInc:
4959 case UnaryOperator::PreDec:
4960 resultType = CheckIncrementDecrementOperand(Input, OpLoc,
4961 Opc == UnaryOperator::PreInc);
4962 break;
4963 case UnaryOperator::AddrOf:
4964 resultType = CheckAddressOfOperand(Input, OpLoc);
4965 break;
4966 case UnaryOperator::Deref:
4967 DefaultFunctionArrayConversion(Input);
4968 resultType = CheckIndirectionOperand(Input, OpLoc);
4969 break;
4970 case UnaryOperator::Plus:
4971 case UnaryOperator::Minus:
4972 UsualUnaryConversions(Input);
4973 resultType = Input->getType();
4974 if (resultType->isDependentType())
4975 break;
4976 if (resultType->isArithmeticType()) // C99 6.5.3.3p1
4977 break;
4978 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6-7
4979 resultType->isEnumeralType())
4980 break;
4981 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6
4982 Opc == UnaryOperator::Plus &&
4983 resultType->isPointerType())
4984 break;
4985
4986 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
4987 << resultType << Input->getSourceRange());
4988 case UnaryOperator::Not: // bitwise complement
4989 UsualUnaryConversions(Input);
4990 resultType = Input->getType();
4991 if (resultType->isDependentType())
4992 break;
4993 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
4994 if (resultType->isComplexType() || resultType->isComplexIntegerType())
4995 // C99 does not support '~' for complex conjugation.
4996 Diag(OpLoc, diag::ext_integer_complement_complex)
4997 << resultType << Input->getSourceRange();
4998 else if (!resultType->isIntegerType())
4999 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
5000 << resultType << Input->getSourceRange());
5001 break;
5002 case UnaryOperator::LNot: // logical negation
5003 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
5004 DefaultFunctionArrayConversion(Input);
5005 resultType = Input->getType();
5006 if (resultType->isDependentType())
5007 break;
5008 if (!resultType->isScalarType()) // C99 6.5.3.3p1
5009 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
5010 << resultType << Input->getSourceRange());
5011 // LNot always has type int. C99 6.5.3.3p5.
5012 // In C++, it's bool. C++ 5.3.1p8
5013 resultType = getLangOptions().CPlusPlus ? Context.BoolTy : Context.IntTy;
5014 break;
5015 case UnaryOperator::Real:
5016 case UnaryOperator::Imag:
5017 resultType = CheckRealImagOperand(Input, OpLoc, Opc == UnaryOperator::Real);
5018 break;
5019 case UnaryOperator::Extension:
5020 resultType = Input->getType();
5021 break;
5022 }
5023 if (resultType.isNull())
5024 return ExprError();
5025
5026 InputArg.release();
5027 return Owned(new (Context) UnaryOperator(Input, Opc, resultType, OpLoc));
5028}
5029
5030// Unary Operators. 'Tok' is the token for the operator.
5031Action::OwningExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
5032 tok::TokenKind Op, ExprArg input) {
5033 Expr *Input = (Expr*)input.get();
5034 UnaryOperator::Opcode Opc = ConvertTokenKindToUnaryOpcode(Op);
5035
5036 if (getLangOptions().CPlusPlus && Input->getType()->isOverloadableType()) {
5037 // Find all of the overloaded operators visible from this
5038 // point. We perform both an operator-name lookup from the local
5039 // scope and an argument-dependent lookup based on the types of
5040 // the arguments.
5041 FunctionSet Functions;
5042 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
5043 if (OverOp != OO_None) {
5044 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
5045 Functions);
5046 DeclarationName OpName
5047 = Context.DeclarationNames.getCXXOperatorName(OverOp);
5048 ArgumentDependentLookup(OpName, &Input, 1, Functions);
5049 }
5050
5051 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(input));
5052 }
5053
5054 return CreateBuiltinUnaryOp(OpLoc, Opc, move(input));
5055}
5056
5057/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
5058Sema::OwningExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc,
5059 SourceLocation LabLoc,
5060 IdentifierInfo *LabelII) {
5061 // Look up the record for this label identifier.
5062 LabelStmt *&LabelDecl = getLabelMap()[LabelII];
5063
5064 // If we haven't seen this label yet, create a forward reference. It
5065 // will be validated and/or cleaned up in ActOnFinishFunctionBody.
5066 if (LabelDecl == 0)
5067 LabelDecl = new (Context) LabelStmt(LabLoc, LabelII, 0);
5068
5069 // Create the AST node. The address of a label always has type 'void*'.
5070 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, LabelDecl,
5071 Context.getPointerType(Context.VoidTy)));
5072}
5073
5074Sema::OwningExprResult
5075Sema::ActOnStmtExpr(SourceLocation LPLoc, StmtArg substmt,
5076 SourceLocation RPLoc) { // "({..})"
5077 Stmt *SubStmt = static_cast<Stmt*>(substmt.get());
5078 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
5079 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
5080
5081 bool isFileScope = getCurFunctionOrMethodDecl() == 0;
5082 if (isFileScope)
5083 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope));
5084
5085 // FIXME: there are a variety of strange constraints to enforce here, for
5086 // example, it is not possible to goto into a stmt expression apparently.
5087 // More semantic analysis is needed.
5088
5089 // If there are sub stmts in the compound stmt, take the type of the last one
5090 // as the type of the stmtexpr.
5091 QualType Ty = Context.VoidTy;
5092
5093 if (!Compound->body_empty()) {
5094 Stmt *LastStmt = Compound->body_back();
5095 // If LastStmt is a label, skip down through into the body.
5096 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt))
5097 LastStmt = Label->getSubStmt();
5098
5099 if (Expr *LastExpr = dyn_cast<Expr>(LastStmt))
5100 Ty = LastExpr->getType();
5101 }
5102
5103 // FIXME: Check that expression type is complete/non-abstract; statement
5104 // expressions are not lvalues.
5105
5106 substmt.release();
5107 return Owned(new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc));
5108}
5109
5110Sema::OwningExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
5111 SourceLocation BuiltinLoc,
5112 SourceLocation TypeLoc,
5113 TypeTy *argty,
5114 OffsetOfComponent *CompPtr,
5115 unsigned NumComponents,
5116 SourceLocation RPLoc) {
5117 // FIXME: This function leaks all expressions in the offset components on
5118 // error.
5119 QualType ArgTy = QualType::getFromOpaquePtr(argty);
5120 assert(!ArgTy.isNull() && "Missing type argument!");
5121
5122 bool Dependent = ArgTy->isDependentType();
5123
5124 // We must have at least one component that refers to the type, and the first
5125 // one is known to be a field designator. Verify that the ArgTy represents
5126 // a struct/union/class.
5127 if (!Dependent && !ArgTy->isRecordType())
5128 return ExprError(Diag(TypeLoc, diag::err_offsetof_record_type) << ArgTy);
5129
5130 // FIXME: Type must be complete per C99 7.17p3 because a declaring a variable
5131 // with an incomplete type would be illegal.
5132
5133 // Otherwise, create a null pointer as the base, and iteratively process
5134 // the offsetof designators.
5135 QualType ArgTyPtr = Context.getPointerType(ArgTy);
5136 Expr* Res = new (Context) ImplicitValueInitExpr(ArgTyPtr);
5137 Res = new (Context) UnaryOperator(Res, UnaryOperator::Deref,
5138 ArgTy, SourceLocation());
5139
5140 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a
5141 // GCC extension, diagnose them.
5142 // FIXME: This diagnostic isn't actually visible because the location is in
5143 // a system header!
5144 if (NumComponents != 1)
5145 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator)
5146 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd);
5147
5148 if (!Dependent) {
5149 bool DidWarnAboutNonPOD = false;
5150
5151 // FIXME: Dependent case loses a lot of information here. And probably
5152 // leaks like a sieve.
5153 for (unsigned i = 0; i != NumComponents; ++i) {
5154 const OffsetOfComponent &OC = CompPtr[i];
5155 if (OC.isBrackets) {
5156 // Offset of an array sub-field. TODO: Should we allow vector elements?
5157 const ArrayType *AT = Context.getAsArrayType(Res->getType());
5158 if (!AT) {
5159 Res->Destroy(Context);
5160 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
5161 << Res->getType());
5162 }
5163
5164 // FIXME: C++: Verify that operator[] isn't overloaded.
5165
5166 // Promote the array so it looks more like a normal array subscript
5167 // expression.
5168 DefaultFunctionArrayConversion(Res);
5169
5170 // C99 6.5.2.1p1
5171 Expr *Idx = static_cast<Expr*>(OC.U.E);
5172 // FIXME: Leaks Res
5173 if (!Idx->isTypeDependent() && !Idx->getType()->isIntegerType())
5174 return ExprError(Diag(Idx->getLocStart(),
5175 diag::err_typecheck_subscript_not_integer)
5176 << Idx->getSourceRange());
5177
5178 Res = new (Context) ArraySubscriptExpr(Res, Idx, AT->getElementType(),
5179 OC.LocEnd);
5180 continue;
5181 }
5182
5183 const RecordType *RC = Res->getType()->getAsRecordType();
5184 if (!RC) {
5185 Res->Destroy(Context);
5186 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
5187 << Res->getType());
5188 }
5189
5190 // Get the decl corresponding to this.
5191 RecordDecl *RD = RC->getDecl();
5192 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
5193 if (!CRD->isPOD() && !DidWarnAboutNonPOD) {
5194 ExprError(Diag(BuiltinLoc, diag::warn_offsetof_non_pod_type)
5195 << SourceRange(CompPtr[0].LocStart, OC.LocEnd)
5196 << Res->getType());
5197 DidWarnAboutNonPOD = true;
5198 }
5199 }
5200
5201 FieldDecl *MemberDecl
5202 = dyn_cast_or_null<FieldDecl>(LookupQualifiedName(RD, OC.U.IdentInfo,
5203 LookupMemberName)
5204 .getAsDecl());
5205 // FIXME: Leaks Res
5206 if (!MemberDecl)
5207 return ExprError(Diag(BuiltinLoc, diag::err_typecheck_no_member)
5208 << OC.U.IdentInfo << SourceRange(OC.LocStart, OC.LocEnd));
5209
5210 // FIXME: C++: Verify that MemberDecl isn't a static field.
5211 // FIXME: Verify that MemberDecl isn't a bitfield.
5212 if (cast<RecordDecl>(MemberDecl->getDeclContext())->isAnonymousStructOrUnion()) {
5213 Res = BuildAnonymousStructUnionMemberReference(
5214 SourceLocation(), MemberDecl, Res, SourceLocation()).takeAs<Expr>();
5215 } else {
5216 // MemberDecl->getType() doesn't get the right qualifiers, but it
5217 // doesn't matter here.
5218 Res = new (Context) MemberExpr(Res, false, MemberDecl, OC.LocEnd,
5219 MemberDecl->getType().getNonReferenceType());
5220 }
5221 }
5222 }
5223
5224 return Owned(new (Context) UnaryOperator(Res, UnaryOperator::OffsetOf,
5225 Context.getSizeType(), BuiltinLoc));
5226}
5227
5228
5229Sema::OwningExprResult Sema::ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
5230 TypeTy *arg1,TypeTy *arg2,
5231 SourceLocation RPLoc) {
5232 QualType argT1 = QualType::getFromOpaquePtr(arg1);
5233 QualType argT2 = QualType::getFromOpaquePtr(arg2);
5234
5235 assert((!argT1.isNull() && !argT2.isNull()) && "Missing type argument(s)");
5236
5237 if (getLangOptions().CPlusPlus) {
5238 Diag(BuiltinLoc, diag::err_types_compatible_p_in_cplusplus)
5239 << SourceRange(BuiltinLoc, RPLoc);
5240 return ExprError();
5241 }
5242
5243 return Owned(new (Context) TypesCompatibleExpr(Context.IntTy, BuiltinLoc,
5244 argT1, argT2, RPLoc));
5245}
5246
5247Sema::OwningExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
5248 ExprArg cond,
5249 ExprArg expr1, ExprArg expr2,
5250 SourceLocation RPLoc) {
5251 Expr *CondExpr = static_cast<Expr*>(cond.get());
5252 Expr *LHSExpr = static_cast<Expr*>(expr1.get());
5253 Expr *RHSExpr = static_cast<Expr*>(expr2.get());
5254
5255 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
5256
5257 QualType resType;
5258 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
5259 resType = Context.DependentTy;
5260 } else {
5261 // The conditional expression is required to be a constant expression.
5262 llvm::APSInt condEval(32);
5263 SourceLocation ExpLoc;
5264 if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc))
5265 return ExprError(Diag(ExpLoc,
5266 diag::err_typecheck_choose_expr_requires_constant)
5267 << CondExpr->getSourceRange());
5268
5269 // If the condition is > zero, then the AST type is the same as the LSHExpr.
5270 resType = condEval.getZExtValue() ? LHSExpr->getType() : RHSExpr->getType();
5271 }
5272
5273 cond.release(); expr1.release(); expr2.release();
5274 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr,
5275 resType, RPLoc));
5276}
5277
5278//===----------------------------------------------------------------------===//
5279// Clang Extensions.
5280//===----------------------------------------------------------------------===//
5281
5282/// ActOnBlockStart - This callback is invoked when a block literal is started.
5283void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope) {
5284 // Analyze block parameters.
5285 BlockSemaInfo *BSI = new BlockSemaInfo();
5286
5287 // Add BSI to CurBlock.
5288 BSI->PrevBlockInfo = CurBlock;
5289 CurBlock = BSI;
5290
5291 BSI->ReturnType = QualType();
5292 BSI->TheScope = BlockScope;
5293 BSI->hasBlockDeclRefExprs = false;
5294 BSI->SavedFunctionNeedsScopeChecking = CurFunctionNeedsScopeChecking;
5295 CurFunctionNeedsScopeChecking = false;
5296
5297 BSI->TheDecl = BlockDecl::Create(Context, CurContext, CaretLoc);
5298 PushDeclContext(BlockScope, BSI->TheDecl);
5299}
5300
5301void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) {
5302 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!");
5303
5304 if (ParamInfo.getNumTypeObjects() == 0
5305 || ParamInfo.getTypeObject(0).Kind != DeclaratorChunk::Function) {
5306 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
5307 QualType T = GetTypeForDeclarator(ParamInfo, CurScope);
5308
5309 if (T->isArrayType()) {
5310 Diag(ParamInfo.getSourceRange().getBegin(),
5311 diag::err_block_returns_array);
5312 return;
5313 }
5314
5315 // The parameter list is optional, if there was none, assume ().
5316 if (!T->isFunctionType())
5317 T = Context.getFunctionType(T, NULL, 0, 0, 0);
5318
5319 CurBlock->hasPrototype = true;
5320 CurBlock->isVariadic = false;
5321 // Check for a valid sentinel attribute on this block.
|
5229 if (CurBlock->TheDecl->getAttr<SentinelAttr>(Context)) {
| 5322 if (CurBlock->TheDecl->getAttr()) {
|
5230 Diag(ParamInfo.getAttributes()->getLoc(),
5231 diag::warn_attribute_sentinel_not_variadic) << 1;
5232 // FIXME: remove the attribute.
5233 }
5234 QualType RetTy = T.getTypePtr()->getAsFunctionType()->getResultType();
5235
5236 // Do not allow returning a objc interface by-value.
5237 if (RetTy->isObjCInterfaceType()) {
5238 Diag(ParamInfo.getSourceRange().getBegin(),
5239 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
5240 return;
5241 }
5242 return;
5243 }
5244
5245 // Analyze arguments to block.
5246 assert(ParamInfo.getTypeObject(0).Kind == DeclaratorChunk::Function &&
5247 "Not a function declarator!");
5248 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getTypeObject(0).Fun;
5249
5250 CurBlock->hasPrototype = FTI.hasPrototype;
5251 CurBlock->isVariadic = true;
5252
5253 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs function that takes
5254 // no arguments, not a function that takes a single void argument.
5255 if (FTI.hasPrototype &&
5256 FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
5257 (!FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType().getCVRQualifiers()&&
5258 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType())) {
5259 // empty arg list, don't push any params.
5260 CurBlock->isVariadic = false;
5261 } else if (FTI.hasPrototype) {
5262 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i)
5263 CurBlock->Params.push_back(FTI.ArgInfo[i].Param.getAs<ParmVarDecl>());
5264 CurBlock->isVariadic = FTI.isVariadic;
5265 }
5266 CurBlock->TheDecl->setParams(Context, CurBlock->Params.data(),
5267 CurBlock->Params.size());
5268 CurBlock->TheDecl->setIsVariadic(CurBlock->isVariadic);
5269 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
5270 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(),
5271 E = CurBlock->TheDecl->param_end(); AI != E; ++AI)
5272 // If this has an identifier, add it to the scope stack.
5273 if ((*AI)->getIdentifier())
5274 PushOnScopeChains(*AI, CurBlock->TheScope);
5275
5276 // Check for a valid sentinel attribute on this block.
5277 if (!CurBlock->isVariadic &&
| 5323 Diag(ParamInfo.getAttributes()->getLoc(),
5324 diag::warn_attribute_sentinel_not_variadic) << 1;
5325 // FIXME: remove the attribute.
5326 }
5327 QualType RetTy = T.getTypePtr()->getAsFunctionType()->getResultType();
5328
5329 // Do not allow returning a objc interface by-value.
5330 if (RetTy->isObjCInterfaceType()) {
5331 Diag(ParamInfo.getSourceRange().getBegin(),
5332 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
5333 return;
5334 }
5335 return;
5336 }
5337
5338 // Analyze arguments to block.
5339 assert(ParamInfo.getTypeObject(0).Kind == DeclaratorChunk::Function &&
5340 "Not a function declarator!");
5341 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getTypeObject(0).Fun;
5342
5343 CurBlock->hasPrototype = FTI.hasPrototype;
5344 CurBlock->isVariadic = true;
5345
5346 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs function that takes
5347 // no arguments, not a function that takes a single void argument.
5348 if (FTI.hasPrototype &&
5349 FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
5350 (!FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType().getCVRQualifiers()&&
5351 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType())) {
5352 // empty arg list, don't push any params.
5353 CurBlock->isVariadic = false;
5354 } else if (FTI.hasPrototype) {
5355 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i)
5356 CurBlock->Params.push_back(FTI.ArgInfo[i].Param.getAs<ParmVarDecl>());
5357 CurBlock->isVariadic = FTI.isVariadic;
5358 }
5359 CurBlock->TheDecl->setParams(Context, CurBlock->Params.data(),
5360 CurBlock->Params.size());
5361 CurBlock->TheDecl->setIsVariadic(CurBlock->isVariadic);
5362 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
5363 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(),
5364 E = CurBlock->TheDecl->param_end(); AI != E; ++AI)
5365 // If this has an identifier, add it to the scope stack.
5366 if ((*AI)->getIdentifier())
5367 PushOnScopeChains(*AI, CurBlock->TheScope);
5368
5369 // Check for a valid sentinel attribute on this block.
5370 if (!CurBlock->isVariadic &&
|
5278 CurBlock->TheDecl->getAttr<SentinelAttr>(Context)) {
| 5371 CurBlock->TheDecl->getAttr()) {
|
5279 Diag(ParamInfo.getAttributes()->getLoc(),
5280 diag::warn_attribute_sentinel_not_variadic) << 1;
5281 // FIXME: remove the attribute.
5282 }
5283
5284 // Analyze the return type.
5285 QualType T = GetTypeForDeclarator(ParamInfo, CurScope);
5286 QualType RetTy = T->getAsFunctionType()->getResultType();
5287
5288 // Do not allow returning a objc interface by-value.
5289 if (RetTy->isObjCInterfaceType()) {
5290 Diag(ParamInfo.getSourceRange().getBegin(),
5291 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
5292 } else if (!RetTy->isDependentType())
5293 CurBlock->ReturnType = RetTy;
5294}
5295
5296/// ActOnBlockError - If there is an error parsing a block, this callback
5297/// is invoked to pop the information about the block from the action impl.
5298void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
5299 // Ensure that CurBlock is deleted.
5300 llvm::OwningPtr<BlockSemaInfo> CC(CurBlock);
5301
5302 CurFunctionNeedsScopeChecking = CurBlock->SavedFunctionNeedsScopeChecking;
5303
5304 // Pop off CurBlock, handle nested blocks.
5305 PopDeclContext();
5306 CurBlock = CurBlock->PrevBlockInfo;
5307 // FIXME: Delete the ParmVarDecl objects as well???
5308}
5309
5310/// ActOnBlockStmtExpr - This is called when the body of a block statement
5311/// literal was successfully completed. ^(int x){...}
5312Sema::OwningExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
5313 StmtArg body, Scope *CurScope) {
5314 // If blocks are disabled, emit an error.
5315 if (!LangOpts.Blocks)
5316 Diag(CaretLoc, diag::err_blocks_disable);
5317
5318 // Ensure that CurBlock is deleted.
5319 llvm::OwningPtr<BlockSemaInfo> BSI(CurBlock);
5320
5321 PopDeclContext();
5322
5323 // Pop off CurBlock, handle nested blocks.
5324 CurBlock = CurBlock->PrevBlockInfo;
5325
5326 QualType RetTy = Context.VoidTy;
5327 if (!BSI->ReturnType.isNull())
5328 RetTy = BSI->ReturnType;
5329
5330 llvm::SmallVector<QualType, 8> ArgTypes;
5331 for (unsigned i = 0, e = BSI->Params.size(); i != e; ++i)
5332 ArgTypes.push_back(BSI->Params[i]->getType());
5333
5334 QualType BlockTy;
5335 if (!BSI->hasPrototype)
5336 BlockTy = Context.getFunctionType(RetTy, 0, 0, false, 0);
5337 else
5338 BlockTy = Context.getFunctionType(RetTy, ArgTypes.data(), ArgTypes.size(),
5339 BSI->isVariadic, 0);
5340
5341 // FIXME: Check that return/parameter types are complete/non-abstract
5342 DiagnoseUnusedParameters(BSI->Params.begin(), BSI->Params.end());
5343 BlockTy = Context.getBlockPointerType(BlockTy);
5344
5345 // If needed, diagnose invalid gotos and switches in the block.
5346 if (CurFunctionNeedsScopeChecking)
5347 DiagnoseInvalidJumps(static_cast<CompoundStmt*>(body.get()));
5348 CurFunctionNeedsScopeChecking = BSI->SavedFunctionNeedsScopeChecking;
5349
5350 BSI->TheDecl->setBody(body.takeAs<CompoundStmt>());
5351 return Owned(new (Context) BlockExpr(BSI->TheDecl, BlockTy,
5352 BSI->hasBlockDeclRefExprs));
5353}
5354
5355Sema::OwningExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc,
5356 ExprArg expr, TypeTy *type,
5357 SourceLocation RPLoc) {
5358 QualType T = QualType::getFromOpaquePtr(type);
5359 Expr *E = static_cast<Expr*>(expr.get());
5360 Expr *OrigExpr = E;
5361
5362 InitBuiltinVaListType();
5363
5364 // Get the va_list type
5365 QualType VaListType = Context.getBuiltinVaListType();
5366 if (VaListType->isArrayType()) {
5367 // Deal with implicit array decay; for example, on x86-64,
5368 // va_list is an array, but it's supposed to decay to
5369 // a pointer for va_arg.
5370 VaListType = Context.getArrayDecayedType(VaListType);
5371 // Make sure the input expression also decays appropriately.
5372 UsualUnaryConversions(E);
5373 } else {
5374 // Otherwise, the va_list argument must be an l-value because
5375 // it is modified by va_arg.
5376 if (!E->isTypeDependent() &&
5377 CheckForModifiableLvalue(E, BuiltinLoc, *this))
5378 return ExprError();
5379 }
5380
5381 if (!E->isTypeDependent() &&
5382 !Context.hasSameType(VaListType, E->getType())) {
5383 return ExprError(Diag(E->getLocStart(),
5384 diag::err_first_argument_to_va_arg_not_of_type_va_list)
5385 << OrigExpr->getType() << E->getSourceRange());
5386 }
5387
5388 // FIXME: Check that type is complete/non-abstract
5389 // FIXME: Warn if a non-POD type is passed in.
5390
5391 expr.release();
5392 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, T.getNonReferenceType(),
5393 RPLoc));
5394}
5395
5396Sema::OwningExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) {
5397 // The type of __null will be int or long, depending on the size of
5398 // pointers on the target.
5399 QualType Ty;
5400 if (Context.Target.getPointerWidth(0) == Context.Target.getIntWidth())
5401 Ty = Context.IntTy;
5402 else
5403 Ty = Context.LongTy;
5404
5405 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc));
5406}
5407
5408bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
5409 SourceLocation Loc,
5410 QualType DstType, QualType SrcType,
5411 Expr *SrcExpr, const char *Flavor) {
5412 // Decode the result (notice that AST's are still created for extensions).
5413 bool isInvalid = false;
5414 unsigned DiagKind;
5415 switch (ConvTy) {
5416 default: assert(0 && "Unknown conversion type");
5417 case Compatible: return false;
5418 case PointerToInt:
5419 DiagKind = diag::ext_typecheck_convert_pointer_int;
5420 break;
5421 case IntToPointer:
5422 DiagKind = diag::ext_typecheck_convert_int_pointer;
5423 break;
5424 case IncompatiblePointer:
5425 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
5426 break;
5427 case IncompatiblePointerSign:
5428 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
5429 break;
5430 case FunctionVoidPointer:
5431 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
5432 break;
5433 case CompatiblePointerDiscardsQualifiers:
5434 // If the qualifiers lost were because we were applying the
5435 // (deprecated) C++ conversion from a string literal to a char*
5436 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME:
5437 // Ideally, this check would be performed in
5438 // CheckPointerTypesForAssignment. However, that would require a
5439 // bit of refactoring (so that the second argument is an
5440 // expression, rather than a type), which should be done as part
5441 // of a larger effort to fix CheckPointerTypesForAssignment for
5442 // C++ semantics.
5443 if (getLangOptions().CPlusPlus &&
5444 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
5445 return false;
5446 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
5447 break;
5448 case IntToBlockPointer:
5449 DiagKind = diag::err_int_to_block_pointer;
5450 break;
5451 case IncompatibleBlockPointer:
5452 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
5453 break;
5454 case IncompatibleObjCQualifiedId:
5455 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since
5456 // it can give a more specific diagnostic.
5457 DiagKind = diag::warn_incompatible_qualified_id;
5458 break;
5459 case IncompatibleVectors:
5460 DiagKind = diag::warn_incompatible_vectors;
5461 break;
5462 case Incompatible:
5463 DiagKind = diag::err_typecheck_convert_incompatible;
5464 isInvalid = true;
5465 break;
5466 }
5467
5468 Diag(Loc, DiagKind) << DstType << SrcType << Flavor
5469 << SrcExpr->getSourceRange();
5470 return isInvalid;
5471}
5472
5473bool Sema::VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result){
5474 llvm::APSInt ICEResult;
5475 if (E->isIntegerConstantExpr(ICEResult, Context)) {
5476 if (Result)
5477 *Result = ICEResult;
5478 return false;
5479 }
5480
5481 Expr::EvalResult EvalResult;
5482
5483 if (!E->Evaluate(EvalResult, Context) || !EvalResult.Val.isInt() ||
5484 EvalResult.HasSideEffects) {
5485 Diag(E->getExprLoc(), diag::err_expr_not_ice) << E->getSourceRange();
5486
5487 if (EvalResult.Diag) {
5488 // We only show the note if it's not the usual "invalid subexpression"
5489 // or if it's actually in a subexpression.
5490 if (EvalResult.Diag != diag::note_invalid_subexpr_in_ice ||
5491 E->IgnoreParens() != EvalResult.DiagExpr->IgnoreParens())
5492 Diag(EvalResult.DiagLoc, EvalResult.Diag);
5493 }
5494
5495 return true;
5496 }
5497
5498 Diag(E->getExprLoc(), diag::ext_expr_not_ice) <<
5499 E->getSourceRange();
5500
5501 if (EvalResult.Diag &&
5502 Diags.getDiagnosticLevel(diag::ext_expr_not_ice) != Diagnostic::Ignored)
5503 Diag(EvalResult.DiagLoc, EvalResult.Diag);
5504
5505 if (Result)
5506 *Result = EvalResult.Val.getInt();
5507 return false;
5508}
5509
5510Sema::ExpressionEvaluationContext
5511Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext) {
5512 // Introduce a new set of potentially referenced declarations to the stack.
5513 if (NewContext == PotentiallyPotentiallyEvaluated)
5514 PotentiallyReferencedDeclStack.push_back(PotentiallyReferencedDecls());
5515
5516 std::swap(ExprEvalContext, NewContext);
5517 return NewContext;
5518}
5519
5520void
5521Sema::PopExpressionEvaluationContext(ExpressionEvaluationContext OldContext,
5522 ExpressionEvaluationContext NewContext) {
5523 ExprEvalContext = NewContext;
5524
5525 if (OldContext == PotentiallyPotentiallyEvaluated) {
5526 // Mark any remaining declarations in the current position of the stack
5527 // as "referenced". If they were not meant to be referenced, semantic
5528 // analysis would have eliminated them (e.g., in ActOnCXXTypeId).
5529 PotentiallyReferencedDecls RemainingDecls;
5530 RemainingDecls.swap(PotentiallyReferencedDeclStack.back());
5531 PotentiallyReferencedDeclStack.pop_back();
5532
5533 for (PotentiallyReferencedDecls::iterator I = RemainingDecls.begin(),
5534 IEnd = RemainingDecls.end();
5535 I != IEnd; ++I)
5536 MarkDeclarationReferenced(I->first, I->second);
5537 }
5538}
5539
5540/// \brief Note that the given declaration was referenced in the source code.
5541///
5542/// This routine should be invoke whenever a given declaration is referenced
5543/// in the source code, and where that reference occurred. If this declaration
5544/// reference means that the the declaration is used (C++ [basic.def.odr]p2,
5545/// C99 6.9p3), then the declaration will be marked as used.
5546///
5547/// \param Loc the location where the declaration was referenced.
5548///
5549/// \param D the declaration that has been referenced by the source code.
5550void Sema::MarkDeclarationReferenced(SourceLocation Loc, Decl *D) {
5551 assert(D && "No declaration?");
5552
5553 if (D->isUsed())
5554 return;
5555
5556 // Mark a parameter declaration "used", regardless of whether we're in a
5557 // template or not.
5558 if (isa<ParmVarDecl>(D))
5559 D->setUsed(true);
5560
5561 // Do not mark anything as "used" within a dependent context; wait for
5562 // an instantiation.
5563 if (CurContext->isDependentContext())
5564 return;
5565
5566 switch (ExprEvalContext) {
5567 case Unevaluated:
5568 // We are in an expression that is not potentially evaluated; do nothing.
5569 return;
5570
5571 case PotentiallyEvaluated:
5572 // We are in a potentially-evaluated expression, so this declaration is
5573 // "used"; handle this below.
5574 break;
5575
5576 case PotentiallyPotentiallyEvaluated:
5577 // We are in an expression that may be potentially evaluated; queue this
5578 // declaration reference until we know whether the expression is
5579 // potentially evaluated.
5580 PotentiallyReferencedDeclStack.back().push_back(std::make_pair(Loc, D));
5581 return;
5582 }
5583
5584 // Note that this declaration has been used.
5585 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
5586 unsigned TypeQuals;
5587 if (Constructor->isImplicit() && Constructor->isDefaultConstructor()) {
5588 if (!Constructor->isUsed())
5589 DefineImplicitDefaultConstructor(Loc, Constructor);
5590 }
5591 else if (Constructor->isImplicit() &&
5592 Constructor->isCopyConstructor(Context, TypeQuals)) {
5593 if (!Constructor->isUsed())
5594 DefineImplicitCopyConstructor(Loc, Constructor, TypeQuals);
5595 }
5596 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
5597 if (Destructor->isImplicit() && !Destructor->isUsed())
5598 DefineImplicitDestructor(Loc, Destructor);
5599
5600 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D)) {
5601 if (MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
5602 MethodDecl->getOverloadedOperator() == OO_Equal) {
5603 if (!MethodDecl->isUsed())
5604 DefineImplicitOverloadedAssign(Loc, MethodDecl);
5605 }
5606 }
5607 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
5608 // Implicit instantiation of function templates and member functions of
5609 // class templates.
| 5372 Diag(ParamInfo.getAttributes()->getLoc(),
5373 diag::warn_attribute_sentinel_not_variadic) << 1;
5374 // FIXME: remove the attribute.
5375 }
5376
5377 // Analyze the return type.
5378 QualType T = GetTypeForDeclarator(ParamInfo, CurScope);
5379 QualType RetTy = T->getAsFunctionType()->getResultType();
5380
5381 // Do not allow returning a objc interface by-value.
5382 if (RetTy->isObjCInterfaceType()) {
5383 Diag(ParamInfo.getSourceRange().getBegin(),
5384 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy;
5385 } else if (!RetTy->isDependentType())
5386 CurBlock->ReturnType = RetTy;
5387}
5388
5389/// ActOnBlockError - If there is an error parsing a block, this callback
5390/// is invoked to pop the information about the block from the action impl.
5391void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
5392 // Ensure that CurBlock is deleted.
5393 llvm::OwningPtr<BlockSemaInfo> CC(CurBlock);
5394
5395 CurFunctionNeedsScopeChecking = CurBlock->SavedFunctionNeedsScopeChecking;
5396
5397 // Pop off CurBlock, handle nested blocks.
5398 PopDeclContext();
5399 CurBlock = CurBlock->PrevBlockInfo;
5400 // FIXME: Delete the ParmVarDecl objects as well???
5401}
5402
5403/// ActOnBlockStmtExpr - This is called when the body of a block statement
5404/// literal was successfully completed. ^(int x){...}
5405Sema::OwningExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
5406 StmtArg body, Scope *CurScope) {
5407 // If blocks are disabled, emit an error.
5408 if (!LangOpts.Blocks)
5409 Diag(CaretLoc, diag::err_blocks_disable);
5410
5411 // Ensure that CurBlock is deleted.
5412 llvm::OwningPtr<BlockSemaInfo> BSI(CurBlock);
5413
5414 PopDeclContext();
5415
5416 // Pop off CurBlock, handle nested blocks.
5417 CurBlock = CurBlock->PrevBlockInfo;
5418
5419 QualType RetTy = Context.VoidTy;
5420 if (!BSI->ReturnType.isNull())
5421 RetTy = BSI->ReturnType;
5422
5423 llvm::SmallVector<QualType, 8> ArgTypes;
5424 for (unsigned i = 0, e = BSI->Params.size(); i != e; ++i)
5425 ArgTypes.push_back(BSI->Params[i]->getType());
5426
5427 QualType BlockTy;
5428 if (!BSI->hasPrototype)
5429 BlockTy = Context.getFunctionType(RetTy, 0, 0, false, 0);
5430 else
5431 BlockTy = Context.getFunctionType(RetTy, ArgTypes.data(), ArgTypes.size(),
5432 BSI->isVariadic, 0);
5433
5434 // FIXME: Check that return/parameter types are complete/non-abstract
5435 DiagnoseUnusedParameters(BSI->Params.begin(), BSI->Params.end());
5436 BlockTy = Context.getBlockPointerType(BlockTy);
5437
5438 // If needed, diagnose invalid gotos and switches in the block.
5439 if (CurFunctionNeedsScopeChecking)
5440 DiagnoseInvalidJumps(static_cast<CompoundStmt*>(body.get()));
5441 CurFunctionNeedsScopeChecking = BSI->SavedFunctionNeedsScopeChecking;
5442
5443 BSI->TheDecl->setBody(body.takeAs<CompoundStmt>());
5444 return Owned(new (Context) BlockExpr(BSI->TheDecl, BlockTy,
5445 BSI->hasBlockDeclRefExprs));
5446}
5447
5448Sema::OwningExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc,
5449 ExprArg expr, TypeTy *type,
5450 SourceLocation RPLoc) {
5451 QualType T = QualType::getFromOpaquePtr(type);
5452 Expr *E = static_cast<Expr*>(expr.get());
5453 Expr *OrigExpr = E;
5454
5455 InitBuiltinVaListType();
5456
5457 // Get the va_list type
5458 QualType VaListType = Context.getBuiltinVaListType();
5459 if (VaListType->isArrayType()) {
5460 // Deal with implicit array decay; for example, on x86-64,
5461 // va_list is an array, but it's supposed to decay to
5462 // a pointer for va_arg.
5463 VaListType = Context.getArrayDecayedType(VaListType);
5464 // Make sure the input expression also decays appropriately.
5465 UsualUnaryConversions(E);
5466 } else {
5467 // Otherwise, the va_list argument must be an l-value because
5468 // it is modified by va_arg.
5469 if (!E->isTypeDependent() &&
5470 CheckForModifiableLvalue(E, BuiltinLoc, *this))
5471 return ExprError();
5472 }
5473
5474 if (!E->isTypeDependent() &&
5475 !Context.hasSameType(VaListType, E->getType())) {
5476 return ExprError(Diag(E->getLocStart(),
5477 diag::err_first_argument_to_va_arg_not_of_type_va_list)
5478 << OrigExpr->getType() << E->getSourceRange());
5479 }
5480
5481 // FIXME: Check that type is complete/non-abstract
5482 // FIXME: Warn if a non-POD type is passed in.
5483
5484 expr.release();
5485 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, T.getNonReferenceType(),
5486 RPLoc));
5487}
5488
5489Sema::OwningExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) {
5490 // The type of __null will be int or long, depending on the size of
5491 // pointers on the target.
5492 QualType Ty;
5493 if (Context.Target.getPointerWidth(0) == Context.Target.getIntWidth())
5494 Ty = Context.IntTy;
5495 else
5496 Ty = Context.LongTy;
5497
5498 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc));
5499}
5500
5501bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
5502 SourceLocation Loc,
5503 QualType DstType, QualType SrcType,
5504 Expr *SrcExpr, const char *Flavor) {
5505 // Decode the result (notice that AST's are still created for extensions).
5506 bool isInvalid = false;
5507 unsigned DiagKind;
5508 switch (ConvTy) {
5509 default: assert(0 && "Unknown conversion type");
5510 case Compatible: return false;
5511 case PointerToInt:
5512 DiagKind = diag::ext_typecheck_convert_pointer_int;
5513 break;
5514 case IntToPointer:
5515 DiagKind = diag::ext_typecheck_convert_int_pointer;
5516 break;
5517 case IncompatiblePointer:
5518 DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
5519 break;
5520 case IncompatiblePointerSign:
5521 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
5522 break;
5523 case FunctionVoidPointer:
5524 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
5525 break;
5526 case CompatiblePointerDiscardsQualifiers:
5527 // If the qualifiers lost were because we were applying the
5528 // (deprecated) C++ conversion from a string literal to a char*
5529 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME:
5530 // Ideally, this check would be performed in
5531 // CheckPointerTypesForAssignment. However, that would require a
5532 // bit of refactoring (so that the second argument is an
5533 // expression, rather than a type), which should be done as part
5534 // of a larger effort to fix CheckPointerTypesForAssignment for
5535 // C++ semantics.
5536 if (getLangOptions().CPlusPlus &&
5537 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
5538 return false;
5539 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
5540 break;
5541 case IntToBlockPointer:
5542 DiagKind = diag::err_int_to_block_pointer;
5543 break;
5544 case IncompatibleBlockPointer:
5545 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
5546 break;
5547 case IncompatibleObjCQualifiedId:
5548 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since
5549 // it can give a more specific diagnostic.
5550 DiagKind = diag::warn_incompatible_qualified_id;
5551 break;
5552 case IncompatibleVectors:
5553 DiagKind = diag::warn_incompatible_vectors;
5554 break;
5555 case Incompatible:
5556 DiagKind = diag::err_typecheck_convert_incompatible;
5557 isInvalid = true;
5558 break;
5559 }
5560
5561 Diag(Loc, DiagKind) << DstType << SrcType << Flavor
5562 << SrcExpr->getSourceRange();
5563 return isInvalid;
5564}
5565
5566bool Sema::VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result){
5567 llvm::APSInt ICEResult;
5568 if (E->isIntegerConstantExpr(ICEResult, Context)) {
5569 if (Result)
5570 *Result = ICEResult;
5571 return false;
5572 }
5573
5574 Expr::EvalResult EvalResult;
5575
5576 if (!E->Evaluate(EvalResult, Context) || !EvalResult.Val.isInt() ||
5577 EvalResult.HasSideEffects) {
5578 Diag(E->getExprLoc(), diag::err_expr_not_ice) << E->getSourceRange();
5579
5580 if (EvalResult.Diag) {
5581 // We only show the note if it's not the usual "invalid subexpression"
5582 // or if it's actually in a subexpression.
5583 if (EvalResult.Diag != diag::note_invalid_subexpr_in_ice ||
5584 E->IgnoreParens() != EvalResult.DiagExpr->IgnoreParens())
5585 Diag(EvalResult.DiagLoc, EvalResult.Diag);
5586 }
5587
5588 return true;
5589 }
5590
5591 Diag(E->getExprLoc(), diag::ext_expr_not_ice) <<
5592 E->getSourceRange();
5593
5594 if (EvalResult.Diag &&
5595 Diags.getDiagnosticLevel(diag::ext_expr_not_ice) != Diagnostic::Ignored)
5596 Diag(EvalResult.DiagLoc, EvalResult.Diag);
5597
5598 if (Result)
5599 *Result = EvalResult.Val.getInt();
5600 return false;
5601}
5602
5603Sema::ExpressionEvaluationContext
5604Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext) {
5605 // Introduce a new set of potentially referenced declarations to the stack.
5606 if (NewContext == PotentiallyPotentiallyEvaluated)
5607 PotentiallyReferencedDeclStack.push_back(PotentiallyReferencedDecls());
5608
5609 std::swap(ExprEvalContext, NewContext);
5610 return NewContext;
5611}
5612
5613void
5614Sema::PopExpressionEvaluationContext(ExpressionEvaluationContext OldContext,
5615 ExpressionEvaluationContext NewContext) {
5616 ExprEvalContext = NewContext;
5617
5618 if (OldContext == PotentiallyPotentiallyEvaluated) {
5619 // Mark any remaining declarations in the current position of the stack
5620 // as "referenced". If they were not meant to be referenced, semantic
5621 // analysis would have eliminated them (e.g., in ActOnCXXTypeId).
5622 PotentiallyReferencedDecls RemainingDecls;
5623 RemainingDecls.swap(PotentiallyReferencedDeclStack.back());
5624 PotentiallyReferencedDeclStack.pop_back();
5625
5626 for (PotentiallyReferencedDecls::iterator I = RemainingDecls.begin(),
5627 IEnd = RemainingDecls.end();
5628 I != IEnd; ++I)
5629 MarkDeclarationReferenced(I->first, I->second);
5630 }
5631}
5632
5633/// \brief Note that the given declaration was referenced in the source code.
5634///
5635/// This routine should be invoke whenever a given declaration is referenced
5636/// in the source code, and where that reference occurred. If this declaration
5637/// reference means that the the declaration is used (C++ [basic.def.odr]p2,
5638/// C99 6.9p3), then the declaration will be marked as used.
5639///
5640/// \param Loc the location where the declaration was referenced.
5641///
5642/// \param D the declaration that has been referenced by the source code.
5643void Sema::MarkDeclarationReferenced(SourceLocation Loc, Decl *D) {
5644 assert(D && "No declaration?");
5645
5646 if (D->isUsed())
5647 return;
5648
5649 // Mark a parameter declaration "used", regardless of whether we're in a
5650 // template or not.
5651 if (isa<ParmVarDecl>(D))
5652 D->setUsed(true);
5653
5654 // Do not mark anything as "used" within a dependent context; wait for
5655 // an instantiation.
5656 if (CurContext->isDependentContext())
5657 return;
5658
5659 switch (ExprEvalContext) {
5660 case Unevaluated:
5661 // We are in an expression that is not potentially evaluated; do nothing.
5662 return;
5663
5664 case PotentiallyEvaluated:
5665 // We are in a potentially-evaluated expression, so this declaration is
5666 // "used"; handle this below.
5667 break;
5668
5669 case PotentiallyPotentiallyEvaluated:
5670 // We are in an expression that may be potentially evaluated; queue this
5671 // declaration reference until we know whether the expression is
5672 // potentially evaluated.
5673 PotentiallyReferencedDeclStack.back().push_back(std::make_pair(Loc, D));
5674 return;
5675 }
5676
5677 // Note that this declaration has been used.
5678 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
5679 unsigned TypeQuals;
5680 if (Constructor->isImplicit() && Constructor->isDefaultConstructor()) {
5681 if (!Constructor->isUsed())
5682 DefineImplicitDefaultConstructor(Loc, Constructor);
5683 }
5684 else if (Constructor->isImplicit() &&
5685 Constructor->isCopyConstructor(Context, TypeQuals)) {
5686 if (!Constructor->isUsed())
5687 DefineImplicitCopyConstructor(Loc, Constructor, TypeQuals);
5688 }
5689 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
5690 if (Destructor->isImplicit() && !Destructor->isUsed())
5691 DefineImplicitDestructor(Loc, Destructor);
5692
5693 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D)) {
5694 if (MethodDecl->isImplicit() && MethodDecl->isOverloadedOperator() &&
5695 MethodDecl->getOverloadedOperator() == OO_Equal) {
5696 if (!MethodDecl->isUsed())
5697 DefineImplicitOverloadedAssign(Loc, MethodDecl);
5698 }
5699 }
5700 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
5701 // Implicit instantiation of function templates and member functions of
5702 // class templates.
|
5610 if (!Function->getBody(Context)) {
| 5703 if (!Function->getBody()) {
|
5611 // FIXME: distinguish between implicit instantiations of function
5612 // templates and explicit specializations (the latter don't get
5613 // instantiated, naturally).
5614 if (Function->getInstantiatedFromMemberFunction() ||
5615 Function->getPrimaryTemplate())
| 5704 // FIXME: distinguish between implicit instantiations of function
5705 // templates and explicit specializations (the latter don't get
5706 // instantiated, naturally).
5707 if (Function->getInstantiatedFromMemberFunction() ||
5708 Function->getPrimaryTemplate())
|
5616 PendingImplicitInstantiations.push(std::make_pair(Function, Loc));
| 5709 PendingImplicitInstantiations.push_back(std::make_pair(Function, Loc));
|
5617 }
5618
5619
5620 // FIXME: keep track of references to static functions
5621 Function->setUsed(true);
5622 return;
5623 }
5624
5625 if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
5626 (void)Var;
5627 // FIXME: implicit template instantiation
5628 // FIXME: keep track of references to static data?
5629 D->setUsed(true);
5630 }
5631}
5632
| 5710 }
5711
5712
5713 // FIXME: keep track of references to static functions
5714 Function->setUsed(true);
5715 return;
5716 }
5717
5718 if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
5719 (void)Var;
5720 // FIXME: implicit template instantiation
5721 // FIXME: keep track of references to static data?
5722 D->setUsed(true);
5723 }
5724}
5725
|