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)) {
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);
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(),
63 MD->isInstanceMethod());
64 isSilenced |= MD && MD->getAttr<DeprecatedAttr>(Context);
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
83 if (D->getAttr<UnavailableAttr>(Context)) {
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{
98 const SentinelAttr *attr = D->getAttr<SentinelAttr>(Context);
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();
676 for (DeclContext::decl_iterator D = Ctx->decls_begin(Context),
677 DEnd = Ctx->decls_end(Context);
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;
880 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(Context, II,
881 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;
918 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(Context, II,
919 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 }
976
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.
1100 if (!(ADL && isa<FunctionDecl>(VD)) && DiagnoseUseOfDecl(VD, Loc))
1101 return ExprError();
1102
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.
1161 if (VD->getAttr<BlocksAttr>(Context))
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;
1313 Res = new (Context) FloatingLiteral(Literal.GetFloatValue(Format, &isExact),
1314 &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
1992 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Context, &Member))
1993 return PD;
1994 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Context, 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) {
2014 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Context, &Member)) {
2015 GDecl = PD;
2016 break;
2017 }
2018 // Also must look for a getter name which uses property syntax.
2019 if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Context, 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()))
2045 Method = ImpDecl->getInstanceMethod(Context, 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;
2204 if (ObjCIvarDecl *IV = IFTy->getDecl()->lookupInstanceVariable(Context,
2205 &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.
2265 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Context,
2266 &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);
2272 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Context, 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)
2282 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Context,
2283 &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);
2299 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Context, 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)
2309 Getter = ObjCCategoryImpls[i]->getInstanceMethod(Context, 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);
2322 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(Context, 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)
2332 Setter = ObjCCategoryImpls[i]->getInstanceMethod(Context, 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.
2393 if ((Getter = IFace->lookupClassMethod(Context, 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);
2403 ObjCMethodDecl *Setter = IFace->lookupClassMethod(Context, 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)
2413 Setter = ObjCCategoryImpls[i]->getClassMethod(Context, 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.
2627 DeclRefExpr *DRExpr = NULL;
2628 Expr *FnExpr = Fn;
2629 bool ADL = true;
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();
2642 } else if ((DRExpr = dyn_cast<DeclRefExpr>(FnExpr))) {
2643 // Qualified names disable ADL (C++0x [basic.lookup.argdep]p1).
2644 ADL &= !isa<QualifiedDeclRefExpr>(DRExpr);
2645 break;
2646 } else if (UnresolvedFunctionNameExpr *DepName
2647 = dyn_cast<UnresolvedFunctionNameExpr>(FnExpr)) {
2648 UnqualifiedName = DepName->getName();
2649 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;
2660 if (DRExpr) {
2661 FDecl = dyn_cast<FunctionDecl>(DRExpr->getDecl());
2662 if ((FunctionTemplate = dyn_cast<FunctionTemplateDecl>(DRExpr->getDecl())))
2663 FDecl = FunctionTemplate->getTemplatedDecl();
2664 else
2665 FDecl = dyn_cast<FunctionDecl>(DRExpr->getDecl());
2666 Ovl = dyn_cast<OverloadedFunctionDecl>(DRExpr->getDecl());
2667 NDecl = dyn_cast<NamedDecl>(DRExpr->getDecl());
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) {
2681 FDecl = ResolveOverloadedCallFn(Fn, DRExpr? DRExpr->getDecl() : 0,
2682 UnqualifiedName, LParenLoc, Args,
2683 NumArgs, CommaLocs, 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
2690 = dyn_cast_or_null<QualifiedDeclRefExpr>(DRExpr))
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;
2753 if (FDecl->getBody(Context, 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;
2863 for (Field = RD->field_begin(Context), FieldEnd = RD->field_end(Context);
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
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.
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
2954 // All scalar -> ext vector "c-style" casts are legal; the appropriate
2955 // conversion will take place first from scalar to elt type, and then
2956 // splat from elt type to vector.
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 }
3045
3046 const PointerType *LHSPT = LHSTy->getAsPointerType();
3047 const PointerType *RHSPT = RHSTy->getAsPointerType();
3048 const BlockPointerType *LHSBPT = LHSTy->getAsBlockPointerType();
3049 const BlockPointerType *RHSBPT = RHSTy->getAsBlockPointerType();
3050
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
3054 // get the "pointed to" types
3055 QualType lhptee = (LHSPT ? LHSPT->getPointeeType()
3056 : LHSBPT->getPointeeType());
3057 QualType rhptee = (RHSPT ? RHSPT->getPointeeType()
3058 : RHSBPT->getPointeeType());
3059
3060 // ignore qualifiers on void (C99 6.5.15p3, clause 6)
3061 if (lhptee->isVoidType()
3062 && (RHSBPT || 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 }
3070 if (rhptee->isVoidType()
3071 && (LHSBPT || 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
3079 bool sameKind = (LHSPT && RHSPT) || (LHSBPT && RHSBPT);
3080 if (sameKind
3081 && Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
3082 // Two identical pointer types are always compatible.
3083 return LHSTy;
3084 }
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())) {
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
3152 ImpCastExprToType(LHS, compositeType);
3153 ImpCastExprToType(RHS, compositeType);
3154 return compositeType;
3155 }
3156
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
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
3388 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();
3495 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>(Context))
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.
3502 for (RecordDecl::field_iterator it = UD->field_begin(Context),
3503 itend = UD->field_end(Context);
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
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 }
3631 }
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;
3643 }
3644 }
3645
3646 // You cannot convert between vector values of different size.
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
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()) {
4149 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())) {
4157 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.
5229 if (CurBlock->TheDecl->getAttr<SentinelAttr>(Context)) {
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 &&
5278 CurBlock->TheDecl->getAttr<SentinelAttr>(Context)) {
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.
5610 if (!Function->getBody(Context)) {
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())
5616 PendingImplicitInstantiations.push(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