clang  9.0.0
SemaExpr.cpp
Go to the documentation of this file.
1 //===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements semantic analysis for expressions.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "TreeTransform.h"
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTLambda.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/ExprObjC.h"
25 #include "clang/AST/ExprOpenMP.h"
27 #include "clang/AST/TypeLoc.h"
28 #include "clang/Basic/FixedPoint.h"
31 #include "clang/Basic/TargetInfo.h"
33 #include "clang/Lex/Preprocessor.h"
35 #include "clang/Sema/DeclSpec.h"
37 #include "clang/Sema/Designator.h"
39 #include "clang/Sema/Lookup.h"
40 #include "clang/Sema/Overload.h"
42 #include "clang/Sema/Scope.h"
43 #include "clang/Sema/ScopeInfo.h"
46 #include "clang/Sema/Template.h"
47 #include "llvm/Support/ConvertUTF.h"
48 using namespace clang;
49 using namespace sema;
50 
51 /// Determine whether the use of this declaration is valid, without
52 /// emitting diagnostics.
53 bool Sema::CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid) {
54  // See if this is an auto-typed variable whose initializer we are parsing.
55  if (ParsingInitForAutoVars.count(D))
56  return false;
57 
58  // See if this is a deleted function.
59  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
60  if (FD->isDeleted())
61  return false;
62 
63  // If the function has a deduced return type, and we can't deduce it,
64  // then we can't use it either.
65  if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
66  DeduceReturnType(FD, SourceLocation(), /*Diagnose*/ false))
67  return false;
68 
69  // See if this is an aligned allocation/deallocation function that is
70  // unavailable.
71  if (TreatUnavailableAsInvalid &&
72  isUnavailableAlignedAllocationFunction(*FD))
73  return false;
74  }
75 
76  // See if this function is unavailable.
77  if (TreatUnavailableAsInvalid && D->getAvailability() == AR_Unavailable &&
78  cast<Decl>(CurContext)->getAvailability() != AR_Unavailable)
79  return false;
80 
81  return true;
82 }
83 
85  // Warn if this is used but marked unused.
86  if (const auto *A = D->getAttr<UnusedAttr>()) {
87  // [[maybe_unused]] should not diagnose uses, but __attribute__((unused))
88  // should diagnose them.
89  if (A->getSemanticSpelling() != UnusedAttr::CXX11_maybe_unused &&
90  A->getSemanticSpelling() != UnusedAttr::C2x_maybe_unused) {
91  const Decl *DC = cast_or_null<Decl>(S.getCurObjCLexicalContext());
92  if (DC && !DC->hasAttr<UnusedAttr>())
93  S.Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName();
94  }
95  }
96 }
97 
98 /// Emit a note explaining that this function is deleted.
100  assert(Decl->isDeleted());
101 
102  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl);
103 
104  if (Method && Method->isDeleted() && Method->isDefaulted()) {
105  // If the method was explicitly defaulted, point at that declaration.
106  if (!Method->isImplicit())
107  Diag(Decl->getLocation(), diag::note_implicitly_deleted);
108 
109  // Try to diagnose why this special member function was implicitly
110  // deleted. This might fail, if that reason no longer applies.
111  CXXSpecialMember CSM = getSpecialMember(Method);
112  if (CSM != CXXInvalid)
113  ShouldDeleteSpecialMember(Method, CSM, nullptr, /*Diagnose=*/true);
114 
115  return;
116  }
117 
118  auto *Ctor = dyn_cast<CXXConstructorDecl>(Decl);
119  if (Ctor && Ctor->isInheritingConstructor())
120  return NoteDeletedInheritingConstructor(Ctor);
121 
122  Diag(Decl->getLocation(), diag::note_availability_specified_here)
123  << Decl << 1;
124 }
125 
126 /// Determine whether a FunctionDecl was ever declared with an
127 /// explicit storage class.
129  for (auto I : D->redecls()) {
130  if (I->getStorageClass() != SC_None)
131  return true;
132  }
133  return false;
134 }
135 
136 /// Check whether we're in an extern inline function and referring to a
137 /// variable or function with internal linkage (C11 6.7.4p3).
138 ///
139 /// This is only a warning because we used to silently accept this code, but
140 /// in many cases it will not behave correctly. This is not enabled in C++ mode
141 /// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)
142 /// and so while there may still be user mistakes, most of the time we can't
143 /// prove that there are errors.
145  const NamedDecl *D,
146  SourceLocation Loc) {
147  // This is disabled under C++; there are too many ways for this to fire in
148  // contexts where the warning is a false positive, or where it is technically
149  // correct but benign.
150  if (S.getLangOpts().CPlusPlus)
151  return;
152 
153  // Check if this is an inlined function or method.
154  FunctionDecl *Current = S.getCurFunctionDecl();
155  if (!Current)
156  return;
157  if (!Current->isInlined())
158  return;
159  if (!Current->isExternallyVisible())
160  return;
161 
162  // Check if the decl has internal linkage.
163  if (D->getFormalLinkage() != InternalLinkage)
164  return;
165 
166  // Downgrade from ExtWarn to Extension if
167  // (1) the supposedly external inline function is in the main file,
168  // and probably won't be included anywhere else.
169  // (2) the thing we're referencing is a pure function.
170  // (3) the thing we're referencing is another inline function.
171  // This last can give us false negatives, but it's better than warning on
172  // wrappers for simple C library functions.
173  const FunctionDecl *UsedFn = dyn_cast<FunctionDecl>(D);
174  bool DowngradeWarning = S.getSourceManager().isInMainFile(Loc);
175  if (!DowngradeWarning && UsedFn)
176  DowngradeWarning = UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>();
177 
178  S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet
179  : diag::ext_internal_in_extern_inline)
180  << /*IsVar=*/!UsedFn << D;
181 
183 
184  S.Diag(D->getCanonicalDecl()->getLocation(), diag::note_entity_declared_at)
185  << D;
186 }
187 
189  const FunctionDecl *First = Cur->getFirstDecl();
190 
191  // Suggest "static" on the function, if possible.
192  if (!hasAnyExplicitStorageClass(First)) {
193  SourceLocation DeclBegin = First->getSourceRange().getBegin();
194  Diag(DeclBegin, diag::note_convert_inline_to_static)
195  << Cur << FixItHint::CreateInsertion(DeclBegin, "static ");
196  }
197 }
198 
199 /// Determine whether the use of this declaration is valid, and
200 /// emit any corresponding diagnostics.
201 ///
202 /// This routine diagnoses various problems with referencing
203 /// declarations that can occur when using a declaration. For example,
204 /// it might warn if a deprecated or unavailable declaration is being
205 /// used, or produce an error (and return true) if a C++0x deleted
206 /// function is being used.
207 ///
208 /// \returns true if there was an error (this declaration cannot be
209 /// referenced), false otherwise.
210 ///
212  const ObjCInterfaceDecl *UnknownObjCClass,
213  bool ObjCPropertyAccess,
214  bool AvoidPartialAvailabilityChecks,
215  ObjCInterfaceDecl *ClassReceiver) {
216  SourceLocation Loc = Locs.front();
217  if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) {
218  // If there were any diagnostics suppressed by template argument deduction,
219  // emit them now.
220  auto Pos = SuppressedDiagnostics.find(D->getCanonicalDecl());
221  if (Pos != SuppressedDiagnostics.end()) {
222  for (const PartialDiagnosticAt &Suppressed : Pos->second)
223  Diag(Suppressed.first, Suppressed.second);
224 
225  // Clear out the list of suppressed diagnostics, so that we don't emit
226  // them again for this specialization. However, we don't obsolete this
227  // entry from the table, because we want to avoid ever emitting these
228  // diagnostics again.
229  Pos->second.clear();
230  }
231 
232  // C++ [basic.start.main]p3:
233  // The function 'main' shall not be used within a program.
234  if (cast<FunctionDecl>(D)->isMain())
235  Diag(Loc, diag::ext_main_used);
236 
237  diagnoseUnavailableAlignedAllocation(*cast<FunctionDecl>(D), Loc);
238  }
239 
240  // See if this is an auto-typed variable whose initializer we are parsing.
241  if (ParsingInitForAutoVars.count(D)) {
242  if (isa<BindingDecl>(D)) {
243  Diag(Loc, diag::err_binding_cannot_appear_in_own_initializer)
244  << D->getDeclName();
245  } else {
246  Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
247  << D->getDeclName() << cast<VarDecl>(D)->getType();
248  }
249  return true;
250  }
251 
252  // See if this is a deleted function.
253  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
254  if (FD->isDeleted()) {
255  auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
256  if (Ctor && Ctor->isInheritingConstructor())
257  Diag(Loc, diag::err_deleted_inherited_ctor_use)
258  << Ctor->getParent()
259  << Ctor->getInheritedConstructor().getConstructor()->getParent();
260  else
261  Diag(Loc, diag::err_deleted_function_use);
262  NoteDeletedFunction(FD);
263  return true;
264  }
265 
266  // If the function has a deduced return type, and we can't deduce it,
267  // then we can't use it either.
268  if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
269  DeduceReturnType(FD, Loc))
270  return true;
271 
272  if (getLangOpts().CUDA && !CheckCUDACall(Loc, FD))
273  return true;
274  }
275 
276  if (auto *MD = dyn_cast<CXXMethodDecl>(D)) {
277  // Lambdas are only default-constructible or assignable in C++2a onwards.
278  if (MD->getParent()->isLambda() &&
279  ((isa<CXXConstructorDecl>(MD) &&
280  cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
281  MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
282  Diag(Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
283  << !isa<CXXConstructorDecl>(MD);
284  }
285  }
286 
287  auto getReferencedObjCProp = [](const NamedDecl *D) ->
288  const ObjCPropertyDecl * {
289  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
290  return MD->findPropertyDecl();
291  return nullptr;
292  };
293  if (const ObjCPropertyDecl *ObjCPDecl = getReferencedObjCProp(D)) {
294  if (diagnoseArgIndependentDiagnoseIfAttrs(ObjCPDecl, Loc))
295  return true;
296  } else if (diagnoseArgIndependentDiagnoseIfAttrs(D, Loc)) {
297  return true;
298  }
299 
300  // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
301  // Only the variables omp_in and omp_out are allowed in the combiner.
302  // Only the variables omp_priv and omp_orig are allowed in the
303  // initializer-clause.
304  auto *DRD = dyn_cast<OMPDeclareReductionDecl>(CurContext);
305  if (LangOpts.OpenMP && DRD && !CurContext->containsDecl(D) &&
306  isa<VarDecl>(D)) {
307  Diag(Loc, diag::err_omp_wrong_var_in_declare_reduction)
308  << getCurFunction()->HasOMPDeclareReductionCombiner;
309  Diag(D->getLocation(), diag::note_entity_declared_at) << D;
310  return true;
311  }
312 
313  // [OpenMP 5.0], 2.19.7.3. declare mapper Directive, Restrictions
314  // List-items in map clauses on this construct may only refer to the declared
315  // variable var and entities that could be referenced by a procedure defined
316  // at the same location
317  auto *DMD = dyn_cast<OMPDeclareMapperDecl>(CurContext);
318  if (LangOpts.OpenMP && DMD && !CurContext->containsDecl(D) &&
319  isa<VarDecl>(D)) {
320  Diag(Loc, diag::err_omp_declare_mapper_wrong_var)
321  << DMD->getVarName().getAsString();
322  Diag(D->getLocation(), diag::note_entity_declared_at) << D;
323  return true;
324  }
325 
326  DiagnoseAvailabilityOfDecl(D, Locs, UnknownObjCClass, ObjCPropertyAccess,
327  AvoidPartialAvailabilityChecks, ClassReceiver);
328 
329  DiagnoseUnusedOfDecl(*this, D, Loc);
330 
332 
333  return false;
334 }
335 
336 /// DiagnoseSentinelCalls - This routine checks whether a call or
337 /// message-send is to a declaration with the sentinel attribute, and
338 /// if so, it checks that the requirements of the sentinel are
339 /// satisfied.
341  ArrayRef<Expr *> Args) {
342  const SentinelAttr *attr = D->getAttr<SentinelAttr>();
343  if (!attr)
344  return;
345 
346  // The number of formal parameters of the declaration.
347  unsigned numFormalParams;
348 
349  // The kind of declaration. This is also an index into a %select in
350  // the diagnostic.
351  enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType;
352 
353  if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
354  numFormalParams = MD->param_size();
355  calleeType = CT_Method;
356  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
357  numFormalParams = FD->param_size();
358  calleeType = CT_Function;
359  } else if (isa<VarDecl>(D)) {
360  QualType type = cast<ValueDecl>(D)->getType();
361  const FunctionType *fn = nullptr;
362  if (const PointerType *ptr = type->getAs<PointerType>()) {
363  fn = ptr->getPointeeType()->getAs<FunctionType>();
364  if (!fn) return;
365  calleeType = CT_Function;
366  } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) {
367  fn = ptr->getPointeeType()->castAs<FunctionType>();
368  calleeType = CT_Block;
369  } else {
370  return;
371  }
372 
373  if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) {
374  numFormalParams = proto->getNumParams();
375  } else {
376  numFormalParams = 0;
377  }
378  } else {
379  return;
380  }
381 
382  // "nullPos" is the number of formal parameters at the end which
383  // effectively count as part of the variadic arguments. This is
384  // useful if you would prefer to not have *any* formal parameters,
385  // but the language forces you to have at least one.
386  unsigned nullPos = attr->getNullPos();
387  assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel");
388  numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos);
389 
390  // The number of arguments which should follow the sentinel.
391  unsigned numArgsAfterSentinel = attr->getSentinel();
392 
393  // If there aren't enough arguments for all the formal parameters,
394  // the sentinel, and the args after the sentinel, complain.
395  if (Args.size() < numFormalParams + numArgsAfterSentinel + 1) {
396  Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
397  Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType);
398  return;
399  }
400 
401  // Otherwise, find the sentinel expression.
402  Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1];
403  if (!sentinelExpr) return;
404  if (sentinelExpr->isValueDependent()) return;
405  if (Context.isSentinelNullExpr(sentinelExpr)) return;
406 
407  // Pick a reasonable string to insert. Optimistically use 'nil', 'nullptr',
408  // or 'NULL' if those are actually defined in the context. Only use
409  // 'nil' for ObjC methods, where it's much more likely that the
410  // variadic arguments form a list of object pointers.
411  SourceLocation MissingNilLoc = getLocForEndOfToken(sentinelExpr->getEndLoc());
412  std::string NullValue;
413  if (calleeType == CT_Method && PP.isMacroDefined("nil"))
414  NullValue = "nil";
415  else if (getLangOpts().CPlusPlus11)
416  NullValue = "nullptr";
417  else if (PP.isMacroDefined("NULL"))
418  NullValue = "NULL";
419  else
420  NullValue = "(void*) 0";
421 
422  if (MissingNilLoc.isInvalid())
423  Diag(Loc, diag::warn_missing_sentinel) << int(calleeType);
424  else
425  Diag(MissingNilLoc, diag::warn_missing_sentinel)
426  << int(calleeType)
427  << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue);
428  Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType);
429 }
430 
432  return E ? E->getSourceRange() : SourceRange();
433 }
434 
435 //===----------------------------------------------------------------------===//
436 // Standard Promotions and Conversions
437 //===----------------------------------------------------------------------===//
438 
439 /// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
441  // Handle any placeholder expressions which made it here.
442  if (E->getType()->isPlaceholderType()) {
443  ExprResult result = CheckPlaceholderExpr(E);
444  if (result.isInvalid()) return ExprError();
445  E = result.get();
446  }
447 
448  QualType Ty = E->getType();
449  assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
450 
451  if (Ty->isFunctionType()) {
452  if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()))
453  if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
454  if (!checkAddressOfFunctionIsAvailable(FD, Diagnose, E->getExprLoc()))
455  return ExprError();
456 
457  E = ImpCastExprToType(E, Context.getPointerType(Ty),
458  CK_FunctionToPointerDecay).get();
459  } else if (Ty->isArrayType()) {
460  // In C90 mode, arrays only promote to pointers if the array expression is
461  // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
462  // type 'array of type' is converted to an expression that has type 'pointer
463  // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
464  // that has type 'array of type' ...". The relevant change is "an lvalue"
465  // (C90) to "an expression" (C99).
466  //
467  // C++ 4.2p1:
468  // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
469  // T" can be converted to an rvalue of type "pointer to T".
470  //
471  if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue())
472  E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty),
473  CK_ArrayToPointerDecay).get();
474  }
475  return E;
476 }
477 
479  // Check to see if we are dereferencing a null pointer. If so,
480  // and if not volatile-qualified, this is undefined behavior that the
481  // optimizer will delete, so warn about it. People sometimes try to use this
482  // to get a deterministic trap and are surprised by clang's behavior. This
483  // only handles the pattern "*null", which is a very syntactic check.
484  if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts()))
485  if (UO->getOpcode() == UO_Deref &&
486  UO->getSubExpr()->IgnoreParenCasts()->
487  isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) &&
488  !UO->getType().isVolatileQualified()) {
489  S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
490  S.PDiag(diag::warn_indirection_through_null)
491  << UO->getSubExpr()->getSourceRange());
492  S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
493  S.PDiag(diag::note_indirection_through_null));
494  }
495 }
496 
497 static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
498  SourceLocation AssignLoc,
499  const Expr* RHS) {
500  const ObjCIvarDecl *IV = OIRE->getDecl();
501  if (!IV)
502  return;
503 
504  DeclarationName MemberName = IV->getDeclName();
505  IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
506  if (!Member || !Member->isStr("isa"))
507  return;
508 
509  const Expr *Base = OIRE->getBase();
510  QualType BaseType = Base->getType();
511  if (OIRE->isArrow())
512  BaseType = BaseType->getPointeeType();
513  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>())
514  if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {
515  ObjCInterfaceDecl *ClassDeclared = nullptr;
516  ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
517  if (!ClassDeclared->getSuperClass()
518  && (*ClassDeclared->ivar_begin()) == IV) {
519  if (RHS) {
520  NamedDecl *ObjectSetClass =
522  &S.Context.Idents.get("object_setClass"),
524  if (ObjectSetClass) {
525  SourceLocation RHSLocEnd = S.getLocForEndOfToken(RHS->getEndLoc());
526  S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign)
528  "object_setClass(")
530  SourceRange(OIRE->getOpLoc(), AssignLoc), ",")
531  << FixItHint::CreateInsertion(RHSLocEnd, ")");
532  }
533  else
534  S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign);
535  } else {
536  NamedDecl *ObjectGetClass =
538  &S.Context.Idents.get("object_getClass"),
540  if (ObjectGetClass)
541  S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use)
543  "object_getClass(")
545  SourceRange(OIRE->getOpLoc(), OIRE->getEndLoc()), ")");
546  else
547  S.Diag(OIRE->getLocation(), diag::warn_objc_isa_use);
548  }
549  S.Diag(IV->getLocation(), diag::note_ivar_decl);
550  }
551  }
552 }
553 
555  // Handle any placeholder expressions which made it here.
556  if (E->getType()->isPlaceholderType()) {
557  ExprResult result = CheckPlaceholderExpr(E);
558  if (result.isInvalid()) return ExprError();
559  E = result.get();
560  }
561 
562  // C++ [conv.lval]p1:
563  // A glvalue of a non-function, non-array type T can be
564  // converted to a prvalue.
565  if (!E->isGLValue()) return E;
566 
567  QualType T = E->getType();
568  assert(!T.isNull() && "r-value conversion on typeless expression?");
569 
570  // We don't want to throw lvalue-to-rvalue casts on top of
571  // expressions of certain types in C++.
572  if (getLangOpts().CPlusPlus &&
573  (E->getType() == Context.OverloadTy ||
574  T->isDependentType() ||
575  T->isRecordType()))
576  return E;
577 
578  // The C standard is actually really unclear on this point, and
579  // DR106 tells us what the result should be but not why. It's
580  // generally best to say that void types just doesn't undergo
581  // lvalue-to-rvalue at all. Note that expressions of unqualified
582  // 'void' type are never l-values, but qualified void can be.
583  if (T->isVoidType())
584  return E;
585 
586  // OpenCL usually rejects direct accesses to values of 'half' type.
587  if (getLangOpts().OpenCL && !getOpenCLOptions().isEnabled("cl_khr_fp16") &&
588  T->isHalfType()) {
589  Diag(E->getExprLoc(), diag::err_opencl_half_load_store)
590  << 0 << T;
591  return ExprError();
592  }
593 
595  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {
596  NamedDecl *ObjectGetClass = LookupSingleName(TUScope,
597  &Context.Idents.get("object_getClass"),
598  SourceLocation(), LookupOrdinaryName);
599  if (ObjectGetClass)
600  Diag(E->getExprLoc(), diag::warn_objc_isa_use)
601  << FixItHint::CreateInsertion(OISA->getBeginLoc(), "object_getClass(")
603  SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")");
604  else
605  Diag(E->getExprLoc(), diag::warn_objc_isa_use);
606  }
607  else if (const ObjCIvarRefExpr *OIRE =
608  dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))
609  DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr);
610 
611  // C++ [conv.lval]p1:
612  // [...] If T is a non-class type, the type of the prvalue is the
613  // cv-unqualified version of T. Otherwise, the type of the
614  // rvalue is T.
615  //
616  // C99 6.3.2.1p2:
617  // If the lvalue has qualified type, the value has the unqualified
618  // version of the type of the lvalue; otherwise, the value has the
619  // type of the lvalue.
620  if (T.hasQualifiers())
621  T = T.getUnqualifiedType();
622 
623  // Under the MS ABI, lock down the inheritance model now.
624  if (T->isMemberPointerType() &&
625  Context.getTargetInfo().getCXXABI().isMicrosoft())
626  (void)isCompleteType(E->getExprLoc(), T);
627 
628  ExprResult Res = CheckLValueToRValueConversionOperand(E);
629  if (Res.isInvalid())
630  return Res;
631  E = Res.get();
632 
633  // Loading a __weak object implicitly retains the value, so we need a cleanup to
634  // balance that.
636  Cleanup.setExprNeedsCleanups(true);
637 
638  // C++ [conv.lval]p3:
639  // If T is cv std::nullptr_t, the result is a null pointer constant.
640  CastKind CK = T->isNullPtrType() ? CK_NullToPointer : CK_LValueToRValue;
641  Res = ImplicitCastExpr::Create(Context, T, CK, E, nullptr, VK_RValue);
642 
643  // C11 6.3.2.1p2:
644  // ... if the lvalue has atomic type, the value has the non-atomic version
645  // of the type of the lvalue ...
646  if (const AtomicType *Atomic = T->getAs<AtomicType>()) {
647  T = Atomic->getValueType().getUnqualifiedType();
648  Res = ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, Res.get(),
649  nullptr, VK_RValue);
650  }
651 
652  return Res;
653 }
654 
656  ExprResult Res = DefaultFunctionArrayConversion(E, Diagnose);
657  if (Res.isInvalid())
658  return ExprError();
659  Res = DefaultLvalueConversion(Res.get());
660  if (Res.isInvalid())
661  return ExprError();
662  return Res;
663 }
664 
665 /// CallExprUnaryConversions - a special case of an unary conversion
666 /// performed on a function designator of a call expression.
668  QualType Ty = E->getType();
669  ExprResult Res = E;
670  // Only do implicit cast for a function type, but not for a pointer
671  // to function type.
672  if (Ty->isFunctionType()) {
673  Res = ImpCastExprToType(E, Context.getPointerType(Ty),
674  CK_FunctionToPointerDecay).get();
675  if (Res.isInvalid())
676  return ExprError();
677  }
678  Res = DefaultLvalueConversion(Res.get());
679  if (Res.isInvalid())
680  return ExprError();
681  return Res.get();
682 }
683 
684 /// UsualUnaryConversions - Performs various conversions that are common to most
685 /// operators (C99 6.3). The conversions of array and function types are
686 /// sometimes suppressed. For example, the array->pointer conversion doesn't
687 /// apply if the array is an argument to the sizeof or address (&) operators.
688 /// In these instances, this routine should *not* be called.
690  // First, convert to an r-value.
691  ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
692  if (Res.isInvalid())
693  return ExprError();
694  E = Res.get();
695 
696  QualType Ty = E->getType();
697  assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
698 
699  // Half FP have to be promoted to float unless it is natively supported
700  if (Ty->isHalfType() && !getLangOpts().NativeHalfType)
701  return ImpCastExprToType(Res.get(), Context.FloatTy, CK_FloatingCast);
702 
703  // Try to perform integral promotions if the object has a theoretically
704  // promotable type.
706  // C99 6.3.1.1p2:
707  //
708  // The following may be used in an expression wherever an int or
709  // unsigned int may be used:
710  // - an object or expression with an integer type whose integer
711  // conversion rank is less than or equal to the rank of int
712  // and unsigned int.
713  // - A bit-field of type _Bool, int, signed int, or unsigned int.
714  //
715  // If an int can represent all values of the original type, the
716  // value is converted to an int; otherwise, it is converted to an
717  // unsigned int. These are called the integer promotions. All
718  // other types are unchanged by the integer promotions.
719 
720  QualType PTy = Context.isPromotableBitField(E);
721  if (!PTy.isNull()) {
722  E = ImpCastExprToType(E, PTy, CK_IntegralCast).get();
723  return E;
724  }
725  if (Ty->isPromotableIntegerType()) {
726  QualType PT = Context.getPromotedIntegerType(Ty);
727  E = ImpCastExprToType(E, PT, CK_IntegralCast).get();
728  return E;
729  }
730  }
731  return E;
732 }
733 
734 /// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
735 /// do not have a prototype. Arguments that have type float or __fp16
736 /// are promoted to double. All other argument types are converted by
737 /// UsualUnaryConversions().
739  QualType Ty = E->getType();
740  assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
741 
742  ExprResult Res = UsualUnaryConversions(E);
743  if (Res.isInvalid())
744  return ExprError();
745  E = Res.get();
746 
747  // If this is a 'float' or '__fp16' (CVR qualified or typedef)
748  // promote to double.
749  // Note that default argument promotion applies only to float (and
750  // half/fp16); it does not apply to _Float16.
751  const BuiltinType *BTy = Ty->getAs<BuiltinType>();
752  if (BTy && (BTy->getKind() == BuiltinType::Half ||
753  BTy->getKind() == BuiltinType::Float)) {
754  if (getLangOpts().OpenCL &&
755  !getOpenCLOptions().isEnabled("cl_khr_fp64")) {
756  if (BTy->getKind() == BuiltinType::Half) {
757  E = ImpCastExprToType(E, Context.FloatTy, CK_FloatingCast).get();
758  }
759  } else {
760  E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get();
761  }
762  }
763 
764  // C++ performs lvalue-to-rvalue conversion as a default argument
765  // promotion, even on class types, but note:
766  // C++11 [conv.lval]p2:
767  // When an lvalue-to-rvalue conversion occurs in an unevaluated
768  // operand or a subexpression thereof the value contained in the
769  // referenced object is not accessed. Otherwise, if the glvalue
770  // has a class type, the conversion copy-initializes a temporary
771  // of type T from the glvalue and the result of the conversion
772  // is a prvalue for the temporary.
773  // FIXME: add some way to gate this entire thing for correctness in
774  // potentially potentially evaluated contexts.
775  if (getLangOpts().CPlusPlus && E->isGLValue() && !isUnevaluatedContext()) {
776  ExprResult Temp = PerformCopyInitialization(
778  E->getExprLoc(), E);
779  if (Temp.isInvalid())
780  return ExprError();
781  E = Temp.get();
782  }
783 
784  return E;
785 }
786 
787 /// Determine the degree of POD-ness for an expression.
788 /// Incomplete types are considered POD, since this check can be performed
789 /// when we're in an unevaluated context.
791  if (Ty->isIncompleteType()) {
792  // C++11 [expr.call]p7:
793  // After these conversions, if the argument does not have arithmetic,
794  // enumeration, pointer, pointer to member, or class type, the program
795  // is ill-formed.
796  //
797  // Since we've already performed array-to-pointer and function-to-pointer
798  // decay, the only such type in C++ is cv void. This also handles
799  // initializer lists as variadic arguments.
800  if (Ty->isVoidType())
801  return VAK_Invalid;
802 
803  if (Ty->isObjCObjectType())
804  return VAK_Invalid;
805  return VAK_Valid;
806  }
807 
809  return VAK_Invalid;
810 
811  if (Ty.isCXX98PODType(Context))
812  return VAK_Valid;
813 
814  // C++11 [expr.call]p7:
815  // Passing a potentially-evaluated argument of class type (Clause 9)
816  // having a non-trivial copy constructor, a non-trivial move constructor,
817  // or a non-trivial destructor, with no corresponding parameter,
818  // is conditionally-supported with implementation-defined semantics.
819  if (getLangOpts().CPlusPlus11 && !Ty->isDependentType())
820  if (CXXRecordDecl *Record = Ty->getAsCXXRecordDecl())
821  if (!Record->hasNonTrivialCopyConstructor() &&
822  !Record->hasNonTrivialMoveConstructor() &&
823  !Record->hasNonTrivialDestructor())
824  return VAK_ValidInCXX11;
825 
826  if (getLangOpts().ObjCAutoRefCount && Ty->isObjCLifetimeType())
827  return VAK_Valid;
828 
829  if (Ty->isObjCObjectType())
830  return VAK_Invalid;
831 
832  if (getLangOpts().MSVCCompat)
833  return VAK_MSVCUndefined;
834 
835  // FIXME: In C++11, these cases are conditionally-supported, meaning we're
836  // permitted to reject them. We should consider doing so.
837  return VAK_Undefined;
838 }
839 
841  // Don't allow one to pass an Objective-C interface to a vararg.
842  const QualType &Ty = E->getType();
843  VarArgKind VAK = isValidVarArgType(Ty);
844 
845  // Complain about passing non-POD types through varargs.
846  switch (VAK) {
847  case VAK_ValidInCXX11:
848  DiagRuntimeBehavior(
849  E->getBeginLoc(), nullptr,
850  PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
851  LLVM_FALLTHROUGH;
852  case VAK_Valid:
853  if (Ty->isRecordType()) {
854  // This is unlikely to be what the user intended. If the class has a
855  // 'c_str' member function, the user probably meant to call that.
856  DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
857  PDiag(diag::warn_pass_class_arg_to_vararg)
858  << Ty << CT << hasCStrMethod(E) << ".c_str()");
859  }
860  break;
861 
862  case VAK_Undefined:
863  case VAK_MSVCUndefined:
864  DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
865  PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
866  << getLangOpts().CPlusPlus11 << Ty << CT);
867  break;
868 
869  case VAK_Invalid:
871  Diag(E->getBeginLoc(),
872  diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
873  << Ty << CT;
874  else if (Ty->isObjCObjectType())
875  DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
876  PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
877  << Ty << CT);
878  else
879  Diag(E->getBeginLoc(), diag::err_cannot_pass_to_vararg)
880  << isa<InitListExpr>(E) << Ty << CT;
881  break;
882  }
883 }
884 
885 /// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
886 /// will create a trap if the resulting type is not a POD type.
888  FunctionDecl *FDecl) {
889  if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) {
890  // Strip the unbridged-cast placeholder expression off, if applicable.
891  if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
892  (CT == VariadicMethod ||
893  (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) {
894  E = stripARCUnbridgedCast(E);
895 
896  // Otherwise, do normal placeholder checking.
897  } else {
898  ExprResult ExprRes = CheckPlaceholderExpr(E);
899  if (ExprRes.isInvalid())
900  return ExprError();
901  E = ExprRes.get();
902  }
903  }
904 
905  ExprResult ExprRes = DefaultArgumentPromotion(E);
906  if (ExprRes.isInvalid())
907  return ExprError();
908  E = ExprRes.get();
909 
910  // Diagnostics regarding non-POD argument types are
911  // emitted along with format string checking in Sema::CheckFunctionCall().
912  if (isValidVarArgType(E->getType()) == VAK_Undefined) {
913  // Turn this into a trap.
914  CXXScopeSpec SS;
915  SourceLocation TemplateKWLoc;
916  UnqualifiedId Name;
917  Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"),
918  E->getBeginLoc());
919  ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc, Name,
920  /*HasTrailingLParen=*/true,
921  /*IsAddressOfOperand=*/false);
922  if (TrapFn.isInvalid())
923  return ExprError();
924 
925  ExprResult Call = BuildCallExpr(TUScope, TrapFn.get(), E->getBeginLoc(),
926  None, E->getEndLoc());
927  if (Call.isInvalid())
928  return ExprError();
929 
930  ExprResult Comma =
931  ActOnBinOp(TUScope, E->getBeginLoc(), tok::comma, Call.get(), E);
932  if (Comma.isInvalid())
933  return ExprError();
934  return Comma.get();
935  }
936 
937  if (!getLangOpts().CPlusPlus &&
938  RequireCompleteType(E->getExprLoc(), E->getType(),
939  diag::err_call_incomplete_argument))
940  return ExprError();
941 
942  return E;
943 }
944 
945 /// Converts an integer to complex float type. Helper function of
946 /// UsualArithmeticConversions()
947 ///
948 /// \return false if the integer expression is an integer type and is
949 /// successfully converted to the complex type.
951  ExprResult &ComplexExpr,
952  QualType IntTy,
953  QualType ComplexTy,
954  bool SkipCast) {
955  if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true;
956  if (SkipCast) return false;
957  if (IntTy->isIntegerType()) {
958  QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType();
959  IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating);
960  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
961  CK_FloatingRealToComplex);
962  } else {
963  assert(IntTy->isComplexIntegerType());
964  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
965  CK_IntegralComplexToFloatingComplex);
966  }
967  return false;
968 }
969 
970 /// Handle arithmetic conversion with complex types. Helper function of
971 /// UsualArithmeticConversions()
973  ExprResult &RHS, QualType LHSType,
974  QualType RHSType,
975  bool IsCompAssign) {
976  // if we have an integer operand, the result is the complex type.
977  if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType,
978  /*skipCast*/false))
979  return LHSType;
980  if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType,
981  /*skipCast*/IsCompAssign))
982  return RHSType;
983 
984  // This handles complex/complex, complex/float, or float/complex.
985  // When both operands are complex, the shorter operand is converted to the
986  // type of the longer, and that is the type of the result. This corresponds
987  // to what is done when combining two real floating-point operands.
988  // The fun begins when size promotion occur across type domains.
989  // From H&S 6.3.4: When one operand is complex and the other is a real
990  // floating-point type, the less precise type is converted, within it's
991  // real or complex domain, to the precision of the other type. For example,
992  // when combining a "long double" with a "double _Complex", the
993  // "double _Complex" is promoted to "long double _Complex".
994 
995  // Compute the rank of the two types, regardless of whether they are complex.
996  int Order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
997 
998  auto *LHSComplexType = dyn_cast<ComplexType>(LHSType);
999  auto *RHSComplexType = dyn_cast<ComplexType>(RHSType);
1000  QualType LHSElementType =
1001  LHSComplexType ? LHSComplexType->getElementType() : LHSType;
1002  QualType RHSElementType =
1003  RHSComplexType ? RHSComplexType->getElementType() : RHSType;
1004 
1005  QualType ResultType = S.Context.getComplexType(LHSElementType);
1006  if (Order < 0) {
1007  // Promote the precision of the LHS if not an assignment.
1008  ResultType = S.Context.getComplexType(RHSElementType);
1009  if (!IsCompAssign) {
1010  if (LHSComplexType)
1011  LHS =
1012  S.ImpCastExprToType(LHS.get(), ResultType, CK_FloatingComplexCast);
1013  else
1014  LHS = S.ImpCastExprToType(LHS.get(), RHSElementType, CK_FloatingCast);
1015  }
1016  } else if (Order > 0) {
1017  // Promote the precision of the RHS.
1018  if (RHSComplexType)
1019  RHS = S.ImpCastExprToType(RHS.get(), ResultType, CK_FloatingComplexCast);
1020  else
1021  RHS = S.ImpCastExprToType(RHS.get(), LHSElementType, CK_FloatingCast);
1022  }
1023  return ResultType;
1024 }
1025 
1026 /// Handle arithmetic conversion from integer to float. Helper function
1027 /// of UsualArithmeticConversions()
1029  ExprResult &IntExpr,
1030  QualType FloatTy, QualType IntTy,
1031  bool ConvertFloat, bool ConvertInt) {
1032  if (IntTy->isIntegerType()) {
1033  if (ConvertInt)
1034  // Convert intExpr to the lhs floating point type.
1035  IntExpr = S.ImpCastExprToType(IntExpr.get(), FloatTy,
1036  CK_IntegralToFloating);
1037  return FloatTy;
1038  }
1039 
1040  // Convert both sides to the appropriate complex float.
1041  assert(IntTy->isComplexIntegerType());
1042  QualType result = S.Context.getComplexType(FloatTy);
1043 
1044  // _Complex int -> _Complex float
1045  if (ConvertInt)
1046  IntExpr = S.ImpCastExprToType(IntExpr.get(), result,
1047  CK_IntegralComplexToFloatingComplex);
1048 
1049  // float -> _Complex float
1050  if (ConvertFloat)
1051  FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result,
1052  CK_FloatingRealToComplex);
1053 
1054  return result;
1055 }
1056 
1057 /// Handle arithmethic conversion with floating point types. Helper
1058 /// function of UsualArithmeticConversions()
1060  ExprResult &RHS, QualType LHSType,
1061  QualType RHSType, bool IsCompAssign) {
1062  bool LHSFloat = LHSType->isRealFloatingType();
1063  bool RHSFloat = RHSType->isRealFloatingType();
1064 
1065  // If we have two real floating types, convert the smaller operand
1066  // to the bigger result.
1067  if (LHSFloat && RHSFloat) {
1068  int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
1069  if (order > 0) {
1070  RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingCast);
1071  return LHSType;
1072  }
1073 
1074  assert(order < 0 && "illegal float comparison");
1075  if (!IsCompAssign)
1076  LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast);
1077  return RHSType;
1078  }
1079 
1080  if (LHSFloat) {
1081  // Half FP has to be promoted to float unless it is natively supported
1082  if (LHSType->isHalfType() && !S.getLangOpts().NativeHalfType)
1083  LHSType = S.Context.FloatTy;
1084 
1085  return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
1086  /*ConvertFloat=*/!IsCompAssign,
1087  /*ConvertInt=*/ true);
1088  }
1089  assert(RHSFloat);
1090  return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
1091  /*convertInt=*/ true,
1092  /*convertFloat=*/!IsCompAssign);
1093 }
1094 
1095 /// Diagnose attempts to convert between __float128 and long double if
1096 /// there is no support for such conversion. Helper function of
1097 /// UsualArithmeticConversions().
1098 static bool unsupportedTypeConversion(const Sema &S, QualType LHSType,
1099  QualType RHSType) {
1100  /* No issue converting if at least one of the types is not a floating point
1101  type or the two types have the same rank.
1102  */
1103  if (!LHSType->isFloatingType() || !RHSType->isFloatingType() ||
1104  S.Context.getFloatingTypeOrder(LHSType, RHSType) == 0)
1105  return false;
1106 
1107  assert(LHSType->isFloatingType() && RHSType->isFloatingType() &&
1108  "The remaining types must be floating point types.");
1109 
1110  auto *LHSComplex = LHSType->getAs<ComplexType>();
1111  auto *RHSComplex = RHSType->getAs<ComplexType>();
1112 
1113  QualType LHSElemType = LHSComplex ?
1114  LHSComplex->getElementType() : LHSType;
1115  QualType RHSElemType = RHSComplex ?
1116  RHSComplex->getElementType() : RHSType;
1117 
1118  // No issue if the two types have the same representation
1119  if (&S.Context.getFloatTypeSemantics(LHSElemType) ==
1120  &S.Context.getFloatTypeSemantics(RHSElemType))
1121  return false;
1122 
1123  bool Float128AndLongDouble = (LHSElemType == S.Context.Float128Ty &&
1124  RHSElemType == S.Context.LongDoubleTy);
1125  Float128AndLongDouble |= (LHSElemType == S.Context.LongDoubleTy &&
1126  RHSElemType == S.Context.Float128Ty);
1127 
1128  // We've handled the situation where __float128 and long double have the same
1129  // representation. We allow all conversions for all possible long double types
1130  // except PPC's double double.
1131  return Float128AndLongDouble &&
1133  &llvm::APFloat::PPCDoubleDouble());
1134 }
1135 
1136 typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType);
1137 
1138 namespace {
1139 /// These helper callbacks are placed in an anonymous namespace to
1140 /// permit their use as function template parameters.
1141 ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
1142  return S.ImpCastExprToType(op, toType, CK_IntegralCast);
1143 }
1144 
1145 ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
1146  return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
1147  CK_IntegralComplexCast);
1148 }
1149 }
1150 
1151 /// Handle integer arithmetic conversions. Helper function of
1152 /// UsualArithmeticConversions()
1153 template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1155  ExprResult &RHS, QualType LHSType,
1156  QualType RHSType, bool IsCompAssign) {
1157  // The rules for this case are in C99 6.3.1.8
1158  int order = S.Context.getIntegerTypeOrder(LHSType, RHSType);
1159  bool LHSSigned = LHSType->hasSignedIntegerRepresentation();
1160  bool RHSSigned = RHSType->hasSignedIntegerRepresentation();
1161  if (LHSSigned == RHSSigned) {
1162  // Same signedness; use the higher-ranked type
1163  if (order >= 0) {
1164  RHS = (*doRHSCast)(S, RHS.get(), LHSType);
1165  return LHSType;
1166  } else if (!IsCompAssign)
1167  LHS = (*doLHSCast)(S, LHS.get(), RHSType);
1168  return RHSType;
1169  } else if (order != (LHSSigned ? 1 : -1)) {
1170  // The unsigned type has greater than or equal rank to the
1171  // signed type, so use the unsigned type
1172  if (RHSSigned) {
1173  RHS = (*doRHSCast)(S, RHS.get(), LHSType);
1174  return LHSType;
1175  } else if (!IsCompAssign)
1176  LHS = (*doLHSCast)(S, LHS.get(), RHSType);
1177  return RHSType;
1178  } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) {
1179  // The two types are different widths; if we are here, that
1180  // means the signed type is larger than the unsigned type, so
1181  // use the signed type.
1182  if (LHSSigned) {
1183  RHS = (*doRHSCast)(S, RHS.get(), LHSType);
1184  return LHSType;
1185  } else if (!IsCompAssign)
1186  LHS = (*doLHSCast)(S, LHS.get(), RHSType);
1187  return RHSType;
1188  } else {
1189  // The signed type is higher-ranked than the unsigned type,
1190  // but isn't actually any bigger (like unsigned int and long
1191  // on most 32-bit systems). Use the unsigned type corresponding
1192  // to the signed type.
1193  QualType result =
1194  S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
1195  RHS = (*doRHSCast)(S, RHS.get(), result);
1196  if (!IsCompAssign)
1197  LHS = (*doLHSCast)(S, LHS.get(), result);
1198  return result;
1199  }
1200 }
1201 
1202 /// Handle conversions with GCC complex int extension. Helper function
1203 /// of UsualArithmeticConversions()
1205  ExprResult &RHS, QualType LHSType,
1206  QualType RHSType,
1207  bool IsCompAssign) {
1208  const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType();
1209  const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType();
1210 
1211  if (LHSComplexInt && RHSComplexInt) {
1212  QualType LHSEltType = LHSComplexInt->getElementType();
1213  QualType RHSEltType = RHSComplexInt->getElementType();
1214  QualType ScalarType =
1215  handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
1216  (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
1217 
1218  return S.Context.getComplexType(ScalarType);
1219  }
1220 
1221  if (LHSComplexInt) {
1222  QualType LHSEltType = LHSComplexInt->getElementType();
1223  QualType ScalarType =
1224  handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
1225  (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1226  QualType ComplexType = S.Context.getComplexType(ScalarType);
1227  RHS = S.ImpCastExprToType(RHS.get(), ComplexType,
1228  CK_IntegralRealToComplex);
1229 
1230  return ComplexType;
1231  }
1232 
1233  assert(RHSComplexInt);
1234 
1235  QualType RHSEltType = RHSComplexInt->getElementType();
1236  QualType ScalarType =
1237  handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
1238  (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
1239  QualType ComplexType = S.Context.getComplexType(ScalarType);
1240 
1241  if (!IsCompAssign)
1242  LHS = S.ImpCastExprToType(LHS.get(), ComplexType,
1243  CK_IntegralRealToComplex);
1244  return ComplexType;
1245 }
1246 
1247 /// Return the rank of a given fixed point or integer type. The value itself
1248 /// doesn't matter, but the values must be increasing with proper increasing
1249 /// rank as described in N1169 4.1.1.
1250 static unsigned GetFixedPointRank(QualType Ty) {
1251  const auto *BTy = Ty->getAs<BuiltinType>();
1252  assert(BTy && "Expected a builtin type.");
1253 
1254  switch (BTy->getKind()) {
1255  case BuiltinType::ShortFract:
1256  case BuiltinType::UShortFract:
1257  case BuiltinType::SatShortFract:
1258  case BuiltinType::SatUShortFract:
1259  return 1;
1260  case BuiltinType::Fract:
1261  case BuiltinType::UFract:
1262  case BuiltinType::SatFract:
1263  case BuiltinType::SatUFract:
1264  return 2;
1265  case BuiltinType::LongFract:
1266  case BuiltinType::ULongFract:
1267  case BuiltinType::SatLongFract:
1268  case BuiltinType::SatULongFract:
1269  return 3;
1270  case BuiltinType::ShortAccum:
1271  case BuiltinType::UShortAccum:
1272  case BuiltinType::SatShortAccum:
1273  case BuiltinType::SatUShortAccum:
1274  return 4;
1275  case BuiltinType::Accum:
1276  case BuiltinType::UAccum:
1277  case BuiltinType::SatAccum:
1278  case BuiltinType::SatUAccum:
1279  return 5;
1280  case BuiltinType::LongAccum:
1281  case BuiltinType::ULongAccum:
1282  case BuiltinType::SatLongAccum:
1283  case BuiltinType::SatULongAccum:
1284  return 6;
1285  default:
1286  if (BTy->isInteger())
1287  return 0;
1288  llvm_unreachable("Unexpected fixed point or integer type");
1289  }
1290 }
1291 
1292 /// handleFixedPointConversion - Fixed point operations between fixed
1293 /// point types and integers or other fixed point types do not fall under
1294 /// usual arithmetic conversion since these conversions could result in loss
1295 /// of precsision (N1169 4.1.4). These operations should be calculated with
1296 /// the full precision of their result type (N1169 4.1.6.2.1).
1298  QualType RHSTy) {
1299  assert((LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) &&
1300  "Expected at least one of the operands to be a fixed point type");
1301  assert((LHSTy->isFixedPointOrIntegerType() ||
1302  RHSTy->isFixedPointOrIntegerType()) &&
1303  "Special fixed point arithmetic operation conversions are only "
1304  "applied to ints or other fixed point types");
1305 
1306  // If one operand has signed fixed-point type and the other operand has
1307  // unsigned fixed-point type, then the unsigned fixed-point operand is
1308  // converted to its corresponding signed fixed-point type and the resulting
1309  // type is the type of the converted operand.
1310  if (RHSTy->isSignedFixedPointType() && LHSTy->isUnsignedFixedPointType())
1312  else if (RHSTy->isUnsignedFixedPointType() && LHSTy->isSignedFixedPointType())
1314 
1315  // The result type is the type with the highest rank, whereby a fixed-point
1316  // conversion rank is always greater than an integer conversion rank; if the
1317  // type of either of the operands is a saturating fixedpoint type, the result
1318  // type shall be the saturating fixed-point type corresponding to the type
1319  // with the highest rank; the resulting value is converted (taking into
1320  // account rounding and overflow) to the precision of the resulting type.
1321  // Same ranks between signed and unsigned types are resolved earlier, so both
1322  // types are either signed or both unsigned at this point.
1323  unsigned LHSTyRank = GetFixedPointRank(LHSTy);
1324  unsigned RHSTyRank = GetFixedPointRank(RHSTy);
1325 
1326  QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;
1327 
1328  if (LHSTy->isSaturatedFixedPointType() || RHSTy->isSaturatedFixedPointType())
1329  ResultTy = S.Context.getCorrespondingSaturatedType(ResultTy);
1330 
1331  return ResultTy;
1332 }
1333 
1334 /// UsualArithmeticConversions - Performs various conversions that are common to
1335 /// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
1336 /// routine returns the first non-arithmetic type found. The client is
1337 /// responsible for emitting appropriate error diagnostics.
1339  bool IsCompAssign) {
1340  if (!IsCompAssign) {
1341  LHS = UsualUnaryConversions(LHS.get());
1342  if (LHS.isInvalid())
1343  return QualType();
1344  }
1345 
1346  RHS = UsualUnaryConversions(RHS.get());
1347  if (RHS.isInvalid())
1348  return QualType();
1349 
1350  // For conversion purposes, we ignore any qualifiers.
1351  // For example, "const float" and "float" are equivalent.
1352  QualType LHSType =
1353  Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
1354  QualType RHSType =
1355  Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
1356 
1357  // For conversion purposes, we ignore any atomic qualifier on the LHS.
1358  if (const AtomicType *AtomicLHS = LHSType->getAs<AtomicType>())
1359  LHSType = AtomicLHS->getValueType();
1360 
1361  // If both types are identical, no conversion is needed.
1362  if (LHSType == RHSType)
1363  return LHSType;
1364 
1365  // If either side is a non-arithmetic type (e.g. a pointer), we are done.
1366  // The caller can deal with this (e.g. pointer + int).
1367  if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType())
1368  return QualType();
1369 
1370  // Apply unary and bitfield promotions to the LHS's type.
1371  QualType LHSUnpromotedType = LHSType;
1372  if (LHSType->isPromotableIntegerType())
1373  LHSType = Context.getPromotedIntegerType(LHSType);
1374  QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get());
1375  if (!LHSBitfieldPromoteTy.isNull())
1376  LHSType = LHSBitfieldPromoteTy;
1377  if (LHSType != LHSUnpromotedType && !IsCompAssign)
1378  LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast);
1379 
1380  // If both types are identical, no conversion is needed.
1381  if (LHSType == RHSType)
1382  return LHSType;
1383 
1384  // At this point, we have two different arithmetic types.
1385 
1386  // Diagnose attempts to convert between __float128 and long double where
1387  // such conversions currently can't be handled.
1388  if (unsupportedTypeConversion(*this, LHSType, RHSType))
1389  return QualType();
1390 
1391  // Handle complex types first (C99 6.3.1.8p1).
1392  if (LHSType->isComplexType() || RHSType->isComplexType())
1393  return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType,
1394  IsCompAssign);
1395 
1396  // Now handle "real" floating types (i.e. float, double, long double).
1397  if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
1398  return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,
1399  IsCompAssign);
1400 
1401  // Handle GCC complex int extension.
1402  if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType())
1403  return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType,
1404  IsCompAssign);
1405 
1406  if (LHSType->isFixedPointType() || RHSType->isFixedPointType())
1407  return handleFixedPointConversion(*this, LHSType, RHSType);
1408 
1409  // Finally, we have two differing integer types.
1410  return handleIntegerConversion<doIntegralCast, doIntegralCast>
1411  (*this, LHS, RHS, LHSType, RHSType, IsCompAssign);
1412 }
1413 
1414 //===----------------------------------------------------------------------===//
1415 // Semantic Analysis for various Expression Types
1416 //===----------------------------------------------------------------------===//
1417 
1418 
1419 ExprResult
1421  SourceLocation DefaultLoc,
1422  SourceLocation RParenLoc,
1423  Expr *ControllingExpr,
1424  ArrayRef<ParsedType> ArgTypes,
1425  ArrayRef<Expr *> ArgExprs) {
1426  unsigned NumAssocs = ArgTypes.size();
1427  assert(NumAssocs == ArgExprs.size());
1428 
1429  TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs];
1430  for (unsigned i = 0; i < NumAssocs; ++i) {
1431  if (ArgTypes[i])
1432  (void) GetTypeFromParser(ArgTypes[i], &Types[i]);
1433  else
1434  Types[i] = nullptr;
1435  }
1436 
1437  ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
1438  ControllingExpr,
1439  llvm::makeArrayRef(Types, NumAssocs),
1440  ArgExprs);
1441  delete [] Types;
1442  return ER;
1443 }
1444 
1445 ExprResult
1447  SourceLocation DefaultLoc,
1448  SourceLocation RParenLoc,
1449  Expr *ControllingExpr,
1451  ArrayRef<Expr *> Exprs) {
1452  unsigned NumAssocs = Types.size();
1453  assert(NumAssocs == Exprs.size());
1454 
1455  // Decay and strip qualifiers for the controlling expression type, and handle
1456  // placeholder type replacement. See committee discussion from WG14 DR423.
1457  {
1460  ExprResult R = DefaultFunctionArrayLvalueConversion(ControllingExpr);
1461  if (R.isInvalid())
1462  return ExprError();
1463  ControllingExpr = R.get();
1464  }
1465 
1466  // The controlling expression is an unevaluated operand, so side effects are
1467  // likely unintended.
1468  if (!inTemplateInstantiation() &&
1469  ControllingExpr->HasSideEffects(Context, false))
1470  Diag(ControllingExpr->getExprLoc(),
1471  diag::warn_side_effects_unevaluated_context);
1472 
1473  bool TypeErrorFound = false,
1474  IsResultDependent = ControllingExpr->isTypeDependent(),
1475  ContainsUnexpandedParameterPack
1476  = ControllingExpr->containsUnexpandedParameterPack();
1477 
1478  for (unsigned i = 0; i < NumAssocs; ++i) {
1479  if (Exprs[i]->containsUnexpandedParameterPack())
1480  ContainsUnexpandedParameterPack = true;
1481 
1482  if (Types[i]) {
1483  if (Types[i]->getType()->containsUnexpandedParameterPack())
1484  ContainsUnexpandedParameterPack = true;
1485 
1486  if (Types[i]->getType()->isDependentType()) {
1487  IsResultDependent = true;
1488  } else {
1489  // C11 6.5.1.1p2 "The type name in a generic association shall specify a
1490  // complete object type other than a variably modified type."
1491  unsigned D = 0;
1492  if (Types[i]->getType()->isIncompleteType())
1493  D = diag::err_assoc_type_incomplete;
1494  else if (!Types[i]->getType()->isObjectType())
1495  D = diag::err_assoc_type_nonobject;
1496  else if (Types[i]->getType()->isVariablyModifiedType())
1497  D = diag::err_assoc_type_variably_modified;
1498 
1499  if (D != 0) {
1500  Diag(Types[i]->getTypeLoc().getBeginLoc(), D)
1501  << Types[i]->getTypeLoc().getSourceRange()
1502  << Types[i]->getType();
1503  TypeErrorFound = true;
1504  }
1505 
1506  // C11 6.5.1.1p2 "No two generic associations in the same generic
1507  // selection shall specify compatible types."
1508  for (unsigned j = i+1; j < NumAssocs; ++j)
1509  if (Types[j] && !Types[j]->getType()->isDependentType() &&
1510  Context.typesAreCompatible(Types[i]->getType(),
1511  Types[j]->getType())) {
1512  Diag(Types[j]->getTypeLoc().getBeginLoc(),
1513  diag::err_assoc_compatible_types)
1514  << Types[j]->getTypeLoc().getSourceRange()
1515  << Types[j]->getType()
1516  << Types[i]->getType();
1517  Diag(Types[i]->getTypeLoc().getBeginLoc(),
1518  diag::note_compat_assoc)
1519  << Types[i]->getTypeLoc().getSourceRange()
1520  << Types[i]->getType();
1521  TypeErrorFound = true;
1522  }
1523  }
1524  }
1525  }
1526  if (TypeErrorFound)
1527  return ExprError();
1528 
1529  // If we determined that the generic selection is result-dependent, don't
1530  // try to compute the result expression.
1531  if (IsResultDependent)
1532  return GenericSelectionExpr::Create(Context, KeyLoc, ControllingExpr, Types,
1533  Exprs, DefaultLoc, RParenLoc,
1534  ContainsUnexpandedParameterPack);
1535 
1536  SmallVector<unsigned, 1> CompatIndices;
1537  unsigned DefaultIndex = -1U;
1538  for (unsigned i = 0; i < NumAssocs; ++i) {
1539  if (!Types[i])
1540  DefaultIndex = i;
1541  else if (Context.typesAreCompatible(ControllingExpr->getType(),
1542  Types[i]->getType()))
1543  CompatIndices.push_back(i);
1544  }
1545 
1546  // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have
1547  // type compatible with at most one of the types named in its generic
1548  // association list."
1549  if (CompatIndices.size() > 1) {
1550  // We strip parens here because the controlling expression is typically
1551  // parenthesized in macro definitions.
1552  ControllingExpr = ControllingExpr->IgnoreParens();
1553  Diag(ControllingExpr->getBeginLoc(), diag::err_generic_sel_multi_match)
1554  << ControllingExpr->getSourceRange() << ControllingExpr->getType()
1555  << (unsigned)CompatIndices.size();
1556  for (unsigned I : CompatIndices) {
1557  Diag(Types[I]->getTypeLoc().getBeginLoc(),
1558  diag::note_compat_assoc)
1559  << Types[I]->getTypeLoc().getSourceRange()
1560  << Types[I]->getType();
1561  }
1562  return ExprError();
1563  }
1564 
1565  // C11 6.5.1.1p2 "If a generic selection has no default generic association,
1566  // its controlling expression shall have type compatible with exactly one of
1567  // the types named in its generic association list."
1568  if (DefaultIndex == -1U && CompatIndices.size() == 0) {
1569  // We strip parens here because the controlling expression is typically
1570  // parenthesized in macro definitions.
1571  ControllingExpr = ControllingExpr->IgnoreParens();
1572  Diag(ControllingExpr->getBeginLoc(), diag::err_generic_sel_no_match)
1573  << ControllingExpr->getSourceRange() << ControllingExpr->getType();
1574  return ExprError();
1575  }
1576 
1577  // C11 6.5.1.1p3 "If a generic selection has a generic association with a
1578  // type name that is compatible with the type of the controlling expression,
1579  // then the result expression of the generic selection is the expression
1580  // in that generic association. Otherwise, the result expression of the
1581  // generic selection is the expression in the default generic association."
1582  unsigned ResultIndex =
1583  CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
1584 
1586  Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc,
1587  ContainsUnexpandedParameterPack, ResultIndex);
1588 }
1589 
1590 /// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the
1591 /// location of the token and the offset of the ud-suffix within it.
1593  unsigned Offset) {
1594  return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(),
1595  S.getLangOpts());
1596 }
1597 
1598 /// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up
1599 /// the corresponding cooked (non-raw) literal operator, and build a call to it.
1601  IdentifierInfo *UDSuffix,
1602  SourceLocation UDSuffixLoc,
1603  ArrayRef<Expr*> Args,
1604  SourceLocation LitEndLoc) {
1605  assert(Args.size() <= 2 && "too many arguments for literal operator");
1606 
1607  QualType ArgTy[2];
1608  for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
1609  ArgTy[ArgIdx] = Args[ArgIdx]->getType();
1610  if (ArgTy[ArgIdx]->isArrayType())
1611  ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]);
1612  }
1613 
1614  DeclarationName OpName =
1616  DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
1617  OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
1618 
1619  LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName);
1620  if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()),
1621  /*AllowRaw*/ false, /*AllowTemplate*/ false,
1622  /*AllowStringTemplate*/ false,
1623  /*DiagnoseMissing*/ true) == Sema::LOLR_Error)
1624  return ExprError();
1625 
1626  return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc);
1627 }
1628 
1629 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
1630 /// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
1631 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1632 /// multiple tokens. However, the common case is that StringToks points to one
1633 /// string.
1634 ///
1635 ExprResult
1637  assert(!StringToks.empty() && "Must have at least one string!");
1638 
1639  StringLiteralParser Literal(StringToks, PP);
1640  if (Literal.hadError)
1641  return ExprError();
1642 
1643  SmallVector<SourceLocation, 4> StringTokLocs;
1644  for (const Token &Tok : StringToks)
1645  StringTokLocs.push_back(Tok.getLocation());
1646 
1647  QualType CharTy = Context.CharTy;
1649  if (Literal.isWide()) {
1650  CharTy = Context.getWideCharType();
1651  Kind = StringLiteral::Wide;
1652  } else if (Literal.isUTF8()) {
1653  if (getLangOpts().Char8)
1654  CharTy = Context.Char8Ty;
1655  Kind = StringLiteral::UTF8;
1656  } else if (Literal.isUTF16()) {
1657  CharTy = Context.Char16Ty;
1658  Kind = StringLiteral::UTF16;
1659  } else if (Literal.isUTF32()) {
1660  CharTy = Context.Char32Ty;
1661  Kind = StringLiteral::UTF32;
1662  } else if (Literal.isPascal()) {
1663  CharTy = Context.UnsignedCharTy;
1664  }
1665 
1666  // Warn on initializing an array of char from a u8 string literal; this
1667  // becomes ill-formed in C++2a.
1668  if (getLangOpts().CPlusPlus && !getLangOpts().CPlusPlus2a &&
1669  !getLangOpts().Char8 && Kind == StringLiteral::UTF8) {
1670  Diag(StringTokLocs.front(), diag::warn_cxx2a_compat_utf8_string);
1671 
1672  // Create removals for all 'u8' prefixes in the string literal(s). This
1673  // ensures C++2a compatibility (but may change the program behavior when
1674  // built by non-Clang compilers for which the execution character set is
1675  // not always UTF-8).
1676  auto RemovalDiag = PDiag(diag::note_cxx2a_compat_utf8_string_remove_u8);
1677  SourceLocation RemovalDiagLoc;
1678  for (const Token &Tok : StringToks) {
1679  if (Tok.getKind() == tok::utf8_string_literal) {
1680  if (RemovalDiagLoc.isInvalid())
1681  RemovalDiagLoc = Tok.getLocation();
1683  Tok.getLocation(),
1684  Lexer::AdvanceToTokenCharacter(Tok.getLocation(), 2,
1685  getSourceManager(), getLangOpts())));
1686  }
1687  }
1688  Diag(RemovalDiagLoc, RemovalDiag);
1689  }
1690 
1691  QualType StrTy =
1692  Context.getStringLiteralArrayType(CharTy, Literal.GetNumStringChars());
1693 
1694  // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
1695  StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(),
1696  Kind, Literal.Pascal, StrTy,
1697  &StringTokLocs[0],
1698  StringTokLocs.size());
1699  if (Literal.getUDSuffix().empty())
1700  return Lit;
1701 
1702  // We're building a user-defined literal.
1703  IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
1704  SourceLocation UDSuffixLoc =
1705  getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()],
1706  Literal.getUDSuffixOffset());
1707 
1708  // Make sure we're allowed user-defined literals here.
1709  if (!UDLScope)
1710  return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl));
1711 
1712  // C++11 [lex.ext]p5: The literal L is treated as a call of the form
1713  // operator "" X (str, len)
1714  QualType SizeType = Context.getSizeType();
1715 
1716  DeclarationName OpName =
1717  Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
1718  DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
1719  OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
1720 
1721  QualType ArgTy[] = {
1722  Context.getArrayDecayedType(StrTy), SizeType
1723  };
1724 
1725  LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
1726  switch (LookupLiteralOperator(UDLScope, R, ArgTy,
1727  /*AllowRaw*/ false, /*AllowTemplate*/ false,
1728  /*AllowStringTemplate*/ true,
1729  /*DiagnoseMissing*/ true)) {
1730 
1731  case LOLR_Cooked: {
1732  llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars());
1733  IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType,
1734  StringTokLocs[0]);
1735  Expr *Args[] = { Lit, LenArg };
1736 
1737  return BuildLiteralOperatorCall(R, OpNameInfo, Args, StringTokLocs.back());
1738  }
1739 
1740  case LOLR_StringTemplate: {
1741  TemplateArgumentListInfo ExplicitArgs;
1742 
1743  unsigned CharBits = Context.getIntWidth(CharTy);
1744  bool CharIsUnsigned = CharTy->isUnsignedIntegerType();
1745  llvm::APSInt Value(CharBits, CharIsUnsigned);
1746 
1747  TemplateArgument TypeArg(CharTy);
1748  TemplateArgumentLocInfo TypeArgInfo(Context.getTrivialTypeSourceInfo(CharTy));
1749  ExplicitArgs.addArgument(TemplateArgumentLoc(TypeArg, TypeArgInfo));
1750 
1751  for (unsigned I = 0, N = Lit->getLength(); I != N; ++I) {
1752  Value = Lit->getCodeUnit(I);
1753  TemplateArgument Arg(Context, Value, CharTy);
1754  TemplateArgumentLocInfo ArgInfo;
1755  ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
1756  }
1757  return BuildLiteralOperatorCall(R, OpNameInfo, None, StringTokLocs.back(),
1758  &ExplicitArgs);
1759  }
1760  case LOLR_Raw:
1761  case LOLR_Template:
1762  case LOLR_ErrorNoDiagnostic:
1763  llvm_unreachable("unexpected literal operator lookup result");
1764  case LOLR_Error:
1765  return ExprError();
1766  }
1767  llvm_unreachable("unexpected literal operator lookup result");
1768 }
1769 
1770 DeclRefExpr *
1772  SourceLocation Loc,
1773  const CXXScopeSpec *SS) {
1774  DeclarationNameInfo NameInfo(D->getDeclName(), Loc);
1775  return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS);
1776 }
1777 
1778 DeclRefExpr *
1780  const DeclarationNameInfo &NameInfo,
1781  const CXXScopeSpec *SS, NamedDecl *FoundD,
1782  SourceLocation TemplateKWLoc,
1783  const TemplateArgumentListInfo *TemplateArgs) {
1785  SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc();
1786  return BuildDeclRefExpr(D, Ty, VK, NameInfo, NNS, FoundD, TemplateKWLoc,
1787  TemplateArgs);
1788 }
1789 
1791  // A declaration named in an unevaluated operand never constitutes an odr-use.
1792  if (isUnevaluatedContext())
1793  return NOUR_Unevaluated;
1794 
1795  // C++2a [basic.def.odr]p4:
1796  // A variable x whose name appears as a potentially-evaluated expression e
1797  // is odr-used by e unless [...] x is a reference that is usable in
1798  // constant expressions.
1799  if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
1800  if (VD->getType()->isReferenceType() &&
1801  !(getLangOpts().OpenMP && isOpenMPCapturedDecl(D)) &&
1802  VD->isUsableInConstantExpressions(Context))
1803  return NOUR_Constant;
1804  }
1805 
1806  // All remaining non-variable cases constitute an odr-use. For variables, we
1807  // need to wait and see how the expression is used.
1808  return NOUR_None;
1809 }
1810 
1811 /// BuildDeclRefExpr - Build an expression that references a
1812 /// declaration that does not require a closure capture.
1813 DeclRefExpr *
1815  const DeclarationNameInfo &NameInfo,
1816  NestedNameSpecifierLoc NNS, NamedDecl *FoundD,
1817  SourceLocation TemplateKWLoc,
1818  const TemplateArgumentListInfo *TemplateArgs) {
1819  bool RefersToCapturedVariable =
1820  isa<VarDecl>(D) &&
1821  NeedToCaptureVariable(cast<VarDecl>(D), NameInfo.getLoc());
1822 
1824  Context, NNS, TemplateKWLoc, D, RefersToCapturedVariable, NameInfo, Ty,
1825  VK, FoundD, TemplateArgs, getNonOdrUseReasonInCurrentContext(D));
1826  MarkDeclRefReferenced(E);
1827 
1828  if (getLangOpts().ObjCWeak && isa<VarDecl>(D) &&
1829  Ty.getObjCLifetime() == Qualifiers::OCL_Weak && !isUnevaluatedContext() &&
1830  !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, E->getBeginLoc()))
1831  getCurFunction()->recordUseOfWeak(E);
1832 
1833  FieldDecl *FD = dyn_cast<FieldDecl>(D);
1834  if (IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(D))
1835  FD = IFD->getAnonField();
1836  if (FD) {
1837  UnusedPrivateFields.remove(FD);
1838  // Just in case we're building an illegal pointer-to-member.
1839  if (FD->isBitField())
1840  E->setObjectKind(OK_BitField);
1841  }
1842 
1843  // C++ [expr.prim]/8: The expression [...] is a bit-field if the identifier
1844  // designates a bit-field.
1845  if (auto *BD = dyn_cast<BindingDecl>(D))
1846  if (auto *BE = BD->getBinding())
1847  E->setObjectKind(BE->getObjectKind());
1848 
1849  return E;
1850 }
1851 
1852 /// Decomposes the given name into a DeclarationNameInfo, its location, and
1853 /// possibly a list of template arguments.
1854 ///
1855 /// If this produces template arguments, it is permitted to call
1856 /// DecomposeTemplateName.
1857 ///
1858 /// This actually loses a lot of source location information for
1859 /// non-standard name kinds; we should consider preserving that in
1860 /// some way.
1861 void
1863  TemplateArgumentListInfo &Buffer,
1864  DeclarationNameInfo &NameInfo,
1865  const TemplateArgumentListInfo *&TemplateArgs) {
1867  Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc);
1868  Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc);
1869 
1870  ASTTemplateArgsPtr TemplateArgsPtr(Id.TemplateId->getTemplateArgs(),
1871  Id.TemplateId->NumArgs);
1872  translateTemplateArguments(TemplateArgsPtr, Buffer);
1873 
1874  TemplateName TName = Id.TemplateId->Template.get();
1875  SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc;
1876  NameInfo = Context.getNameForTemplate(TName, TNameLoc);
1877  TemplateArgs = &Buffer;
1878  } else {
1879  NameInfo = GetNameFromUnqualifiedId(Id);
1880  TemplateArgs = nullptr;
1881  }
1882 }
1883 
1885  const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS,
1886  DeclarationName Typo, SourceLocation TypoLoc, ArrayRef<Expr *> Args,
1887  unsigned DiagnosticID, unsigned DiagnosticSuggestID) {
1888  DeclContext *Ctx =
1889  SS.isEmpty() ? nullptr : SemaRef.computeDeclContext(SS, false);
1890  if (!TC) {
1891  // Emit a special diagnostic for failed member lookups.
1892  // FIXME: computing the declaration context might fail here (?)
1893  if (Ctx)
1894  SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << Ctx
1895  << SS.getRange();
1896  else
1897  SemaRef.Diag(TypoLoc, DiagnosticID) << Typo;
1898  return;
1899  }
1900 
1901  std::string CorrectedStr = TC.getAsString(SemaRef.getLangOpts());
1902  bool DroppedSpecifier =
1903  TC.WillReplaceSpecifier() && Typo.getAsString() == CorrectedStr;
1904  unsigned NoteID = TC.getCorrectionDeclAs<ImplicitParamDecl>()
1905  ? diag::note_implicit_param_decl
1906  : diag::note_previous_decl;
1907  if (!Ctx)
1908  SemaRef.diagnoseTypo(TC, SemaRef.PDiag(DiagnosticSuggestID) << Typo,
1909  SemaRef.PDiag(NoteID));
1910  else
1911  SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest)
1912  << Typo << Ctx << DroppedSpecifier
1913  << SS.getRange(),
1914  SemaRef.PDiag(NoteID));
1915 }
1916 
1917 /// Diagnose an empty lookup.
1918 ///
1919 /// \return false if new lookup candidates were found
1922  TemplateArgumentListInfo *ExplicitTemplateArgs,
1923  ArrayRef<Expr *> Args, TypoExpr **Out) {
1924  DeclarationName Name = R.getLookupName();
1925 
1926  unsigned diagnostic = diag::err_undeclared_var_use;
1927  unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
1931  diagnostic = diag::err_undeclared_use;
1932  diagnostic_suggest = diag::err_undeclared_use_suggest;
1933  }
1934 
1935  // If the original lookup was an unqualified lookup, fake an
1936  // unqualified lookup. This is useful when (for example) the
1937  // original lookup would not have found something because it was a
1938  // dependent name.
1939  DeclContext *DC = SS.isEmpty() ? CurContext : nullptr;
1940  while (DC) {
1941  if (isa<CXXRecordDecl>(DC)) {
1942  LookupQualifiedName(R, DC);
1943 
1944  if (!R.empty()) {
1945  // Don't give errors about ambiguities in this lookup.
1946  R.suppressDiagnostics();
1947 
1948  // During a default argument instantiation the CurContext points
1949  // to a CXXMethodDecl; but we can't apply a this-> fixit inside a
1950  // function parameter list, hence add an explicit check.
1951  bool isDefaultArgument =
1952  !CodeSynthesisContexts.empty() &&
1953  CodeSynthesisContexts.back().Kind ==
1954  CodeSynthesisContext::DefaultFunctionArgumentInstantiation;
1955  CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
1956  bool isInstance = CurMethod &&
1957  CurMethod->isInstance() &&
1958  DC == CurMethod->getParent() && !isDefaultArgument;
1959 
1960  // Give a code modification hint to insert 'this->'.
1961  // TODO: fixit for inserting 'Base<T>::' in the other cases.
1962  // Actually quite difficult!
1963  if (getLangOpts().MSVCCompat)
1964  diagnostic = diag::ext_found_via_dependent_bases_lookup;
1965  if (isInstance) {
1966  Diag(R.getNameLoc(), diagnostic) << Name
1967  << FixItHint::CreateInsertion(R.getNameLoc(), "this->");
1968  CheckCXXThisCapture(R.getNameLoc());
1969  } else {
1970  Diag(R.getNameLoc(), diagnostic) << Name;
1971  }
1972 
1973  // Do we really want to note all of these?
1974  for (NamedDecl *D : R)
1975  Diag(D->getLocation(), diag::note_dependent_var_use);
1976 
1977  // Return true if we are inside a default argument instantiation
1978  // and the found name refers to an instance member function, otherwise
1979  // the function calling DiagnoseEmptyLookup will try to create an
1980  // implicit member call and this is wrong for default argument.
1981  if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) {
1982  Diag(R.getNameLoc(), diag::err_member_call_without_object);
1983  return true;
1984  }
1985 
1986  // Tell the callee to try to recover.
1987  return false;
1988  }
1989 
1990  R.clear();
1991  }
1992 
1993  // In Microsoft mode, if we are performing lookup from within a friend
1994  // function definition declared at class scope then we must set
1995  // DC to the lexical parent to be able to search into the parent
1996  // class.
1997  if (getLangOpts().MSVCCompat && isa<FunctionDecl>(DC) &&
1998  cast<FunctionDecl>(DC)->getFriendObjectKind() &&
1999  DC->getLexicalParent()->isRecord())
2000  DC = DC->getLexicalParent();
2001  else
2002  DC = DC->getParent();
2003  }
2004 
2005  // We didn't find anything, so try to correct for a typo.
2006  TypoCorrection Corrected;
2007  if (S && Out) {
2008  SourceLocation TypoLoc = R.getNameLoc();
2009  assert(!ExplicitTemplateArgs &&
2010  "Diagnosing an empty lookup with explicit template args!");
2011  *Out = CorrectTypoDelayed(
2012  R.getLookupNameInfo(), R.getLookupKind(), S, &SS, CCC,
2013  [=](const TypoCorrection &TC) {
2014  emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args,
2015  diagnostic, diagnostic_suggest);
2016  },
2017  nullptr, CTK_ErrorRecovery);
2018  if (*Out)
2019  return true;
2020  } else if (S &&
2021  (Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(),
2022  S, &SS, CCC, CTK_ErrorRecovery))) {
2023  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
2024  bool DroppedSpecifier =
2025  Corrected.WillReplaceSpecifier() && Name.getAsString() == CorrectedStr;
2026  R.setLookupName(Corrected.getCorrection());
2027 
2028  bool AcceptableWithRecovery = false;
2029  bool AcceptableWithoutRecovery = false;
2030  NamedDecl *ND = Corrected.getFoundDecl();
2031  if (ND) {
2032  if (Corrected.isOverloaded()) {
2036  for (NamedDecl *CD : Corrected) {
2037  if (FunctionTemplateDecl *FTD =
2038  dyn_cast<FunctionTemplateDecl>(CD))
2039  AddTemplateOverloadCandidate(
2040  FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs,
2041  Args, OCS);
2042  else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
2043  if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0)
2044  AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none),
2045  Args, OCS);
2046  }
2047  switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) {
2048  case OR_Success:
2049  ND = Best->FoundDecl;
2050  Corrected.setCorrectionDecl(ND);
2051  break;
2052  default:
2053  // FIXME: Arbitrarily pick the first declaration for the note.
2054  Corrected.setCorrectionDecl(ND);
2055  break;
2056  }
2057  }
2058  R.addDecl(ND);
2059  if (getLangOpts().CPlusPlus && ND->isCXXClassMember()) {
2060  CXXRecordDecl *Record = nullptr;
2061  if (Corrected.getCorrectionSpecifier()) {
2062  const Type *Ty = Corrected.getCorrectionSpecifier()->getAsType();
2063  Record = Ty->getAsCXXRecordDecl();
2064  }
2065  if (!Record)
2066  Record = cast<CXXRecordDecl>(
2067  ND->getDeclContext()->getRedeclContext());
2068  R.setNamingClass(Record);
2069  }
2070 
2071  auto *UnderlyingND = ND->getUnderlyingDecl();
2072  AcceptableWithRecovery = isa<ValueDecl>(UnderlyingND) ||
2073  isa<FunctionTemplateDecl>(UnderlyingND);
2074  // FIXME: If we ended up with a typo for a type name or
2075  // Objective-C class name, we're in trouble because the parser
2076  // is in the wrong place to recover. Suggest the typo
2077  // correction, but don't make it a fix-it since we're not going
2078  // to recover well anyway.
2079  AcceptableWithoutRecovery = isa<TypeDecl>(UnderlyingND) ||
2080  getAsTypeTemplateDecl(UnderlyingND) ||
2081  isa<ObjCInterfaceDecl>(UnderlyingND);
2082  } else {
2083  // FIXME: We found a keyword. Suggest it, but don't provide a fix-it
2084  // because we aren't able to recover.
2085  AcceptableWithoutRecovery = true;
2086  }
2087 
2088  if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
2089  unsigned NoteID = Corrected.getCorrectionDeclAs<ImplicitParamDecl>()
2090  ? diag::note_implicit_param_decl
2091  : diag::note_previous_decl;
2092  if (SS.isEmpty())
2093  diagnoseTypo(Corrected, PDiag(diagnostic_suggest) << Name,
2094  PDiag(NoteID), AcceptableWithRecovery);
2095  else
2096  diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
2097  << Name << computeDeclContext(SS, false)
2098  << DroppedSpecifier << SS.getRange(),
2099  PDiag(NoteID), AcceptableWithRecovery);
2100 
2101  // Tell the callee whether to try to recover.
2102  return !AcceptableWithRecovery;
2103  }
2104  }
2105  R.clear();
2106 
2107  // Emit a special diagnostic for failed member lookups.
2108  // FIXME: computing the declaration context might fail here (?)
2109  if (!SS.isEmpty()) {
2110  Diag(R.getNameLoc(), diag::err_no_member)
2111  << Name << computeDeclContext(SS, false)
2112  << SS.getRange();
2113  return true;
2114  }
2115 
2116  // Give up, we can't recover.
2117  Diag(R.getNameLoc(), diagnostic) << Name;
2118  return true;
2119 }
2120 
2121 /// In Microsoft mode, if we are inside a template class whose parent class has
2122 /// dependent base classes, and we can't resolve an unqualified identifier, then
2123 /// assume the identifier is a member of a dependent base class. We can only
2124 /// recover successfully in static methods, instance methods, and other contexts
2125 /// where 'this' is available. This doesn't precisely match MSVC's
2126 /// instantiation model, but it's close enough.
2127 static Expr *
2129  DeclarationNameInfo &NameInfo,
2130  SourceLocation TemplateKWLoc,
2131  const TemplateArgumentListInfo *TemplateArgs) {
2132  // Only try to recover from lookup into dependent bases in static methods or
2133  // contexts where 'this' is available.
2134  QualType ThisType = S.getCurrentThisType();
2135  const CXXRecordDecl *RD = nullptr;
2136  if (!ThisType.isNull())
2137  RD = ThisType->getPointeeType()->getAsCXXRecordDecl();
2138  else if (auto *MD = dyn_cast<CXXMethodDecl>(S.CurContext))
2139  RD = MD->getParent();
2140  if (!RD || !RD->hasAnyDependentBases())
2141  return nullptr;
2142 
2143  // Diagnose this as unqualified lookup into a dependent base class. If 'this'
2144  // is available, suggest inserting 'this->' as a fixit.
2145  SourceLocation Loc = NameInfo.getLoc();
2146  auto DB = S.Diag(Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
2147  DB << NameInfo.getName() << RD;
2148 
2149  if (!ThisType.isNull()) {
2150  DB << FixItHint::CreateInsertion(Loc, "this->");
2152  Context, /*This=*/nullptr, ThisType, /*IsArrow=*/true,
2153  /*Op=*/SourceLocation(), NestedNameSpecifierLoc(), TemplateKWLoc,
2154  /*FirstQualifierFoundInScope=*/nullptr, NameInfo, TemplateArgs);
2155  }
2156 
2157  // Synthesize a fake NNS that points to the derived class. This will
2158  // perform name lookup during template instantiation.
2159  CXXScopeSpec SS;
2160  auto *NNS =
2161  NestedNameSpecifier::Create(Context, nullptr, true, RD->getTypeForDecl());
2162  SS.MakeTrivial(Context, NNS, SourceRange(Loc, Loc));
2164  Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
2165  TemplateArgs);
2166 }
2167 
2168 ExprResult
2170  SourceLocation TemplateKWLoc, UnqualifiedId &Id,
2171  bool HasTrailingLParen, bool IsAddressOfOperand,
2173  bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
2174  assert(!(IsAddressOfOperand && HasTrailingLParen) &&
2175  "cannot be direct & operand and have a trailing lparen");
2176  if (SS.isInvalid())
2177  return ExprError();
2178 
2179  TemplateArgumentListInfo TemplateArgsBuffer;
2180 
2181  // Decompose the UnqualifiedId into the following data.
2182  DeclarationNameInfo NameInfo;
2183  const TemplateArgumentListInfo *TemplateArgs;
2184  DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs);
2185 
2186  DeclarationName Name = NameInfo.getName();
2187  IdentifierInfo *II = Name.getAsIdentifierInfo();
2188  SourceLocation NameLoc = NameInfo.getLoc();
2189 
2190  if (II && II->isEditorPlaceholder()) {
2191  // FIXME: When typed placeholders are supported we can create a typed
2192  // placeholder expression node.
2193  return ExprError();
2194  }
2195 
2196  // C++ [temp.dep.expr]p3:
2197  // An id-expression is type-dependent if it contains:
2198  // -- an identifier that was declared with a dependent type,
2199  // (note: handled after lookup)
2200  // -- a template-id that is dependent,
2201  // (note: handled in BuildTemplateIdExpr)
2202  // -- a conversion-function-id that specifies a dependent type,
2203  // -- a nested-name-specifier that contains a class-name that
2204  // names a dependent type.
2205  // Determine whether this is a member of an unknown specialization;
2206  // we need to handle these differently.
2207  bool DependentID = false;
2209  Name.getCXXNameType()->isDependentType()) {
2210  DependentID = true;
2211  } else if (SS.isSet()) {
2212  if (DeclContext *DC = computeDeclContext(SS, false)) {
2213  if (RequireCompleteDeclContext(SS, DC))
2214  return ExprError();
2215  } else {
2216  DependentID = true;
2217  }
2218  }
2219 
2220  if (DependentID)
2221  return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
2222  IsAddressOfOperand, TemplateArgs);
2223 
2224  // Perform the required lookup.
2225  LookupResult R(*this, NameInfo,
2227  ? LookupObjCImplicitSelfParam
2228  : LookupOrdinaryName);
2229  if (TemplateKWLoc.isValid() || TemplateArgs) {
2230  // Lookup the template name again to correctly establish the context in
2231  // which it was found. This is really unfortunate as we already did the
2232  // lookup to determine that it was a template name in the first place. If
2233  // this becomes a performance hit, we can work harder to preserve those
2234  // results until we get here but it's likely not worth it.
2235  bool MemberOfUnknownSpecialization;
2236  AssumedTemplateKind AssumedTemplate;
2237  if (LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false,
2238  MemberOfUnknownSpecialization, TemplateKWLoc,
2239  &AssumedTemplate))
2240  return ExprError();
2241 
2242  if (MemberOfUnknownSpecialization ||
2244  return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
2245  IsAddressOfOperand, TemplateArgs);
2246  } else {
2247  bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl();
2248  LookupParsedName(R, S, &SS, !IvarLookupFollowUp);
2249 
2250  // If the result might be in a dependent base class, this is a dependent
2251  // id-expression.
2253  return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
2254  IsAddressOfOperand, TemplateArgs);
2255 
2256  // If this reference is in an Objective-C method, then we need to do
2257  // some special Objective-C lookup, too.
2258  if (IvarLookupFollowUp) {
2259  ExprResult E(LookupInObjCMethod(R, S, II, true));
2260  if (E.isInvalid())
2261  return ExprError();
2262 
2263  if (Expr *Ex = E.getAs<Expr>())
2264  return Ex;
2265  }
2266  }
2267 
2268  if (R.isAmbiguous())
2269  return ExprError();
2270 
2271  // This could be an implicitly declared function reference (legal in C90,
2272  // extension in C99, forbidden in C++).
2273  if (R.empty() && HasTrailingLParen && II && !getLangOpts().CPlusPlus) {
2274  NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
2275  if (D) R.addDecl(D);
2276  }
2277 
2278  // Determine whether this name might be a candidate for
2279  // argument-dependent lookup.
2280  bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);
2281 
2282  if (R.empty() && !ADL) {
2283  if (SS.isEmpty() && getLangOpts().MSVCCompat) {
2284  if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
2285  TemplateKWLoc, TemplateArgs))
2286  return E;
2287  }
2288 
2289  // Don't diagnose an empty lookup for inline assembly.
2290  if (IsInlineAsmIdentifier)
2291  return ExprError();
2292 
2293  // If this name wasn't predeclared and if this is not a function
2294  // call, diagnose the problem.
2295  TypoExpr *TE = nullptr;
2296  DefaultFilterCCC DefaultValidator(II, SS.isValid() ? SS.getScopeRep()
2297  : nullptr);
2298  DefaultValidator.IsAddressOfOperand = IsAddressOfOperand;
2299  assert((!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) &&
2300  "Typo correction callback misconfigured");
2301  if (CCC) {
2302  // Make sure the callback knows what the typo being diagnosed is.
2303  CCC->setTypoName(II);
2304  if (SS.isValid())
2305  CCC->setTypoNNS(SS.getScopeRep());
2306  }
2307  // FIXME: DiagnoseEmptyLookup produces bad diagnostics if we're looking for
2308  // a template name, but we happen to have always already looked up the name
2309  // before we get here if it must be a template name.
2310  if (DiagnoseEmptyLookup(S, SS, R, CCC ? *CCC : DefaultValidator, nullptr,
2311  None, &TE)) {
2312  if (TE && KeywordReplacement) {
2313  auto &State = getTypoExprState(TE);
2314  auto BestTC = State.Consumer->getNextCorrection();
2315  if (BestTC.isKeyword()) {
2316  auto *II = BestTC.getCorrectionAsIdentifierInfo();
2317  if (State.DiagHandler)
2318  State.DiagHandler(BestTC);
2319  KeywordReplacement->startToken();
2320  KeywordReplacement->setKind(II->getTokenID());
2321  KeywordReplacement->setIdentifierInfo(II);
2322  KeywordReplacement->setLocation(BestTC.getCorrectionRange().getBegin());
2323  // Clean up the state associated with the TypoExpr, since it has
2324  // now been diagnosed (without a call to CorrectDelayedTyposInExpr).
2325  clearDelayedTypo(TE);
2326  // Signal that a correction to a keyword was performed by returning a
2327  // valid-but-null ExprResult.
2328  return (Expr*)nullptr;
2329  }
2330  State.Consumer->resetCorrectionStream();
2331  }
2332  return TE ? TE : ExprError();
2333  }
2334 
2335  assert(!R.empty() &&
2336  "DiagnoseEmptyLookup returned false but added no results");
2337 
2338  // If we found an Objective-C instance variable, let
2339  // LookupInObjCMethod build the appropriate expression to
2340  // reference the ivar.
2341  if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) {
2342  R.clear();
2343  ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier()));
2344  // In a hopelessly buggy code, Objective-C instance variable
2345  // lookup fails and no expression will be built to reference it.
2346  if (!E.isInvalid() && !E.get())
2347  return ExprError();
2348  return E;
2349  }
2350  }
2351 
2352  // This is guaranteed from this point on.
2353  assert(!R.empty() || ADL);
2354 
2355  // Check whether this might be a C++ implicit instance member access.
2356  // C++ [class.mfct.non-static]p3:
2357  // When an id-expression that is not part of a class member access
2358  // syntax and not used to form a pointer to member is used in the
2359  // body of a non-static member function of class X, if name lookup
2360  // resolves the name in the id-expression to a non-static non-type
2361  // member of some class C, the id-expression is transformed into a
2362  // class member access expression using (*this) as the
2363  // postfix-expression to the left of the . operator.
2364  //
2365  // But we don't actually need to do this for '&' operands if R
2366  // resolved to a function or overloaded function set, because the
2367  // expression is ill-formed if it actually works out to be a
2368  // non-static member function:
2369  //
2370  // C++ [expr.ref]p4:
2371  // Otherwise, if E1.E2 refers to a non-static member function. . .
2372  // [t]he expression can be used only as the left-hand operand of a
2373  // member function call.
2374  //
2375  // There are other safeguards against such uses, but it's important
2376  // to get this right here so that we don't end up making a
2377  // spuriously dependent expression if we're inside a dependent
2378  // instance method.
2379  if (!R.empty() && (*R.begin())->isCXXClassMember()) {
2380  bool MightBeImplicitMember;
2381  if (!IsAddressOfOperand)
2382  MightBeImplicitMember = true;
2383  else if (!SS.isEmpty())
2384  MightBeImplicitMember = false;
2385  else if (R.isOverloadedResult())
2386  MightBeImplicitMember = false;
2387  else if (R.isUnresolvableResult())
2388  MightBeImplicitMember = true;
2389  else
2390  MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) ||
2391  isa<IndirectFieldDecl>(R.getFoundDecl()) ||
2392  isa<MSPropertyDecl>(R.getFoundDecl());
2393 
2394  if (MightBeImplicitMember)
2395  return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc,
2396  R, TemplateArgs, S);
2397  }
2398 
2399  if (TemplateArgs || TemplateKWLoc.isValid()) {
2400 
2401  // In C++1y, if this is a variable template id, then check it
2402  // in BuildTemplateIdExpr().
2403  // The single lookup result must be a variable template declaration.
2405  Id.TemplateId->Kind == TNK_Var_template) {
2406  assert(R.getAsSingle<VarTemplateDecl>() &&
2407  "There should only be one declaration found.");
2408  }
2409 
2410  return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs);
2411  }
2412 
2413  return BuildDeclarationNameExpr(SS, R, ADL);
2414 }
2415 
2416 /// BuildQualifiedDeclarationNameExpr - Build a C++ qualified
2417 /// declaration name, generally during template instantiation.
2418 /// There's a large number of things which don't need to be done along
2419 /// this path.
2421  CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo,
2422  bool IsAddressOfOperand, const Scope *S, TypeSourceInfo **RecoveryTSI) {
2423  DeclContext *DC = computeDeclContext(SS, false);
2424  if (!DC)
2425  return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
2426  NameInfo, /*TemplateArgs=*/nullptr);
2427 
2428  if (RequireCompleteDeclContext(SS, DC))
2429  return ExprError();
2430 
2431  LookupResult R(*this, NameInfo, LookupOrdinaryName);
2432  LookupQualifiedName(R, DC);
2433 
2434  if (R.isAmbiguous())
2435  return ExprError();
2436 
2438  return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
2439  NameInfo, /*TemplateArgs=*/nullptr);
2440 
2441  if (R.empty()) {
2442  Diag(NameInfo.getLoc(), diag::err_no_member)
2443  << NameInfo.getName() << DC << SS.getRange();
2444  return ExprError();
2445  }
2446 
2447  if (const TypeDecl *TD = R.getAsSingle<TypeDecl>()) {
2448  // Diagnose a missing typename if this resolved unambiguously to a type in
2449  // a dependent context. If we can recover with a type, downgrade this to
2450  // a warning in Microsoft compatibility mode.
2451  unsigned DiagID = diag::err_typename_missing;
2452  if (RecoveryTSI && getLangOpts().MSVCCompat)
2453  DiagID = diag::ext_typename_missing;
2454  SourceLocation Loc = SS.getBeginLoc();
2455  auto D = Diag(Loc, DiagID);
2456  D << SS.getScopeRep() << NameInfo.getName().getAsString()
2457  << SourceRange(Loc, NameInfo.getEndLoc());
2458 
2459  // Don't recover if the caller isn't expecting us to or if we're in a SFINAE
2460  // context.
2461  if (!RecoveryTSI)
2462  return ExprError();
2463 
2464  // Only issue the fixit if we're prepared to recover.
2465  D << FixItHint::CreateInsertion(Loc, "typename ");
2466 
2467  // Recover by pretending this was an elaborated type.
2468  QualType Ty = Context.getTypeDeclType(TD);
2469  TypeLocBuilder TLB;
2470  TLB.pushTypeSpec(Ty).setNameLoc(NameInfo.getLoc());
2471 
2472  QualType ET = getElaboratedType(ETK_None, SS, Ty);
2473  ElaboratedTypeLoc QTL = TLB.push<ElaboratedTypeLoc>(ET);
2475  QTL.setQualifierLoc(SS.getWithLocInContext(Context));
2476 
2477  *RecoveryTSI = TLB.getTypeSourceInfo(Context, ET);
2478 
2479  return ExprEmpty();
2480  }
2481 
2482  // Defend against this resolving to an implicit member access. We usually
2483  // won't get here if this might be a legitimate a class member (we end up in
2484  // BuildMemberReferenceExpr instead), but this can be valid if we're forming
2485  // a pointer-to-member or in an unevaluated context in C++11.
2486  if (!R.empty() && (*R.begin())->isCXXClassMember() && !IsAddressOfOperand)
2487  return BuildPossibleImplicitMemberExpr(SS,
2488  /*TemplateKWLoc=*/SourceLocation(),
2489  R, /*TemplateArgs=*/nullptr, S);
2490 
2491  return BuildDeclarationNameExpr(SS, R, /* ADL */ false);
2492 }
2493 
2494 /// LookupInObjCMethod - The parser has read a name in, and Sema has
2495 /// detected that we're currently inside an ObjC method. Perform some
2496 /// additional lookup.
2497 ///
2498 /// Ideally, most of this would be done by lookup, but there's
2499 /// actually quite a lot of extra work involved.
2500 ///
2501 /// Returns a null sentinel to indicate trivial success.
2502 ExprResult
2504  IdentifierInfo *II, bool AllowBuiltinCreation) {
2505  SourceLocation Loc = Lookup.getNameLoc();
2506  ObjCMethodDecl *CurMethod = getCurMethodDecl();
2507 
2508  // Check for error condition which is already reported.
2509  if (!CurMethod)
2510  return ExprError();
2511 
2512  // There are two cases to handle here. 1) scoped lookup could have failed,
2513  // in which case we should look for an ivar. 2) scoped lookup could have
2514  // found a decl, but that decl is outside the current instance method (i.e.
2515  // a global variable). In these two cases, we do a lookup for an ivar with
2516  // this name, if the lookup sucedes, we replace it our current decl.
2517 
2518  // If we're in a class method, we don't normally want to look for
2519  // ivars. But if we don't find anything else, and there's an
2520  // ivar, that's an error.
2521  bool IsClassMethod = CurMethod->isClassMethod();
2522 
2523  bool LookForIvars;
2524  if (Lookup.empty())
2525  LookForIvars = true;
2526  else if (IsClassMethod)
2527  LookForIvars = false;
2528  else
2529  LookForIvars = (Lookup.isSingleResult() &&
2531  ObjCInterfaceDecl *IFace = nullptr;
2532  if (LookForIvars) {
2533  IFace = CurMethod->getClassInterface();
2534  ObjCInterfaceDecl *ClassDeclared;
2535  ObjCIvarDecl *IV = nullptr;
2536  if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) {
2537  // Diagnose using an ivar in a class method.
2538  if (IsClassMethod)
2539  return ExprError(Diag(Loc, diag::err_ivar_use_in_class_method)
2540  << IV->getDeclName());
2541 
2542  // If we're referencing an invalid decl, just return this as a silent
2543  // error node. The error diagnostic was already emitted on the decl.
2544  if (IV->isInvalidDecl())
2545  return ExprError();
2546 
2547  // Check if referencing a field with __attribute__((deprecated)).
2548  if (DiagnoseUseOfDecl(IV, Loc))
2549  return ExprError();
2550 
2551  // Diagnose the use of an ivar outside of the declaring class.
2552  if (IV->getAccessControl() == ObjCIvarDecl::Private &&
2553  !declaresSameEntity(ClassDeclared, IFace) &&
2554  !getLangOpts().DebuggerSupport)
2555  Diag(Loc, diag::err_private_ivar_access) << IV->getDeclName();
2556 
2557  // FIXME: This should use a new expr for a direct reference, don't
2558  // turn this into Self->ivar, just return a BareIVarExpr or something.
2559  IdentifierInfo &II = Context.Idents.get("self");
2560  UnqualifiedId SelfName;
2561  SelfName.setIdentifier(&II, SourceLocation());
2563  CXXScopeSpec SelfScopeSpec;
2564  SourceLocation TemplateKWLoc;
2565  ExprResult SelfExpr =
2566  ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, SelfName,
2567  /*HasTrailingLParen=*/false,
2568  /*IsAddressOfOperand=*/false);
2569  if (SelfExpr.isInvalid())
2570  return ExprError();
2571 
2572  SelfExpr = DefaultLvalueConversion(SelfExpr.get());
2573  if (SelfExpr.isInvalid())
2574  return ExprError();
2575 
2576  MarkAnyDeclReferenced(Loc, IV, true);
2577 
2578  ObjCMethodFamily MF = CurMethod->getMethodFamily();
2579  if (MF != OMF_init && MF != OMF_dealloc && MF != OMF_finalize &&
2580  !IvarBacksCurrentMethodAccessor(IFace, CurMethod, IV))
2581  Diag(Loc, diag::warn_direct_ivar_access) << IV->getDeclName();
2582 
2583  ObjCIvarRefExpr *Result = new (Context)
2584  ObjCIvarRefExpr(IV, IV->getUsageType(SelfExpr.get()->getType()), Loc,
2585  IV->getLocation(), SelfExpr.get(), true, true);
2586 
2587  if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
2588  if (!isUnevaluatedContext() &&
2589  !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc))
2590  getCurFunction()->recordUseOfWeak(Result);
2591  }
2592  if (getLangOpts().ObjCAutoRefCount)
2593  if (const BlockDecl *BD = CurContext->getInnermostBlockDecl())
2594  ImplicitlyRetainedSelfLocs.push_back({Loc, BD});
2595 
2596  return Result;
2597  }
2598  } else if (CurMethod->isInstanceMethod()) {
2599  // We should warn if a local variable hides an ivar.
2600  if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) {
2601  ObjCInterfaceDecl *ClassDeclared;
2602  if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
2603  if (IV->getAccessControl() != ObjCIvarDecl::Private ||
2604  declaresSameEntity(IFace, ClassDeclared))
2605  Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
2606  }
2607  }
2608  } else if (Lookup.isSingleResult() &&
2610  // If accessing a stand-alone ivar in a class method, this is an error.
2611  if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl()))
2612  return ExprError(Diag(Loc, diag::err_ivar_use_in_class_method)
2613  << IV->getDeclName());
2614  }
2615 
2616  if (Lookup.empty() && II && AllowBuiltinCreation) {
2617  // FIXME. Consolidate this with similar code in LookupName.
2618  if (unsigned BuiltinID = II->getBuiltinID()) {
2619  if (!(getLangOpts().CPlusPlus &&
2620  Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) {
2621  NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID,
2622  S, Lookup.isForRedeclaration(),
2623  Lookup.getNameLoc());
2624  if (D) Lookup.addDecl(D);
2625  }
2626  }
2627  }
2628  // Sentinel value saying that we didn't do anything special.
2629  return ExprResult((Expr *)nullptr);
2630 }
2631 
2632 /// Cast a base object to a member's actual type.
2633 ///
2634 /// Logically this happens in three phases:
2635 ///
2636 /// * First we cast from the base type to the naming class.
2637 /// The naming class is the class into which we were looking
2638 /// when we found the member; it's the qualifier type if a
2639 /// qualifier was provided, and otherwise it's the base type.
2640 ///
2641 /// * Next we cast from the naming class to the declaring class.
2642 /// If the member we found was brought into a class's scope by
2643 /// a using declaration, this is that class; otherwise it's
2644 /// the class declaring the member.
2645 ///
2646 /// * Finally we cast from the declaring class to the "true"
2647 /// declaring class of the member. This conversion does not
2648 /// obey access control.
2649 ExprResult
2651  NestedNameSpecifier *Qualifier,
2652  NamedDecl *FoundDecl,
2653  NamedDecl *Member) {
2654  CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext());
2655  if (!RD)
2656  return From;
2657 
2658  QualType DestRecordType;
2659  QualType DestType;
2660  QualType FromRecordType;
2661  QualType FromType = From->getType();
2662  bool PointerConversions = false;
2663  if (isa<FieldDecl>(Member)) {
2664  DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD));
2665  auto FromPtrType = FromType->getAs<PointerType>();
2666  DestRecordType = Context.getAddrSpaceQualType(
2667  DestRecordType, FromPtrType
2668  ? FromType->getPointeeType().getAddressSpace()
2669  : FromType.getAddressSpace());
2670 
2671  if (FromPtrType) {
2672  DestType = Context.getPointerType(DestRecordType);
2673  FromRecordType = FromPtrType->getPointeeType();
2674  PointerConversions = true;
2675  } else {
2676  DestType = DestRecordType;
2677  FromRecordType = FromType;
2678  }
2679  } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) {
2680  if (Method->isStatic())
2681  return From;
2682 
2683  DestType = Method->getThisType();
2684  DestRecordType = DestType->getPointeeType();
2685 
2686  if (FromType->getAs<PointerType>()) {
2687  FromRecordType = FromType->getPointeeType();
2688  PointerConversions = true;
2689  } else {
2690  FromRecordType = FromType;
2691  DestType = DestRecordType;
2692  }
2693  } else {
2694  // No conversion necessary.
2695  return From;
2696  }
2697 
2698  if (DestType->isDependentType() || FromType->isDependentType())
2699  return From;
2700 
2701  // If the unqualified types are the same, no conversion is necessary.
2702  if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
2703  return From;
2704 
2705  SourceRange FromRange = From->getSourceRange();
2706  SourceLocation FromLoc = FromRange.getBegin();
2707 
2708  ExprValueKind VK = From->getValueKind();
2709 
2710  // C++ [class.member.lookup]p8:
2711  // [...] Ambiguities can often be resolved by qualifying a name with its
2712  // class name.
2713  //
2714  // If the member was a qualified name and the qualified referred to a
2715  // specific base subobject type, we'll cast to that intermediate type
2716  // first and then to the object in which the member is declared. That allows
2717  // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as:
2718  //
2719  // class Base { public: int x; };
2720  // class Derived1 : public Base { };
2721  // class Derived2 : public Base { };
2722  // class VeryDerived : public Derived1, public Derived2 { void f(); };
2723  //
2724  // void VeryDerived::f() {
2725  // x = 17; // error: ambiguous base subobjects
2726  // Derived1::x = 17; // okay, pick the Base subobject of Derived1
2727  // }
2728  if (Qualifier && Qualifier->getAsType()) {
2729  QualType QType = QualType(Qualifier->getAsType(), 0);
2730  assert(QType->isRecordType() && "lookup done with non-record type");
2731 
2732  QualType QRecordType = QualType(QType->getAs<RecordType>(), 0);
2733 
2734  // In C++98, the qualifier type doesn't actually have to be a base
2735  // type of the object type, in which case we just ignore it.
2736  // Otherwise build the appropriate casts.
2737  if (IsDerivedFrom(FromLoc, FromRecordType, QRecordType)) {
2738  CXXCastPath BasePath;
2739  if (CheckDerivedToBaseConversion(FromRecordType, QRecordType,
2740  FromLoc, FromRange, &BasePath))
2741  return ExprError();
2742 
2743  if (PointerConversions)
2744  QType = Context.getPointerType(QType);
2745  From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase,
2746  VK, &BasePath).get();
2747 
2748  FromType = QType;
2749  FromRecordType = QRecordType;
2750 
2751  // If the qualifier type was the same as the destination type,
2752  // we're done.
2753  if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
2754  return From;
2755  }
2756  }
2757 
2758  bool IgnoreAccess = false;
2759 
2760  // If we actually found the member through a using declaration, cast
2761  // down to the using declaration's type.
2762  //
2763  // Pointer equality is fine here because only one declaration of a
2764  // class ever has member declarations.
2765  if (FoundDecl->getDeclContext() != Member->getDeclContext()) {
2766  assert(isa<UsingShadowDecl>(FoundDecl));
2767  QualType URecordType = Context.getTypeDeclType(
2768  cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
2769 
2770  // We only need to do this if the naming-class to declaring-class
2771  // conversion is non-trivial.
2772  if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) {
2773  assert(IsDerivedFrom(FromLoc, FromRecordType, URecordType));
2774  CXXCastPath BasePath;
2775  if (CheckDerivedToBaseConversion(FromRecordType, URecordType,
2776  FromLoc, FromRange, &BasePath))
2777  return ExprError();
2778 
2779  QualType UType = URecordType;
2780  if (PointerConversions)
2781  UType = Context.getPointerType(UType);
2782  From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase,
2783  VK, &BasePath).get();
2784  FromType = UType;
2785  FromRecordType = URecordType;
2786  }
2787 
2788  // We don't do access control for the conversion from the
2789  // declaring class to the true declaring class.
2790  IgnoreAccess = true;
2791  }
2792 
2793  CXXCastPath BasePath;
2794  if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType,
2795  FromLoc, FromRange, &BasePath,
2796  IgnoreAccess))
2797  return ExprError();
2798 
2799  return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase,
2800  VK, &BasePath);
2801 }
2802 
2804  const LookupResult &R,
2805  bool HasTrailingLParen) {
2806  // Only when used directly as the postfix-expression of a call.
2807  if (!HasTrailingLParen)
2808  return false;
2809 
2810  // Never if a scope specifier was provided.
2811  if (SS.isSet())
2812  return false;
2813 
2814  // Only in C++ or ObjC++.
2815  if (!getLangOpts().CPlusPlus)
2816  return false;
2817 
2818  // Turn off ADL when we find certain kinds of declarations during
2819  // normal lookup:
2820  for (NamedDecl *D : R) {
2821  // C++0x [basic.lookup.argdep]p3:
2822  // -- a declaration of a class member
2823  // Since using decls preserve this property, we check this on the
2824  // original decl.
2825  if (D->isCXXClassMember())
2826  return false;
2827 
2828  // C++0x [basic.lookup.argdep]p3:
2829  // -- a block-scope function declaration that is not a
2830  // using-declaration
2831  // NOTE: we also trigger this for function templates (in fact, we
2832  // don't check the decl type at all, since all other decl types
2833  // turn off ADL anyway).
2834  if (isa<UsingShadowDecl>(D))
2835  D = cast<UsingShadowDecl>(D)->getTargetDecl();
2836  else if (D->getLexicalDeclContext()->isFunctionOrMethod())
2837  return false;
2838 
2839  // C++0x [basic.lookup.argdep]p3:
2840  // -- a declaration that is neither a function or a function
2841  // template
2842  // And also for builtin functions.
2843  if (isa<FunctionDecl>(D)) {
2844  FunctionDecl *FDecl = cast<FunctionDecl>(D);
2845 
2846  // But also builtin functions.
2847  if (FDecl->getBuiltinID() && FDecl->isImplicit())
2848  return false;
2849  } else if (!isa<FunctionTemplateDecl>(D))
2850  return false;
2851  }
2852 
2853  return true;
2854 }
2855 
2856 
2857 /// Diagnoses obvious problems with the use of the given declaration
2858 /// as an expression. This is only actually called for lookups that
2859 /// were not overloaded, and it doesn't promise that the declaration
2860 /// will in fact be used.
2861 static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) {
2862  if (D->isInvalidDecl())
2863  return true;
2864 
2865  if (isa<TypedefNameDecl>(D)) {
2866  S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName();
2867  return true;
2868  }
2869 
2870  if (isa<ObjCInterfaceDecl>(D)) {
2871  S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName();
2872  return true;
2873  }
2874 
2875  if (isa<NamespaceDecl>(D)) {
2876  S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName();
2877  return true;
2878  }
2879 
2880  return false;
2881 }
2882 
2883 // Certain multiversion types should be treated as overloaded even when there is
2884 // only one result.
2886  assert(R.isSingleResult() && "Expected only a single result");
2887  const auto *FD = dyn_cast<FunctionDecl>(R.getFoundDecl());
2888  return FD &&
2889  (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
2890 }
2891 
2893  LookupResult &R, bool NeedsADL,
2894  bool AcceptInvalidDecl) {
2895  // If this is a single, fully-resolved result and we don't need ADL,
2896  // just build an ordinary singleton decl ref.
2897  if (!NeedsADL && R.isSingleResult() &&
2900  return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), R.getFoundDecl(),
2901  R.getRepresentativeDecl(), nullptr,
2902  AcceptInvalidDecl);
2903 
2904  // We only need to check the declaration if there's exactly one
2905  // result, because in the overloaded case the results can only be
2906  // functions and function templates.
2908  CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl()))
2909  return ExprError();
2910 
2911  // Otherwise, just build an unresolved lookup expression. Suppress
2912  // any lookup-related diagnostics; we'll hash these out later, when
2913  // we've picked a target.
2914  R.suppressDiagnostics();
2915 
2918  SS.getWithLocInContext(Context),
2919  R.getLookupNameInfo(),
2920  NeedsADL, R.isOverloadedResult(),
2921  R.begin(), R.end());
2922 
2923  return ULE;
2924 }
2925 
2926 static void
2928  ValueDecl *var, DeclContext *DC);
2929 
2930 /// Complete semantic analysis for a reference to the given declaration.
2932  const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
2933  NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs,
2934  bool AcceptInvalidDecl) {
2935  assert(D && "Cannot refer to a NULL declaration");
2936  assert(!isa<FunctionTemplateDecl>(D) &&
2937  "Cannot refer unambiguously to a function template");
2938 
2939  SourceLocation Loc = NameInfo.getLoc();
2940  if (CheckDeclInExpr(*this, Loc, D))
2941  return ExprError();
2942 
2943  if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
2944  // Specifically diagnose references to class templates that are missing
2945  // a template argument list.
2946  diagnoseMissingTemplateArguments(TemplateName(Template), Loc);
2947  return ExprError();
2948  }
2949 
2950  // Make sure that we're referring to a value.
2951  ValueDecl *VD = dyn_cast<ValueDecl>(D);
2952  if (!VD) {
2953  Diag(Loc, diag::err_ref_non_value)
2954  << D << SS.getRange();
2955  Diag(D->getLocation(), diag::note_declared_at);
2956  return ExprError();
2957  }
2958 
2959  // Check whether this declaration can be used. Note that we suppress
2960  // this check when we're going to perform argument-dependent lookup
2961  // on this function name, because this might not be the function
2962  // that overload resolution actually selects.
2963  if (DiagnoseUseOfDecl(VD, Loc))
2964  return ExprError();
2965 
2966  // Only create DeclRefExpr's for valid Decl's.
2967  if (VD->isInvalidDecl() && !AcceptInvalidDecl)
2968  return ExprError();
2969 
2970  // Handle members of anonymous structs and unions. If we got here,
2971  // and the reference is to a class member indirect field, then this
2972  // must be the subject of a pointer-to-member expression.
2973  if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD))
2974  if (!indirectField->isCXXClassMember())
2975  return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(),
2976  indirectField);
2977 
2978  {
2979  QualType type = VD->getType();
2980  if (type.isNull())
2981  return ExprError();
2982  if (auto *FPT = type->getAs<FunctionProtoType>()) {
2983  // C++ [except.spec]p17:
2984  // An exception-specification is considered to be needed when:
2985  // - in an expression, the function is the unique lookup result or
2986  // the selected member of a set of overloaded functions.
2987  ResolveExceptionSpec(Loc, FPT);
2988  type = VD->getType();
2989  }
2990  ExprValueKind valueKind = VK_RValue;
2991 
2992  switch (D->getKind()) {
2993  // Ignore all the non-ValueDecl kinds.
2994 #define ABSTRACT_DECL(kind)
2995 #define VALUE(type, base)
2996 #define DECL(type, base) \
2997  case Decl::type:
2998 #include "clang/AST/DeclNodes.inc"
2999  llvm_unreachable("invalid value decl kind");
3000 
3001  // These shouldn't make it here.
3002  case Decl::ObjCAtDefsField:
3003  llvm_unreachable("forming non-member reference to ivar?");
3004 
3005  // Enum constants are always r-values and never references.
3006  // Unresolved using declarations are dependent.
3007  case Decl::EnumConstant:
3008  case Decl::UnresolvedUsingValue:
3009  case Decl::OMPDeclareReduction:
3010  case Decl::OMPDeclareMapper:
3011  valueKind = VK_RValue;
3012  break;
3013 
3014  // Fields and indirect fields that got here must be for
3015  // pointer-to-member expressions; we just call them l-values for
3016  // internal consistency, because this subexpression doesn't really
3017  // exist in the high-level semantics.
3018  case Decl::Field:
3019  case Decl::IndirectField:
3020  case Decl::ObjCIvar:
3021  assert(getLangOpts().CPlusPlus &&
3022  "building reference to field in C?");
3023 
3024  // These can't have reference type in well-formed programs, but
3025  // for internal consistency we do this anyway.
3026  type = type.getNonReferenceType();
3027  valueKind = VK_LValue;
3028  break;
3029 
3030  // Non-type template parameters are either l-values or r-values
3031  // depending on the type.
3032  case Decl::NonTypeTemplateParm: {
3033  if (const ReferenceType *reftype = type->getAs<ReferenceType>()) {
3034  type = reftype->getPointeeType();
3035  valueKind = VK_LValue; // even if the parameter is an r-value reference
3036  break;
3037  }
3038 
3039  // For non-references, we need to strip qualifiers just in case
3040  // the template parameter was declared as 'const int' or whatever.
3041  valueKind = VK_RValue;
3042  type = type.getUnqualifiedType();
3043  break;
3044  }
3045 
3046  case Decl::Var:
3047  case Decl::VarTemplateSpecialization:
3048  case Decl::VarTemplatePartialSpecialization:
3049  case Decl::Decomposition:
3050  case Decl::OMPCapturedExpr:
3051  // In C, "extern void blah;" is valid and is an r-value.
3052  if (!getLangOpts().CPlusPlus &&
3053  !type.hasQualifiers() &&
3054  type->isVoidType()) {
3055  valueKind = VK_RValue;
3056  break;
3057  }
3058  LLVM_FALLTHROUGH;
3059 
3060  case Decl::ImplicitParam:
3061  case Decl::ParmVar: {
3062  // These are always l-values.
3063  valueKind = VK_LValue;
3064  type = type.getNonReferenceType();
3065 
3066  // FIXME: Does the addition of const really only apply in
3067  // potentially-evaluated contexts? Since the variable isn't actually
3068  // captured in an unevaluated context, it seems that the answer is no.
3069  if (!isUnevaluatedContext()) {
3070  QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc);
3071  if (!CapturedType.isNull())
3072  type = CapturedType;
3073  }
3074 
3075  break;
3076  }
3077 
3078  case Decl::Binding: {
3079  // These are always lvalues.
3080  valueKind = VK_LValue;
3081  type = type.getNonReferenceType();
3082  // FIXME: Support lambda-capture of BindingDecls, once CWG actually
3083  // decides how that's supposed to work.
3084  auto *BD = cast<BindingDecl>(VD);
3085  if (BD->getDeclContext() != CurContext) {
3086  auto *DD = dyn_cast_or_null<VarDecl>(BD->getDecomposedDecl());
3087  if (DD && DD->hasLocalStorage())
3088  diagnoseUncapturableValueReference(*this, Loc, BD, CurContext);
3089  }
3090  break;
3091  }
3092 
3093  case Decl::Function: {
3094  if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
3095  if (!Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
3096  type = Context.BuiltinFnTy;
3097  valueKind = VK_RValue;
3098  break;
3099  }
3100  }
3101 
3102  const FunctionType *fty = type->castAs<FunctionType>();
3103 
3104  // If we're referring to a function with an __unknown_anytype
3105  // result type, make the entire expression __unknown_anytype.
3106  if (fty->getReturnType() == Context.UnknownAnyTy) {
3107  type = Context.UnknownAnyTy;
3108  valueKind = VK_RValue;
3109  break;
3110  }
3111 
3112  // Functions are l-values in C++.
3113  if (getLangOpts().CPlusPlus) {
3114  valueKind = VK_LValue;
3115  break;
3116  }
3117 
3118  // C99 DR 316 says that, if a function type comes from a
3119  // function definition (without a prototype), that type is only
3120  // used for checking compatibility. Therefore, when referencing
3121  // the function, we pretend that we don't have the full function
3122  // type.
3123  if (!cast<FunctionDecl>(VD)->hasPrototype() &&
3124  isa<FunctionProtoType>(fty))
3125  type = Context.getFunctionNoProtoType(fty->getReturnType(),
3126  fty->getExtInfo());
3127 
3128  // Functions are r-values in C.
3129  valueKind = VK_RValue;
3130  break;
3131  }
3132 
3133  case Decl::CXXDeductionGuide:
3134  llvm_unreachable("building reference to deduction guide");
3135 
3136  case Decl::MSProperty:
3137  valueKind = VK_LValue;
3138  break;
3139 
3140  case Decl::CXXMethod:
3141  // If we're referring to a method with an __unknown_anytype
3142  // result type, make the entire expression __unknown_anytype.
3143  // This should only be possible with a type written directly.
3144  if (const FunctionProtoType *proto
3145  = dyn_cast<FunctionProtoType>(VD->getType()))
3146  if (proto->getReturnType() == Context.UnknownAnyTy) {
3147  type = Context.UnknownAnyTy;
3148  valueKind = VK_RValue;
3149  break;
3150  }
3151 
3152  // C++ methods are l-values if static, r-values if non-static.
3153  if (cast<CXXMethodDecl>(VD)->isStatic()) {
3154  valueKind = VK_LValue;
3155  break;
3156  }
3157  LLVM_FALLTHROUGH;
3158 
3159  case Decl::CXXConversion:
3160  case Decl::CXXDestructor:
3161  case Decl::CXXConstructor:
3162  valueKind = VK_RValue;
3163  break;
3164  }
3165 
3166  return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD,
3167  /*FIXME: TemplateKWLoc*/ SourceLocation(),
3168  TemplateArgs);
3169  }
3170 }
3171 
3172 static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
3173  SmallString<32> &Target) {
3174  Target.resize(CharByteWidth * (Source.size() + 1));
3175  char *ResultPtr = &Target[0];
3176  const llvm::UTF8 *ErrorPtr;
3177  bool success =
3178  llvm::ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
3179  (void)success;
3180  assert(success);
3181  Target.resize(ResultPtr - &Target[0]);
3182 }
3183 
3186  // Pick the current block, lambda, captured statement or function.
3187  Decl *currentDecl = nullptr;
3188  if (const BlockScopeInfo *BSI = getCurBlock())
3189  currentDecl = BSI->TheDecl;
3190  else if (const LambdaScopeInfo *LSI = getCurLambda())
3191  currentDecl = LSI->CallOperator;
3192  else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion())
3193  currentDecl = CSI->TheCapturedDecl;
3194  else
3195  currentDecl = getCurFunctionOrMethodDecl();
3196 
3197  if (!currentDecl) {
3198  Diag(Loc, diag::ext_predef_outside_function);
3199  currentDecl = Context.getTranslationUnitDecl();
3200  }
3201 
3202  QualType ResTy;
3203  StringLiteral *SL = nullptr;
3204  if (cast<DeclContext>(currentDecl)->isDependentContext())
3205  ResTy = Context.DependentTy;
3206  else {
3207  // Pre-defined identifiers are of type char[x], where x is the length of
3208  // the string.
3209  auto Str = PredefinedExpr::ComputeName(IK, currentDecl);
3210  unsigned Length = Str.length();
3211 
3212  llvm::APInt LengthI(32, Length + 1);
3214  ResTy =
3216  SmallString<32> RawChars;
3218  Str, RawChars);
3219  ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal,
3220  /*IndexTypeQuals*/ 0);
3221  SL = StringLiteral::Create(Context, RawChars, StringLiteral::Wide,
3222  /*Pascal*/ false, ResTy, Loc);
3223  } else {
3224  ResTy = Context.adjustStringLiteralBaseType(Context.CharTy.withConst());
3225  ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal,
3226  /*IndexTypeQuals*/ 0);
3227  SL = StringLiteral::Create(Context, Str, StringLiteral::Ascii,
3228  /*Pascal*/ false, ResTy, Loc);
3229  }
3230  }
3231 
3232  return PredefinedExpr::Create(Context, Loc, ResTy, IK, SL);
3233 }
3234 
3237 
3238  switch (Kind) {
3239  default: llvm_unreachable("Unknown simple primary expr!");
3240  case tok::kw___func__: IK = PredefinedExpr::Func; break; // [C99 6.4.2.2]
3241  case tok::kw___FUNCTION__: IK = PredefinedExpr::Function; break;
3242  case tok::kw___FUNCDNAME__: IK = PredefinedExpr::FuncDName; break; // [MS]
3243  case tok::kw___FUNCSIG__: IK = PredefinedExpr::FuncSig; break; // [MS]
3244  case tok::kw_L__FUNCTION__: IK = PredefinedExpr::LFunction; break; // [MS]
3245  case tok::kw_L__FUNCSIG__: IK = PredefinedExpr::LFuncSig; break; // [MS]
3246  case tok::kw___PRETTY_FUNCTION__: IK = PredefinedExpr::PrettyFunction; break;
3247  }
3248 
3249  return BuildPredefinedExpr(Loc, IK);
3250 }
3251 
3253  SmallString<16> CharBuffer;
3254  bool Invalid = false;
3255  StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid);
3256  if (Invalid)
3257  return ExprError();
3258 
3259  CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(),
3260  PP, Tok.getKind());
3261  if (Literal.hadError())
3262  return ExprError();
3263 
3264  QualType Ty;
3265  if (Literal.isWide())
3266  Ty = Context.WideCharTy; // L'x' -> wchar_t in C and C++.
3267  else if (Literal.isUTF8() && getLangOpts().Char8)
3268  Ty = Context.Char8Ty; // u8'x' -> char8_t when it exists.
3269  else if (Literal.isUTF16())
3270  Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11.
3271  else if (Literal.isUTF32())
3272  Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11.
3273  else if (!getLangOpts().CPlusPlus || Literal.isMultiChar())
3274  Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++.
3275  else
3276  Ty = Context.CharTy; // 'x' -> char in C++
3277 
3279  if (Literal.isWide())
3281  else if (Literal.isUTF16())
3283  else if (Literal.isUTF32())
3285  else if (Literal.isUTF8())
3287 
3288  Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty,
3289  Tok.getLocation());
3290 
3291  if (Literal.getUDSuffix().empty())
3292  return Lit;
3293 
3294  // We're building a user-defined literal.
3295  IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
3296  SourceLocation UDSuffixLoc =
3297  getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
3298 
3299  // Make sure we're allowed user-defined literals here.
3300  if (!UDLScope)
3301  return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl));
3302 
3303  // C++11 [lex.ext]p6: The literal L is treated as a call of the form
3304  // operator "" X (ch)
3305  return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc,
3306  Lit, Tok.getLocation());
3307 }
3308 
3310  unsigned IntSize = Context.getTargetInfo().getIntWidth();
3311  return IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val),
3312  Context.IntTy, Loc);
3313 }
3314 
3316  QualType Ty, SourceLocation Loc) {
3317  const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty);
3318 
3319  using llvm::APFloat;
3320  APFloat Val(Format);
3321 
3322  APFloat::opStatus result = Literal.GetFloatValue(Val);
3323 
3324  // Overflow is always an error, but underflow is only an error if
3325  // we underflowed to zero (APFloat reports denormals as underflow).
3326  if ((result & APFloat::opOverflow) ||
3327  ((result & APFloat::opUnderflow) && Val.isZero())) {
3328  unsigned diagnostic;
3329  SmallString<20> buffer;
3330  if (result & APFloat::opOverflow) {
3331  diagnostic = diag::warn_float_overflow;
3332  APFloat::getLargest(Format).toString(buffer);
3333  } else {
3334  diagnostic = diag::warn_float_underflow;
3335  APFloat::getSmallest(Format).toString(buffer);
3336  }
3337 
3338  S.Diag(Loc, diagnostic)
3339  << Ty
3340  << StringRef(buffer.data(), buffer.size());
3341  }
3342 
3343  bool isExact = (result == APFloat::opOK);
3344  return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc);
3345 }
3346 
3348  assert(E && "Invalid expression");
3349 
3350  if (E->isValueDependent())
3351  return false;
3352 
3353  QualType QT = E->getType();
3354  if (!QT->isIntegerType() || QT->isBooleanType() || QT->isCharType()) {
3355  Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;
3356  return true;
3357  }
3358 
3359  llvm::APSInt ValueAPS;
3360  ExprResult R = VerifyIntegerConstantExpression(E, &ValueAPS);
3361 
3362  if (R.isInvalid())
3363  return true;
3364 
3365  bool ValueIsPositive = ValueAPS.isStrictlyPositive();
3366  if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {
3367  Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_value)
3368  << ValueAPS.toString(10) << ValueIsPositive;
3369  return true;
3370  }
3371 
3372  return false;
3373 }
3374 
3376  // Fast path for a single digit (which is quite common). A single digit
3377  // cannot have a trigraph, escaped newline, radix prefix, or suffix.
3378  if (Tok.getLength() == 1) {
3379  const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
3380  return ActOnIntegerConstant(Tok.getLocation(), Val-'0');
3381  }
3382 
3383  SmallString<128> SpellingBuffer;
3384  // NumericLiteralParser wants to overread by one character. Add padding to
3385  // the buffer in case the token is copied to the buffer. If getSpelling()
3386  // returns a StringRef to the memory buffer, it should have a null char at
3387  // the EOF, so it is also safe.
3388  SpellingBuffer.resize(Tok.getLength() + 1);
3389 
3390  // Get the spelling of the token, which eliminates trigraphs, etc.
3391  bool Invalid = false;
3392  StringRef TokSpelling = PP.getSpelling(Tok, SpellingBuffer, &Invalid);
3393  if (Invalid)
3394  return ExprError();
3395 
3396  NumericLiteralParser Literal(TokSpelling, Tok.getLocation(), PP);
3397  if (Literal.hadError)
3398  return ExprError();
3399 
3400  if (Literal.hasUDSuffix()) {
3401  // We're building a user-defined literal.
3402  IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
3403  SourceLocation UDSuffixLoc =
3404  getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
3405 
3406  // Make sure we're allowed user-defined literals here.
3407  if (!UDLScope)
3408  return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));
3409 
3410  QualType CookedTy;
3411  if (Literal.isFloatingLiteral()) {
3412  // C++11 [lex.ext]p4: If S contains a literal operator with parameter type
3413  // long double, the literal is treated as a call of the form
3414  // operator "" X (f L)
3415  CookedTy = Context.LongDoubleTy;
3416  } else {
3417  // C++11 [lex.ext]p3: If S contains a literal operator with parameter type
3418  // unsigned long long, the literal is treated as a call of the form
3419  // operator "" X (n ULL)
3420  CookedTy = Context.UnsignedLongLongTy;
3421  }
3422 
3423  DeclarationName OpName =
3424  Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
3425  DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
3426  OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
3427 
3428  SourceLocation TokLoc = Tok.getLocation();
3429 
3430  // Perform literal operator lookup to determine if we're building a raw
3431  // literal or a cooked one.
3432  LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
3433  switch (LookupLiteralOperator(UDLScope, R, CookedTy,
3434  /*AllowRaw*/ true, /*AllowTemplate*/ true,
3435  /*AllowStringTemplate*/ false,
3436  /*DiagnoseMissing*/ !Literal.isImaginary)) {
3437  case LOLR_ErrorNoDiagnostic:
3438  // Lookup failure for imaginary constants isn't fatal, there's still the
3439  // GNU extension producing _Complex types.
3440  break;
3441  case LOLR_Error:
3442  return ExprError();
3443  case LOLR_Cooked: {
3444  Expr *Lit;
3445  if (Literal.isFloatingLiteral()) {
3446  Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation());
3447  } else {
3448  llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0);
3449  if (Literal.GetIntegerValue(ResultVal))
3450  Diag(Tok.getLocation(), diag::err_integer_literal_too_large)
3451  << /* Unsigned */ 1;
3452  Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy,
3453  Tok.getLocation());
3454  }
3455  return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc);
3456  }
3457 
3458  case LOLR_Raw: {
3459  // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the
3460  // literal is treated as a call of the form
3461  // operator "" X ("n")
3462  unsigned Length = Literal.getUDSuffixOffset();
3463  QualType StrTy = Context.getConstantArrayType(
3464  Context.adjustStringLiteralBaseType(Context.CharTy.withConst()),
3465  llvm::APInt(32, Length + 1), ArrayType::Normal, 0);
3466  Expr *Lit = StringLiteral::Create(
3467  Context, StringRef(TokSpelling.data(), Length), StringLiteral::Ascii,
3468  /*Pascal*/false, StrTy, &TokLoc, 1);
3469  return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc);
3470  }
3471 
3472  case LOLR_Template: {
3473  // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator
3474  // template), L is treated as a call fo the form
3475  // operator "" X <'c1', 'c2', ... 'ck'>()
3476  // where n is the source character sequence c1 c2 ... ck.
3477  TemplateArgumentListInfo ExplicitArgs;
3478  unsigned CharBits = Context.getIntWidth(Context.CharTy);
3479  bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType();
3480  llvm::APSInt Value(CharBits, CharIsUnsigned);
3481  for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
3482  Value = TokSpelling[I];
3483  TemplateArgument Arg(Context, Value, Context.CharTy);
3484  TemplateArgumentLocInfo ArgInfo;
3485  ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
3486  }
3487  return BuildLiteralOperatorCall(R, OpNameInfo, None, TokLoc,
3488  &ExplicitArgs);
3489  }
3490  case LOLR_StringTemplate:
3491  llvm_unreachable("unexpected literal operator lookup result");
3492  }
3493  }
3494 
3495  Expr *Res;
3496 
3497  if (Literal.isFixedPointLiteral()) {
3498  QualType Ty;
3499 
3500  if (Literal.isAccum) {
3501  if (Literal.isHalf) {
3502  Ty = Context.ShortAccumTy;
3503  } else if (Literal.isLong) {
3504  Ty = Context.LongAccumTy;
3505  } else {
3506  Ty = Context.AccumTy;
3507  }
3508  } else if (Literal.isFract) {
3509  if (Literal.isHalf) {
3510  Ty = Context.ShortFractTy;
3511  } else if (Literal.isLong) {
3512  Ty = Context.LongFractTy;
3513  } else {
3514  Ty = Context.FractTy;
3515  }
3516  }
3517 
3518  if (Literal.isUnsigned) Ty = Context.getCorrespondingUnsignedType(Ty);
3519 
3520  bool isSigned = !Literal.isUnsigned;
3521  unsigned scale = Context.getFixedPointScale(Ty);
3522  unsigned bit_width = Context.getTypeInfo(Ty).Width;
3523 
3524  llvm::APInt Val(bit_width, 0, isSigned);
3525  bool Overflowed = Literal.GetFixedPointValue(Val, scale);
3526  bool ValIsZero = Val.isNullValue() && !Overflowed;
3527 
3528  auto MaxVal = Context.getFixedPointMax(Ty).getValue();
3529  if (Literal.isFract && Val == MaxVal + 1 && !ValIsZero)
3530  // Clause 6.4.4 - The value of a constant shall be in the range of
3531  // representable values for its type, with exception for constants of a
3532  // fract type with a value of exactly 1; such a constant shall denote
3533  // the maximal value for the type.
3534  --Val;
3535  else if (Val.ugt(MaxVal) || Overflowed)
3536  Diag(Tok.getLocation(), diag::err_too_large_for_fixed_point);
3537 
3538  Res = FixedPointLiteral::CreateFromRawInt(Context, Val, Ty,
3539  Tok.getLocation(), scale);
3540  } else if (Literal.isFloatingLiteral()) {
3541  QualType Ty;
3542  if (Literal.isHalf){
3543  if (getOpenCLOptions().isEnabled("cl_khr_fp16"))
3544  Ty = Context.HalfTy;
3545  else {
3546  Diag(Tok.getLocation(), diag::err_half_const_requires_fp16);
3547  return ExprError();
3548  }
3549  } else if (Literal.isFloat)
3550  Ty = Context.FloatTy;
3551  else if (Literal.isLong)
3552  Ty = Context.LongDoubleTy;
3553  else if (Literal.isFloat16)
3554  Ty = Context.Float16Ty;
3555  else if (Literal.isFloat128)
3556  Ty = Context.Float128Ty;
3557  else
3558  Ty = Context.DoubleTy;
3559 
3560  Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());
3561 
3562  if (Ty == Context.DoubleTy) {
3563  if (getLangOpts().SinglePrecisionConstants) {
3564  const BuiltinType *BTy = Ty->getAs<BuiltinType>();
3565  if (BTy->getKind() != BuiltinType::Float) {
3566  Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
3567  }
3568  } else if (getLangOpts().OpenCL &&
3569  !getOpenCLOptions().isEnabled("cl_khr_fp64")) {
3570  // Impose single-precision float type when cl_khr_fp64 is not enabled.
3571  Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64);
3572  Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
3573  }
3574  }
3575  } else if (!Literal.isIntegerLiteral()) {
3576  return ExprError();
3577  } else {
3578  QualType Ty;
3579 
3580  // 'long long' is a C99 or C++11 feature.
3581  if (!getLangOpts().C99 && Literal.isLongLong) {
3582  if (getLangOpts().CPlusPlus)
3583  Diag(Tok.getLocation(),
3584  getLangOpts().CPlusPlus11 ?
3585  diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
3586  else
3587  Diag(Tok.getLocation(), diag::ext_c99_longlong);
3588  }
3589 
3590  // Get the value in the widest-possible width.
3591  unsigned MaxWidth = Context.getTargetInfo().getIntMaxTWidth();
3592  llvm::APInt ResultVal(MaxWidth, 0);
3593 
3594  if (Literal.GetIntegerValue(ResultVal)) {
3595  // If this value didn't fit into uintmax_t, error and force to ull.
3596  Diag(Tok.getLocation(), diag::err_integer_literal_too_large)
3597  << /* Unsigned */ 1;
3598  Ty = Context.UnsignedLongLongTy;
3599  assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
3600  "long long is not intmax_t?");
3601  } else {
3602  // If this value fits into a ULL, try to figure out what else it fits into
3603  // according to the rules of C99 6.4.4.1p5.
3604 
3605  // Octal, Hexadecimal, and integers with a U suffix are allowed to
3606  // be an unsigned int.
3607  bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
3608 
3609  // Check from smallest to largest, picking the smallest type we can.
3610  unsigned Width = 0;
3611 
3612  // Microsoft specific integer suffixes are explicitly sized.
3613  if (Literal.MicrosoftInteger) {
3614  if (Literal.MicrosoftInteger == 8 && !Literal.isUnsigned) {
3615  Width = 8;
3616  Ty = Context.CharTy;
3617  } else {
3618  Width = Literal.MicrosoftInteger;
3619  Ty = Context.getIntTypeForBitwidth(Width,
3620  /*Signed=*/!Literal.isUnsigned);
3621  }
3622  }
3623 
3624  if (Ty.isNull() && !Literal.isLong && !Literal.isLongLong) {
3625  // Are int/unsigned possibilities?
3626  unsigned IntSize = Context.getTargetInfo().getIntWidth();
3627 
3628  // Does it fit in a unsigned int?
3629  if (ResultVal.isIntN(IntSize)) {
3630  // Does it fit in a signed int?
3631  if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
3632  Ty = Context.IntTy;
3633  else if (AllowUnsigned)
3634  Ty = Context.UnsignedIntTy;
3635  Width = IntSize;
3636  }
3637  }
3638 
3639  // Are long/unsigned long possibilities?
3640  if (Ty.isNull() && !Literal.isLongLong) {
3641  unsigned LongSize = Context.getTargetInfo().getLongWidth();
3642 
3643  // Does it fit in a unsigned long?
3644  if (ResultVal.isIntN(LongSize)) {
3645  // Does it fit in a signed long?
3646  if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
3647  Ty = Context.LongTy;
3648  else if (AllowUnsigned)
3649  Ty = Context.UnsignedLongTy;
3650  // Check according to the rules of C90 6.1.3.2p5. C++03 [lex.icon]p2
3651  // is compatible.
3652  else if (!getLangOpts().C99 && !getLangOpts().CPlusPlus11) {
3653  const unsigned LongLongSize =
3654  Context.getTargetInfo().getLongLongWidth();
3655  Diag(Tok.getLocation(),
3656  getLangOpts().CPlusPlus
3657  ? Literal.isLong
3658  ? diag::warn_old_implicitly_unsigned_long_cxx
3659  : /*C++98 UB*/ diag::
3660  ext_old_implicitly_unsigned_long_cxx
3661  : diag::warn_old_implicitly_unsigned_long)
3662  << (LongLongSize > LongSize ? /*will have type 'long long'*/ 0
3663  : /*will be ill-formed*/ 1);
3664  Ty = Context.UnsignedLongTy;
3665  }
3666  Width = LongSize;
3667  }
3668  }
3669 
3670  // Check long long if needed.
3671  if (Ty.isNull()) {
3672  unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth();
3673 
3674  // Does it fit in a unsigned long long?
3675  if (ResultVal.isIntN(LongLongSize)) {
3676  // Does it fit in a signed long long?
3677  // To be compatible with MSVC, hex integer literals ending with the
3678  // LL or i64 suffix are always signed in Microsoft mode.
3679  if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
3680  (getLangOpts().MSVCCompat && Literal.isLongLong)))
3681  Ty = Context.LongLongTy;
3682  else if (AllowUnsigned)
3683  Ty = Context.UnsignedLongLongTy;
3684  Width = LongLongSize;
3685  }
3686  }
3687 
3688  // If we still couldn't decide a type, we probably have something that
3689  // does not fit in a signed long long, but has no U suffix.
3690  if (Ty.isNull()) {
3691  Diag(Tok.getLocation(), diag::ext_integer_literal_too_large_for_signed);
3692  Ty = Context.UnsignedLongLongTy;
3693  Width = Context.getTargetInfo().getLongLongWidth();
3694  }
3695 
3696  if (ResultVal.getBitWidth() != Width)
3697  ResultVal = ResultVal.trunc(Width);
3698  }
3699  Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation());
3700  }
3701 
3702  // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
3703  if (Literal.isImaginary) {
3704  Res = new (Context) ImaginaryLiteral(Res,
3705  Context.getComplexType(Res->getType()));
3706 
3707  Diag(Tok.getLocation(), diag::ext_imaginary_constant);
3708  }
3709  return Res;
3710 }
3711 
3713  assert(E && "ActOnParenExpr() missing expr");
3714  return new (Context) ParenExpr(L, R, E);
3715 }
3716 
3718  SourceLocation Loc,
3719  SourceRange ArgRange) {
3720  // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in
3721  // scalar or vector data type argument..."
3722  // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic
3723  // type (C99 6.2.5p18) or void.
3724  if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {
3725  S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
3726  << T << ArgRange;
3727  return true;
3728  }
3729 
3730  assert((T->isVoidType() || !T->isIncompleteType()) &&
3731  "Scalar types should always be complete");
3732  return false;
3733 }
3734 
3736  SourceLocation Loc,
3737  SourceRange ArgRange,
3738  UnaryExprOrTypeTrait TraitKind) {
3739  // Invalid types must be hard errors for SFINAE in C++.
3740  if (S.LangOpts.CPlusPlus)
3741  return true;
3742 
3743  // C99 6.5.3.4p1:
3744  if (T->isFunctionType() &&
3745  (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf ||
3746  TraitKind == UETT_PreferredAlignOf)) {
3747  // sizeof(function)/alignof(function) is allowed as an extension.
3748  S.Diag(Loc, diag::ext_sizeof_alignof_function_type)
3749  << TraitKind << ArgRange;
3750  return false;
3751  }
3752 
3753  // Allow sizeof(void)/alignof(void) as an extension, unless in OpenCL where
3754  // this is an error (OpenCL v1.1 s6.3.k)
3755  if (T->isVoidType()) {
3756  unsigned DiagID = S.LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
3757  : diag::ext_sizeof_alignof_void_type;
3758  S.Diag(Loc, DiagID) << TraitKind << ArgRange;
3759  return false;
3760  }
3761 
3762  return true;
3763 }
3764 
3766  SourceLocation Loc,
3767  SourceRange ArgRange,
3768  UnaryExprOrTypeTrait TraitKind) {
3769  // Reject sizeof(interface) and sizeof(interface<proto>) if the
3770  // runtime doesn't allow it.
3772  S.Diag(Loc, diag::err_sizeof_nonfragile_interface)
3773  << T << (TraitKind == UETT_SizeOf)
3774  << ArgRange;
3775  return true;
3776  }
3777 
3778  return false;
3779 }
3780 
3781 /// Check whether E is a pointer from a decayed array type (the decayed
3782 /// pointer type is equal to T) and emit a warning if it is.
3784  Expr *E) {
3785  // Don't warn if the operation changed the type.
3786  if (T != E->getType())
3787  return;
3788 
3789  // Now look for array decays.
3790  ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E);
3791  if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
3792  return;
3793 
3794  S.Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
3795  << ICE->getType()
3796  << ICE->getSubExpr()->getType();
3797 }
3798 
3799 /// Check the constraints on expression operands to unary type expression
3800 /// and type traits.
3801 ///
3802 /// Completes any types necessary and validates the constraints on the operand
3803 /// expression. The logic mostly mirrors the type-based overload, but may modify
3804 /// the expression as it completes the type for that expression through template
3805 /// instantiation, etc.
3807  UnaryExprOrTypeTrait ExprKind) {
3808  QualType ExprTy = E->getType();
3809  assert(!ExprTy->isReferenceType());
3810 
3811  if (ExprKind == UETT_VecStep)
3812  return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(),
3813  E->getSourceRange());
3814 
3815  // Whitelist some types as extensions
3816  if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(),
3817  E->getSourceRange(), ExprKind))
3818  return false;
3819 
3820  // 'alignof' applied to an expression only requires the base element type of
3821  // the expression to be complete. 'sizeof' requires the expression's type to
3822  // be complete (and will attempt to complete it if it's an array of unknown
3823  // bound).
3824  if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
3825  if (RequireCompleteType(E->getExprLoc(),
3826  Context.getBaseElementType(E->getType()),
3827  diag::err_sizeof_alignof_incomplete_type, ExprKind,
3828  E->getSourceRange()))
3829  return true;
3830  } else {
3831  if (RequireCompleteExprType(E, diag::err_sizeof_alignof_incomplete_type,
3832  ExprKind, E->getSourceRange()))
3833  return true;
3834  }
3835 
3836  // Completing the expression's type may have changed it.
3837  ExprTy = E->getType();
3838  assert(!ExprTy->isReferenceType());
3839 
3840  if (ExprTy->isFunctionType()) {
3841  Diag(E->getExprLoc(), diag::err_sizeof_alignof_function_type)
3842  << ExprKind << E->getSourceRange();
3843  return true;
3844  }
3845 
3846  // The operand for sizeof and alignof is in an unevaluated expression context,
3847  // so side effects could result in unintended consequences.
3848  if ((ExprKind == UETT_SizeOf || ExprKind == UETT_AlignOf ||
3849  ExprKind == UETT_PreferredAlignOf) &&
3850  !inTemplateInstantiation() && E->HasSideEffects(Context, false))
3851  Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
3852 
3853  if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(),
3854  E->getSourceRange(), ExprKind))
3855  return true;
3856 
3857  if (ExprKind == UETT_SizeOf) {
3858  if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
3859  if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
3860  QualType OType = PVD->getOriginalType();
3861  QualType Type = PVD->getType();
3862  if (Type->isPointerType() && OType->isArrayType()) {
3863  Diag(E->getExprLoc(), diag::warn_sizeof_array_param)
3864  << Type << OType;
3865  Diag(PVD->getLocation(), diag::note_declared_at);
3866  }
3867  }
3868  }
3869 
3870  // Warn on "sizeof(array op x)" and "sizeof(x op array)", where the array
3871  // decays into a pointer and returns an unintended result. This is most
3872  // likely a typo for "sizeof(array) op x".
3873  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E->IgnoreParens())) {
3874  warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
3875  BO->getLHS());
3876  warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
3877  BO->getRHS());
3878  }
3879  }
3880 
3881  return false;
3882 }
3883 
3884 /// Check the constraints on operands to unary expression and type
3885 /// traits.
3886 ///
3887 /// This will complete any types necessary, and validate the various constraints
3888 /// on those operands.
3889 ///
3890 /// The UsualUnaryConversions() function is *not* called by this routine.
3891 /// C99 6.3.2.1p[2-4] all state:
3892 /// Except when it is the operand of the sizeof operator ...
3893 ///
3894 /// C++ [expr.sizeof]p4
3895 /// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
3896 /// standard conversions are not applied to the operand of sizeof.
3897 ///
3898 /// This policy is followed for all of the unary trait expressions.
3900  SourceLocation OpLoc,
3901  SourceRange ExprRange,
3902  UnaryExprOrTypeTrait ExprKind) {
3903  if (ExprType->isDependentType())
3904  return false;
3905 
3906  // C++ [expr.sizeof]p2:
3907  // When applied to a reference or a reference type, the result
3908  // is the size of the referenced type.
3909  // C++11 [expr.alignof]p3:
3910  // When alignof is applied to a reference type, the result
3911  // shall be the alignment of the referenced type.
3912  if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>())
3913  ExprType = Ref->getPointeeType();
3914 
3915  // C11 6.5.3.4/3, C++11 [expr.alignof]p3:
3916  // When alignof or _Alignof is applied to an array type, the result
3917  // is the alignment of the element type.
3918  if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
3919  ExprKind == UETT_OpenMPRequiredSimdAlign)
3920  ExprType = Context.getBaseElementType(ExprType);
3921 
3922  if (ExprKind == UETT_VecStep)
3923  return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange);
3924 
3925  // Whitelist some types as extensions
3926  if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
3927  ExprKind))
3928  return false;
3929 
3930  if (RequireCompleteType(OpLoc, ExprType,
3931  diag::err_sizeof_alignof_incomplete_type,
3932  ExprKind, ExprRange))
3933  return true;
3934 
3935  if (ExprType->isFunctionType()) {
3936  Diag(OpLoc, diag::err_sizeof_alignof_function_type)
3937  << ExprKind << ExprRange;
3938  return true;
3939  }
3940 
3941  if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange,
3942  ExprKind))
3943  return true;
3944 
3945  return false;
3946 }
3947 
3948 static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {
3949  E = E->IgnoreParens();
3950 
3951  // Cannot know anything else if the expression is dependent.
3952  if (E->isTypeDependent())
3953  return false;
3954 
3955  if (E->getObjectKind() == OK_BitField) {
3956  S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield)
3957  << 1 << E->getSourceRange();
3958  return true;
3959  }
3960 
3961  ValueDecl *D = nullptr;
3962  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
3963  D = DRE->getDecl();
3964  } else if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3965  D = ME->getMemberDecl();
3966  }
3967 
3968  // If it's a field, require the containing struct to have a
3969  // complete definition so that we can compute the layout.
3970  //
3971  // This can happen in C++11 onwards, either by naming the member
3972  // in a way that is not transformed into a member access expression
3973  // (in an unevaluated operand, for instance), or by naming the member
3974  // in a trailing-return-type.
3975  //
3976  // For the record, since __alignof__ on expressions is a GCC
3977  // extension, GCC seems to permit this but always gives the
3978  // nonsensical answer 0.
3979  //
3980  // We don't really need the layout here --- we could instead just
3981  // directly check for all the appropriate alignment-lowing
3982  // attributes --- but that would require duplicating a lot of
3983  // logic that just isn't worth duplicating for such a marginal
3984  // use-case.
3985  if (FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
3986  // Fast path this check, since we at least know the record has a
3987  // definition if we can find a member of it.
3988  if (!FD->getParent()->isCompleteDefinition()) {
3989  S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type)
3990  << E->getSourceRange();
3991  return true;
3992  }
3993 
3994  // Otherwise, if it's a field, and the field doesn't have
3995  // reference type, then it must have a complete type (or be a
3996  // flexible array member, which we explicitly want to
3997  // white-list anyway), which makes the following checks trivial.
3998  if (!FD->getType()->isReferenceType())
3999  return false;
4000  }
4001 
4002  return S.CheckUnaryExprOrTypeTraitOperand(E, ExprKind);
4003 }
4004 
4006  E = E->IgnoreParens();
4007 
4008  // Cannot know anything else if the expression is dependent.
4009  if (E->isTypeDependent())
4010  return false;
4011 
4012  return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep);
4013 }
4014 
4016  CapturingScopeInfo *CSI) {
4017  assert(T->isVariablyModifiedType());
4018  assert(CSI != nullptr);
4019 
4020  // We're going to walk down into the type and look for VLA expressions.
4021  do {
4022  const Type *Ty = T.getTypePtr();
4023  switch (Ty->getTypeClass()) {
4024 #define TYPE(Class, Base)
4025 #define ABSTRACT_TYPE(Class, Base)
4026 #define NON_CANONICAL_TYPE(Class, Base)
4027 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
4028 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4029 #include "clang/AST/TypeNodes.def"
4030  T = QualType();
4031  break;
4032  // These types are never variably-modified.
4033  case Type::Builtin:
4034  case Type::Complex:
4035  case Type::Vector:
4036  case Type::ExtVector:
4037  case Type::Record:
4038  case Type::Enum:
4039  case Type::Elaborated:
4040  case Type::TemplateSpecialization:
4041  case Type::ObjCObject:
4042  case Type::ObjCInterface:
4043  case Type::ObjCObjectPointer:
4044  case Type::ObjCTypeParam:
4045  case Type::Pipe:
4046  llvm_unreachable("type class is never variably-modified!");
4047  case Type::Adjusted:
4048  T = cast<AdjustedType>(Ty)->getOriginalType();
4049  break;
4050  case Type::Decayed:
4051  T = cast<DecayedType>(Ty)->getPointeeType();
4052  break;
4053  case Type::Pointer:
4054  T = cast<PointerType>(Ty)->getPointeeType();
4055  break;
4056  case Type::BlockPointer:
4057  T = cast<BlockPointerType>(Ty)->getPointeeType();
4058  break;
4059  case Type::LValueReference:
4060  case Type::RValueReference:
4061  T = cast<ReferenceType>(Ty)->getPointeeType();
4062  break;
4063  case Type::MemberPointer:
4064  T = cast<MemberPointerType>(Ty)->getPointeeType();
4065  break;
4066  case Type::ConstantArray:
4067  case Type::IncompleteArray:
4068  // Losing element qualification here is fine.
4069  T = cast<ArrayType>(Ty)->getElementType();
4070  break;
4071  case Type::VariableArray: {
4072  // Losing element qualification here is fine.
4073  const VariableArrayType *VAT = cast<VariableArrayType>(Ty);
4074 
4075  // Unknown size indication requires no size computation.
4076  // Otherwise, evaluate and record it.
4077  auto Size = VAT->getSizeExpr();
4078  if (Size && !CSI->isVLATypeCaptured(VAT) &&
4079  (isa<CapturedRegionScopeInfo>(CSI) || isa<LambdaScopeInfo>(CSI)))
4080  CSI->addVLATypeCapture(Size->getExprLoc(), VAT, Context.getSizeType());
4081 
4082  T = VAT->getElementType();
4083  break;
4084  }
4085  case Type::FunctionProto:
4086  case Type::FunctionNoProto:
4087  T = cast<FunctionType>(Ty)->getReturnType();
4088  break;
4089  case Type::Paren:
4090  case Type::TypeOf:
4091  case Type::UnaryTransform:
4092  case Type::Attributed:
4093  case Type::SubstTemplateTypeParm:
4094  case Type::PackExpansion:
4095  case Type::MacroQualified:
4096  // Keep walking after single level desugaring.
4097  T = T.getSingleStepDesugaredType(Context);
4098  break;
4099  case Type::Typedef:
4100  T = cast<TypedefType>(Ty)->desugar();
4101  break;
4102  case Type::Decltype:
4103  T = cast<DecltypeType>(Ty)->desugar();
4104  break;
4105  case Type::Auto:
4106  case Type::DeducedTemplateSpecialization:
4107  T = cast<DeducedType>(Ty)->getDeducedType();
4108  break;
4109  case Type::TypeOfExpr:
4110  T = cast<TypeOfExprType>(Ty)->getUnderlyingExpr()->getType();
4111  break;
4112  case Type::Atomic:
4113  T = cast<AtomicType>(Ty)->getValueType();
4114  break;
4115  }
4116  } while (!T.isNull() && T->isVariablyModifiedType());
4117 }
4118 
4119 /// Build a sizeof or alignof expression given a type operand.
4120 ExprResult
4122  SourceLocation OpLoc,
4123  UnaryExprOrTypeTrait ExprKind,
4124  SourceRange R) {
4125  if (!TInfo)
4126  return ExprError();
4127 
4128  QualType T = TInfo->getType();
4129 
4130  if (!T->isDependentType() &&
4131  CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind))
4132  return ExprError();
4133 
4134  if (T->isVariablyModifiedType() && FunctionScopes.size() > 1) {
4135  if (auto *TT = T->getAs<TypedefType>()) {
4136  for (auto I = FunctionScopes.rbegin(),
4137  E = std::prev(FunctionScopes.rend());
4138  I != E; ++I) {
4139  auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
4140  if (CSI == nullptr)
4141  break;
4142  DeclContext *DC = nullptr;
4143  if (auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
4144  DC = LSI->CallOperator;
4145  else if (auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
4146  DC = CRSI->TheCapturedDecl;
4147  else if (auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
4148  DC = BSI->TheDecl;
4149  if (DC) {
4150  if (DC->containsDecl(TT->getDecl()))
4151  break;
4152  captureVariablyModifiedType(Context, T, CSI);
4153  }
4154  }
4155  }
4156  }
4157 
4158  // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
4159  return new (Context) UnaryExprOrTypeTraitExpr(
4160  ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd());
4161 }
4162 
4163 /// Build a sizeof or alignof expression given an expression
4164 /// operand.
4165 ExprResult
4167  UnaryExprOrTypeTrait ExprKind) {
4168  ExprResult PE = CheckPlaceholderExpr(E);
4169  if (PE.isInvalid())
4170  return ExprError();
4171 
4172  E = PE.get();
4173 
4174  // Verify that the operand is valid.
4175  bool isInvalid = false;
4176  if (E->isTypeDependent()) {
4177  // Delay type-checking for type-dependent expressions.
4178  } else if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf) {
4179  isInvalid = CheckAlignOfExpr(*this, E, ExprKind);
4180  } else if (ExprKind == UETT_VecStep) {
4181  isInvalid = CheckVecStepExpr(E);
4182  } else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
4183  Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
4184  isInvalid = true;
4185  } else if (E->refersToBitField()) { // C99 6.5.3.4p1.
4186  Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
4187  isInvalid = true;
4188  } else {
4189  isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf);
4190  }
4191 
4192  if (isInvalid)
4193  return ExprError();
4194 
4195  if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) {
4196  PE = TransformToPotentiallyEvaluated(E);
4197  if (PE.isInvalid()) return ExprError();
4198  E = PE.get();
4199  }
4200 
4201  // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
4202  return new (Context) UnaryExprOrTypeTraitExpr(
4203  ExprKind, E, Context.getSizeType(), OpLoc, E->getSourceRange().getEnd());
4204 }
4205 
4206 /// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c
4207 /// expr and the same for @c alignof and @c __alignof
4208 /// Note that the ArgRange is invalid if isType is false.
4209 ExprResult
4211  UnaryExprOrTypeTrait ExprKind, bool IsType,
4212  void *TyOrEx, SourceRange ArgRange) {
4213  // If error parsing type, ignore.
4214  if (!TyOrEx) return ExprError();
4215 
4216  if (IsType) {
4217  TypeSourceInfo *TInfo;
4218  (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
4219  return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange);
4220  }
4221 
4222  Expr *ArgEx = (Expr *)TyOrEx;
4223  ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind);
4224  return Result;
4225 }
4226 
4228  bool IsReal) {
4229  if (V.get()->isTypeDependent())
4230  return S.Context.DependentTy;
4231 
4232  // _Real and _Imag are only l-values for normal l-values.
4233  if (V.get()->getObjectKind() != OK_Ordinary) {
4234  V = S.DefaultLvalueConversion(V.get());
4235  if (V.isInvalid())
4236  return QualType();
4237  }
4238 
4239  // These operators return the element type of a complex type.
4240  if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>())
4241  return CT->getElementType();
4242 
4243  // Otherwise they pass through real integer and floating point types here.
4244  if (V.get()->getType()->isArithmeticType())
4245  return V.get()->getType();
4246 
4247  // Test for placeholders.
4248  ExprResult PR = S.CheckPlaceholderExpr(V.get());
4249  if (PR.isInvalid()) return QualType();
4250  if (PR.get() != V.get()) {
4251  V = PR;
4252  return CheckRealImagOperand(S, V, Loc, IsReal);
4253  }
4254 
4255  // Reject anything else.
4256  S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType()
4257  << (IsReal ? "__real" : "__imag");
4258  return QualType();
4259 }
4260 
4261 
4262 
4263 ExprResult
4265  tok::TokenKind Kind, Expr *Input) {
4266  UnaryOperatorKind Opc;
4267  switch (Kind) {
4268  default: llvm_unreachable("Unknown unary op!");
4269  case tok::plusplus: Opc = UO_PostInc; break;
4270  case tok::minusminus: Opc = UO_PostDec; break;
4271  }
4272 
4273  // Since this might is a postfix expression, get rid of ParenListExprs.
4274  ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input);
4275  if (Result.isInvalid()) return ExprError();
4276  Input = Result.get();
4277 
4278  return BuildUnaryOp(S, OpLoc, Opc, Input);
4279 }
4280 
4281 /// Diagnose if arithmetic on the given ObjC pointer is illegal.
4282 ///
4283 /// \return true on error
4285  SourceLocation opLoc,
4286  Expr *op) {
4287  assert(op->getType()->isObjCObjectPointerType());
4289  !S.LangOpts.ObjCSubscriptingLegacyRuntime)
4290  return false;
4291 
4292  S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
4293  << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType()
4294  << op->getSourceRange();
4295  return true;
4296 }
4297 
4299  auto *BaseNoParens = Base->IgnoreParens();
4300  if (auto *MSProp = dyn_cast<MSPropertyRefExpr>(BaseNoParens))
4301  return MSProp->getPropertyDecl()->getType()->isArrayType();
4302  return isa<MSPropertySubscriptExpr>(BaseNoParens);
4303 }
4304 
4305 ExprResult
4307  Expr *idx, SourceLocation rbLoc) {
4308  if (base && !base->getType().isNull() &&
4309  base->getType()->isSpecificPlaceholderType(BuiltinType::OMPArraySection))
4310  return ActOnOMPArraySectionExpr(base, lbLoc, idx, SourceLocation(),
4311  /*Length=*/nullptr, rbLoc);
4312 
4313  // Since this might be a postfix expression, get rid of ParenListExprs.
4314  if (isa<ParenListExpr>(base)) {
4315  ExprResult result = MaybeConvertParenListExprToParenExpr(S, base);
4316  if (result.isInvalid()) return ExprError();
4317  base = result.get();
4318  }
4319 
4320  // Handle any non-overload placeholder types in the base and index
4321  // expressions. We can't handle overloads here because the other
4322  // operand might be an overloadable type, in which case the overload
4323  // resolution for the operator overload should get the first crack
4324  // at the overload.
4325  bool IsMSPropertySubscript = false;
4326  if (base->getType()->isNonOverloadPlaceholderType()) {
4327  IsMSPropertySubscript = isMSPropertySubscriptExpr(*this, base);
4328  if (!IsMSPropertySubscript) {
4329  ExprResult result = CheckPlaceholderExpr(base);
4330  if (result.isInvalid())
4331  return ExprError();
4332  base = result.get();
4333  }
4334  }
4335  if (idx->getType()->isNonOverloadPlaceholderType()) {
4336  ExprResult result = CheckPlaceholderExpr(idx);
4337  if (result.isInvalid()) return ExprError();
4338  idx = result.get();
4339  }
4340 
4341  // Build an unanalyzed expression if either operand is type-dependent.
4342  if (getLangOpts().CPlusPlus &&
4343  (base->isTypeDependent() || idx->isTypeDependent())) {
4344  return new (Context) ArraySubscriptExpr(base, idx, Context.DependentTy,
4345  VK_LValue, OK_Ordinary, rbLoc);
4346  }
4347 
4348  // MSDN, property (C++)
4349  // https://msdn.microsoft.com/en-us/library/yhfk0thd(v=vs.120).aspx
4350  // This attribute can also be used in the declaration of an empty array in a
4351  // class or structure definition. For example:
4352  // __declspec(property(get=GetX, put=PutX)) int x[];
4353  // The above statement indicates that x[] can be used with one or more array
4354  // indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b),
4355  // and p->x[a][b] = i will be turned into p->PutX(a, b, i);
4356  if (IsMSPropertySubscript) {
4357  // Build MS property subscript expression if base is MS property reference
4358  // or MS property subscript.
4359  return new (Context) MSPropertySubscriptExpr(
4360  base, idx, Context.PseudoObjectTy, VK_LValue, OK_Ordinary, rbLoc);
4361  }
4362 
4363  // Use C++ overloaded-operator rules if either operand has record
4364  // type. The spec says to do this if either type is *overloadable*,
4365  // but enum types can't declare subscript operators or conversion
4366  // operators, so there's nothing interesting for overload resolution
4367  // to do if there aren't any record types involved.
4368  //
4369  // ObjC pointers have their own subscripting logic that is not tied
4370  // to overload resolution and so should not take this path.
4371  if (getLangOpts().CPlusPlus &&
4372  (base->getType()->isRecordType() ||
4373  (!base->getType()->isObjCObjectPointerType() &&
4374  idx->getType()->isRecordType()))) {
4375  return CreateOverloadedArraySubscriptExpr(lbLoc, rbLoc, base, idx);
4376  }
4377 
4378  ExprResult Res = CreateBuiltinArraySubscriptExpr(base, lbLoc, idx, rbLoc);
4379 
4380  if (!Res.isInvalid() && isa<ArraySubscriptExpr>(Res.get()))
4381  CheckSubscriptAccessOfNoDeref(cast<ArraySubscriptExpr>(Res.get()));
4382 
4383  return Res;
4384 }
4385 
4386 void Sema::CheckAddressOfNoDeref(const Expr *E) {
4387  ExpressionEvaluationContextRecord &LastRecord = ExprEvalContexts.back();
4388  const Expr *StrippedExpr = E->IgnoreParenImpCasts();
4389 
4390  // For expressions like `&(*s).b`, the base is recorded and what should be
4391  // checked.
4392  const MemberExpr *Member = nullptr;
4393  while ((Member = dyn_cast<MemberExpr>(StrippedExpr)) && !Member->isArrow())
4394  StrippedExpr = Member->getBase()->IgnoreParenImpCasts();
4395 
4396  LastRecord.PossibleDerefs.erase(StrippedExpr);
4397 }
4398 
4399 void Sema::CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E) {
4400  QualType ResultTy = E->getType();
4401  ExpressionEvaluationContextRecord &LastRecord = ExprEvalContexts.back();
4402 
4403  // Bail if the element is an array since it is not memory access.
4404  if (isa<ArrayType>(ResultTy))
4405  return;
4406 
4407  if (ResultTy->hasAttr(attr::NoDeref)) {
4408  LastRecord.PossibleDerefs.insert(E);
4409  return;
4410  }
4411 
4412  // Check if the base type is a pointer to a member access of a struct
4413  // marked with noderef.
4414  const Expr *Base = E->getBase();
4415  QualType BaseTy = Base->getType();
4416  if (!(isa<ArrayType>(BaseTy) || isa<PointerType>(BaseTy)))
4417  // Not a pointer access
4418  return;
4419 
4420  const MemberExpr *Member = nullptr;
4421  while ((Member = dyn_cast<MemberExpr>(Base->IgnoreParenCasts())) &&
4422  Member->isArrow())
4423  Base = Member->getBase();
4424 
4425  if (const auto *Ptr = dyn_cast<PointerType>(Base->getType())) {
4426  if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
4427  LastRecord.PossibleDerefs.insert(E);
4428  }
4429 }
4430 
4432  Expr *LowerBound,
4433  SourceLocation ColonLoc, Expr *Length,
4434  SourceLocation RBLoc) {
4435  if (Base->getType()->isPlaceholderType() &&
4437  BuiltinType::OMPArraySection)) {
4438  ExprResult Result = CheckPlaceholderExpr(Base);
4439  if (Result.isInvalid())
4440  return ExprError();
4441  Base = Result.get();
4442  }
4443  if (LowerBound && LowerBound->getType()->isNonOverloadPlaceholderType()) {
4444  ExprResult Result = CheckPlaceholderExpr(LowerBound);
4445  if (Result.isInvalid())
4446  return ExprError();
4447  Result = DefaultLvalueConversion(Result.get());
4448  if (Result.isInvalid())
4449  return ExprError();
4450  LowerBound = Result.get();
4451  }
4452  if (Length && Length->getType()->isNonOverloadPlaceholderType()) {
4453  ExprResult Result = CheckPlaceholderExpr(Length);
4454  if (Result.isInvalid())
4455  return ExprError();
4456  Result = DefaultLvalueConversion(Result.get());
4457  if (Result.isInvalid())
4458  return ExprError();
4459  Length = Result.get();
4460  }
4461 
4462  // Build an unanalyzed expression if either operand is type-dependent.
4463  if (Base->isTypeDependent() ||
4464  (LowerBound &&
4465  (LowerBound->isTypeDependent() || LowerBound->isValueDependent())) ||
4466  (Length && (Length->isTypeDependent() || Length->isValueDependent()))) {
4467  return new (Context)
4468  OMPArraySectionExpr(Base, LowerBound, Length, Context.DependentTy,
4469  VK_LValue, OK_Ordinary, ColonLoc, RBLoc);
4470  }
4471 
4472  // Perform default conversions.
4474  QualType ResultTy;
4475  if (OriginalTy->isAnyPointerType()) {
4476  ResultTy = OriginalTy->getPointeeType();
4477  } else if (OriginalTy->isArrayType()) {
4478  ResultTy = OriginalTy->getAsArrayTypeUnsafe()->getElementType();
4479  } else {
4480  return ExprError(
4481  Diag(Base->getExprLoc(), diag::err_omp_typecheck_section_value)
4482  << Base->getSourceRange());
4483  }
4484  // C99 6.5.2.1p1
4485  if (LowerBound) {
4486  auto Res = PerformOpenMPImplicitIntegerConversion(LowerBound->getExprLoc(),
4487  LowerBound);
4488  if (Res.isInvalid())
4489  return ExprError(Diag(LowerBound->getExprLoc(),
4490  diag::err_omp_typecheck_section_not_integer)
4491  << 0 << LowerBound->getSourceRange());
4492  LowerBound = Res.get();
4493 
4494  if (LowerBound->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
4495  LowerBound->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
4496  Diag(LowerBound->getExprLoc(), diag::warn_omp_section_is_char)
4497  << 0 << LowerBound->getSourceRange();
4498  }
4499  if (Length) {
4500  auto Res =
4501  PerformOpenMPImplicitIntegerConversion(Length->getExprLoc(), Length);
4502  if (Res.isInvalid())
4503  return ExprError(Diag(Length->getExprLoc(),
4504  diag::err_omp_typecheck_section_not_integer)
4505  << 1 << Length->getSourceRange());
4506  Length = Res.get();
4507 
4508  if (Length->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
4509  Length->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
4510  Diag(Length->getExprLoc(), diag::warn_omp_section_is_char)
4511  << 1 << Length->getSourceRange();
4512  }
4513 
4514  // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
4515  // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
4516  // type. Note that functions are not objects, and that (in C99 parlance)
4517  // incomplete types are not object types.
4518  if (ResultTy->isFunctionType()) {
4519  Diag(Base->getExprLoc(), diag::err_omp_section_function_type)
4520  << ResultTy << Base->getSourceRange();
4521  return ExprError();
4522  }
4523 
4524  if (RequireCompleteType(Base->getExprLoc(), ResultTy,
4525  diag::err_omp_section_incomplete_type, Base))
4526  return ExprError();
4527 
4528  if (LowerBound && !OriginalTy->isAnyPointerType()) {
4529  Expr::EvalResult Result;
4530  if (LowerBound->EvaluateAsInt(Result, Context)) {
4531  // OpenMP 4.5, [2.4 Array Sections]
4532  // The array section must be a subset of the original array.
4533  llvm::APSInt LowerBoundValue = Result.Val.getInt();
4534  if (LowerBoundValue.isNegative()) {
4535  Diag(LowerBound->getExprLoc(), diag::err_omp_section_not_subset_of_array)
4536  << LowerBound->getSourceRange();
4537  return ExprError();
4538  }
4539  }
4540  }
4541 
4542  if (Length) {
4543  Expr::EvalResult Result;
4544  if (Length->EvaluateAsInt(Result, Context)) {
4545  // OpenMP 4.5, [2.4 Array Sections]
4546  // The length must evaluate to non-negative integers.
4547  llvm::APSInt LengthValue = Result.Val.getInt();
4548  if (LengthValue.isNegative()) {
4549  Diag(Length->getExprLoc(), diag::err_omp_section_length_negative)
4550  << LengthValue.toString(/*Radix=*/10, /*Signed=*/true)
4551  << Length->getSourceRange();
4552  return ExprError();
4553  }
4554  }
4555  } else if (ColonLoc.isValid() &&
4556  (OriginalTy.isNull() || (!OriginalTy->isConstantArrayType() &&
4557  !OriginalTy->isVariableArrayType()))) {
4558  // OpenMP 4.5, [2.4 Array Sections]
4559  // When the size of the array dimension is not known, the length must be
4560  // specified explicitly.
4561  Diag(ColonLoc, diag::err_omp_section_length_undefined)
4562  << (!OriginalTy.isNull() && OriginalTy->isArrayType());
4563  return ExprError();
4564  }
4565 
4566  if (!Base->getType()->isSpecificPlaceholderType(
4567  BuiltinType::OMPArraySection)) {
4568  ExprResult Result = DefaultFunctionArrayLvalueConversion(Base);
4569  if (Result.isInvalid())
4570  return ExprError();
4571  Base = Result.get();
4572  }
4573  return new (Context)
4574  OMPArraySectionExpr(Base, LowerBound, Length, Context.OMPArraySectionTy,
4575  VK_LValue, OK_Ordinary, ColonLoc, RBLoc);
4576 }
4577 
4578 ExprResult
4580  Expr *Idx, SourceLocation RLoc) {
4581  Expr *LHSExp = Base;
4582  Expr *RHSExp = Idx;
4583 
4584  ExprValueKind VK = VK_LValue;
4586 
4587  // Per C++ core issue 1213, the result is an xvalue if either operand is
4588  // a non-lvalue array, and an lvalue otherwise.
4589  if (getLangOpts().CPlusPlus11) {
4590  for (auto *Op : {LHSExp, RHSExp}) {
4591  Op = Op->IgnoreImplicit();
4592  if (Op->getType()->isArrayType() && !Op->isLValue())
4593  VK = VK_XValue;
4594  }
4595  }
4596 
4597  // Perform default conversions.
4598  if (!LHSExp->getType()->getAs<VectorType>()) {
4599  ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp);
4600  if (Result.isInvalid())
4601  return ExprError();
4602  LHSExp = Result.get();
4603  }
4604  ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp);
4605  if (Result.isInvalid())
4606  return ExprError();
4607  RHSExp = Result.get();
4608 
4609  QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
4610 
4611  // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
4612  // to the expression *((e1)+(e2)). This means the array "Base" may actually be
4613  // in the subscript position. As a result, we need to derive the array base
4614  // and index from the expression types.
4615  Expr *BaseExpr, *IndexExpr;
4616  QualType ResultType;
4617  if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
4618  BaseExpr = LHSExp;
4619  IndexExpr = RHSExp;
4620  ResultType = Context.DependentTy;
4621  } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) {
4622  BaseExpr = LHSExp;
4623  IndexExpr = RHSExp;
4624  ResultType = PTy->getPointeeType();
4625  } else if (const ObjCObjectPointerType *PTy =
4626  LHSTy->getAs<ObjCObjectPointerType>()) {
4627  BaseExpr = LHSExp;
4628  IndexExpr = RHSExp;
4629 
4630  // Use custom logic if this should be the pseudo-object subscript
4631  // expression.
4632  if (!LangOpts.isSubscriptPointerArithmetic())
4633  return BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, nullptr,
4634  nullptr);
4635 
4636  ResultType = PTy->getPointeeType();
4637  } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) {
4638  // Handle the uncommon case of "123[Ptr]".
4639  BaseExpr = RHSExp;
4640  IndexExpr = LHSExp;
4641  ResultType = PTy->getPointeeType();
4642  } else if (const ObjCObjectPointerType *PTy =
4643  RHSTy->getAs<ObjCObjectPointerType>()) {
4644  // Handle the uncommon case of "123[Ptr]".
4645  BaseExpr = RHSExp;
4646  IndexExpr = LHSExp;
4647  ResultType = PTy->getPointeeType();
4648  if (!LangOpts.isSubscriptPointerArithmetic()) {
4649  Diag(LLoc, diag::err_subscript_nonfragile_interface)
4650  << ResultType << BaseExpr->getSourceRange();
4651  return ExprError();
4652  }
4653  } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) {
4654  BaseExpr = LHSExp; // vectors: V[123]
4655  IndexExpr = RHSExp;
4656  // We apply C++ DR1213 to vector subscripting too.
4657  if (getLangOpts().CPlusPlus11 && LHSExp->getValueKind() == VK_RValue) {
4658  ExprResult Materialized = TemporaryMaterializationConversion(LHSExp);
4659  if (Materialized.isInvalid())
4660  return ExprError();
4661  LHSExp = Materialized.get();
4662  }
4663  VK = LHSExp->getValueKind();
4664  if (VK != VK_RValue)
4665  OK = OK_VectorComponent;
4666 
4667  ResultType = VTy->getElementType();
4668  QualType BaseType = BaseExpr->getType();
4669  Qualifiers BaseQuals = BaseType.getQualifiers();
4670  Qualifiers MemberQuals = ResultType.getQualifiers();
4671  Qualifiers Combined = BaseQuals + MemberQuals;
4672  if (Combined != MemberQuals)
4673  ResultType = Context.getQualifiedType(ResultType, Combined);
4674  } else if (LHSTy->isArrayType()) {
4675  // If we see an array that wasn't promoted by
4676  // DefaultFunctionArrayLvalueConversion, it must be an array that
4677  // wasn't promoted because of the C90 rule that doesn't
4678  // allow promoting non-lvalue arrays. Warn, then
4679  // force the promotion here.
4680  Diag(LHSExp->getBeginLoc(), diag::ext_subscript_non_lvalue)
4681  << LHSExp->getSourceRange();
4682  LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy),
4683  CK_ArrayToPointerDecay).get();
4684  LHSTy = LHSExp->getType();
4685 
4686  BaseExpr = LHSExp;
4687  IndexExpr = RHSExp;
4688  ResultType = LHSTy->getAs<PointerType>()->getPointeeType();
4689  } else if (RHSTy->isArrayType()) {
4690  // Same as previous, except for 123[f().a] case
4691  Diag(RHSExp->getBeginLoc(), diag::ext_subscript_non_lvalue)
4692  << RHSExp->getSourceRange();
4693  RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy),
4694  CK_ArrayToPointerDecay).get();
4695  RHSTy = RHSExp->getType();
4696 
4697  BaseExpr = RHSExp;
4698  IndexExpr = LHSExp;
4699  ResultType = RHSTy->getAs<PointerType>()->getPointeeType();
4700  } else {
4701  return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
4702  << LHSExp->getSourceRange() << RHSExp->getSourceRange());
4703  }
4704  // C99 6.5.2.1p1
4705  if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
4706  return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
4707  << IndexExpr->getSourceRange());
4708 
4709  if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
4710  IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
4711  && !IndexExpr->isTypeDependent())
4712  Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange();
4713 
4714  // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
4715  // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
4716  // type. Note that Functions are not objects, and that (in C99 parlance)
4717  // incomplete types are not object types.
4718  if (ResultType->isFunctionType()) {
4719  Diag(BaseExpr->getBeginLoc(), diag::err_subscript_function_type)
4720  << ResultType << BaseExpr->getSourceRange();
4721  return ExprError();
4722  }
4723 
4724  if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {
4725  // GNU extension: subscripting on pointer to void
4726  Diag(LLoc, diag::ext_gnu_subscript_void_type)
4727  << BaseExpr->getSourceRange();
4728 
4729  // C forbids expressions of unqualified void type from being l-values.
4730  // See IsCForbiddenLValueType.
4731  if (!ResultType.hasQualifiers()) VK = VK_RValue;
4732  } else if (!ResultType->isDependentType() &&
4733  RequireCompleteType(LLoc, ResultType,
4734  diag::err_subscript_incomplete_type, BaseExpr))
4735  return ExprError();
4736 
4737  assert(VK == VK_RValue || LangOpts.CPlusPlus ||
4738  !ResultType.isCForbiddenLValueType());
4739 
4740  if (LHSExp->IgnoreParenImpCasts()->getType()->isVariablyModifiedType() &&
4741  FunctionScopes.size() > 1) {
4742  if (auto *TT =
4743  LHSExp->IgnoreParenImpCasts()->getType()->getAs<TypedefType>()) {
4744  for (auto I = FunctionScopes.rbegin(),
4745  E = std::prev(FunctionScopes.rend());
4746  I != E; ++I) {
4747  auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
4748  if (CSI == nullptr)
4749  break;
4750  DeclContext *DC = nullptr;
4751  if (auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
4752  DC = LSI->CallOperator;
4753  else if (auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
4754  DC = CRSI->TheCapturedDecl;
4755  else if (auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
4756  DC = BSI->TheDecl;
4757  if (DC) {
4758  if (DC->containsDecl(TT->getDecl()))
4759  break;
4761  Context, LHSExp->IgnoreParenImpCasts()->getType(), CSI);
4762  }
4763  }
4764  }
4765  }
4766 
4767  return new (Context)
4768  ArraySubscriptExpr(LHSExp, RHSExp, ResultType, VK, OK, RLoc);
4769 }
4770 
4772  ParmVarDecl *Param) {
4773  if (Param->hasUnparsedDefaultArg()) {
4774  Diag(CallLoc,
4775  diag::err_use_of_default_argument_to_function_declared_later) <<
4776  FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName();
4777  Diag(UnparsedDefaultArgLocs[Param],
4778  diag::note_default_argument_declared_here);
4779  return true;
4780  }
4781 
4782  if (Param->hasUninstantiatedDefaultArg()) {
4783  Expr *UninstExpr = Param->getUninstantiatedDefaultArg();
4784 
4786  *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
4787 
4788  // Instantiate the expression.
4789  //
4790  // FIXME: Pass in a correct Pattern argument, otherwise
4791  // getTemplateInstantiationArgs uses the lexical context of FD, e.g.
4792  //
4793  // template<typename T>
4794  // struct A {
4795  // static int FooImpl();
4796  //
4797  // template<typename Tp>
4798  // // bug: default argument A<T>::FooImpl() is evaluated with 2-level
4799  // // template argument list [[T], [Tp]], should be [[Tp]].
4800  // friend A<Tp> Foo(int a);
4801  // };
4802  //
4803  // template<typename T>
4804  // A<T> Foo(int a = A<T>::FooImpl());
4805  MultiLevelTemplateArgumentList MutiLevelArgList
4806  = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary=*/true);
4807 
4808  InstantiatingTemplate Inst(*this, CallLoc, Param,
4809  MutiLevelArgList.getInnermost());
4810  if (Inst.isInvalid())
4811  return true;
4812  if (Inst.isAlreadyInstantiating()) {
4813  Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
4814  Param->setInvalidDecl();
4815  return true;
4816  }
4817 
4818  ExprResult Result;
4819  {
4820  // C++ [dcl.fct.default]p5:
4821  // The names in the [default argument] expression are bound, and
4822  // the semantic constraints are checked, at the point where the
4823  // default argument expression appears.
4824  ContextRAII SavedContext(*this, FD);
4825  LocalInstantiationScope Local(*this);
4826  Result = SubstInitializer(UninstExpr, MutiLevelArgList,
4827  /*DirectInit*/false);
4828  }
4829  if (Result.isInvalid())
4830  return true;
4831 
4832  // Check the expression as an initializer for the parameter.
4833  InitializedEntity Entity
4834  = InitializedEntity::InitializeParameter(Context, Param);
4836  Param->getLocation(),
4837  /*FIXME:EqualLoc*/ UninstExpr->getBeginLoc());
4838  Expr *ResultE = Result.getAs<Expr>();
4839 
4840  InitializationSequence InitSeq(*this, Entity, Kind, ResultE);
4841  Result = InitSeq.Perform(*this, Entity, Kind, ResultE);
4842  if (Result.isInvalid())
4843  return true;
4844 
4845  Result =
4846  ActOnFinishFullExpr(Result.getAs<Expr>(), Param->getOuterLocStart(),
4847  /*DiscardedValue*/ false);
4848  if (Result.isInvalid())
4849  return true;
4850 
4851  // Remember the instantiated default argument.
4852  Param->setDefaultArg(Result.getAs<Expr>());
4853  if (ASTMutationListener *L = getASTMutationListener()) {
4854  L->DefaultArgumentInstantiated(Param);
4855  }
4856  }
4857 
4858  // If the default argument expression is not set yet, we are building it now.
4859  if (!Param->hasInit()) {
4860  Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
4861  Param->setInvalidDecl();
4862  return true;
4863  }
4864 
4865  // If the default expression creates temporaries, we need to
4866  // push them to the current stack of expression temporaries so they'll
4867  // be properly destroyed.
4868  // FIXME: We should really be rebuilding the default argument with new
4869  // bound temporaries; see the comment in PR5810.
4870  // We don't need to do that with block decls, though, because
4871  // blocks in default argument expression can never capture anything.
4872  if (auto Init = dyn_cast<ExprWithCleanups>(Param->getInit())) {
4873  // Set the "needs cleanups" bit regardless of whether there are
4874  // any explicit objects.
4875  Cleanup.setExprNeedsCleanups(Init->cleanupsHaveSideEffects());
4876 
4877  // Append all the objects to the cleanup list. Right now, this
4878  // should always be a no-op, because blocks in default argument
4879  // expressions should never be able to capture anything.
4880  assert(!Init->getNumObjects() &&
4881  "default argument expression has capturing blocks?");
4882  }
4883 
4884  // We already type-checked the argument, so we know it works.
4885  // Just mark all of the declarations in this potentially-evaluated expression
4886  // as being "referenced".
4888  *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
4889  MarkDeclarationsReferencedInExpr(Param->getDefaultArg(),
4890  /*SkipLocalVariables=*/true);
4891  return false;
4892 }
4893 
4895  FunctionDecl *FD, ParmVarDecl *Param) {
4896  if (CheckCXXDefaultArgExpr(CallLoc, FD, Param))
4897  return ExprError();
4898  return CXXDefaultArgExpr::Create(Context, CallLoc, Param, CurContext);
4899 }
4900 
4903  Expr *Fn) {
4904  if (Proto && Proto->isVariadic()) {
4905  if (dyn_cast_or_null<CXXConstructorDecl>(FDecl))
4906  return VariadicConstructor;
4907  else if (Fn && Fn->getType()->isBlockPointerType())
4908  return VariadicBlock;
4909  else if (FDecl) {
4910  if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
4911  if (Method->isInstance())
4912  return VariadicMethod;
4913  } else if (Fn && Fn->getType() == Context.BoundMemberTy)
4914  return VariadicMethod;
4915  return VariadicFunction;
4916  }
4917  return VariadicDoesNotApply;
4918 }
4919 
4920 namespace {
4921 class FunctionCallCCC final : public FunctionCallFilterCCC {
4922 public:
4923  FunctionCallCCC(Sema &SemaRef, const IdentifierInfo *FuncName,
4924  unsigned NumArgs, MemberExpr *ME)
4925  : FunctionCallFilterCCC(SemaRef, NumArgs, false, ME),
4926  FunctionName(FuncName) {}
4927 
4928  bool ValidateCandidate(const TypoCorrection &candidate) override {
4929  if (!candidate.getCorrectionSpecifier() ||
4930  candidate.getCorrectionAsIdentifierInfo() != FunctionName) {
4931  return false;
4932  }
4933 
4934  return FunctionCallFilterCCC::ValidateCandidate(candidate);
4935  }
4936 
4937  std::unique_ptr<CorrectionCandidateCallback> clone() override {
4938  return llvm::make_unique<FunctionCallCCC>(*this);
4939  }
4940 
4941 private:
4942  const IdentifierInfo *const FunctionName;
4943 };
4944 }
4945 
4947  FunctionDecl *FDecl,
4948  ArrayRef<Expr *> Args) {
4949  MemberExpr *ME = dyn_cast<MemberExpr>(Fn);
4950  DeclarationName FuncName = FDecl->getDeclName();
4951  SourceLocation NameLoc = ME ? ME->getMemberLoc() : Fn->getBeginLoc();
4952 
4953  FunctionCallCCC CCC(S, FuncName.getAsIdentifierInfo(), Args.size(), ME);
4954  if (TypoCorrection Corrected = S.CorrectTypo(
4955  DeclarationNameInfo(FuncName, NameLoc), Sema::LookupOrdinaryName,
4956  S.getScopeForContext(S.CurContext), nullptr, CCC,
4958  if (NamedDecl *ND = Corrected.getFoundDecl()) {
4959  if (Corrected.isOverloaded()) {
4962  for (NamedDecl *CD : Corrected) {
4963  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
4965  OCS);
4966  }
4967  switch (OCS.BestViableFunction(S, NameLoc, Best)) {
4968  case OR_Success:
4969  ND = Best->FoundDecl;
4970  Corrected.setCorrectionDecl(ND);
4971  break;
4972  default:
4973  break;
4974  }
4975  }
4976  ND = ND->getUnderlyingDecl();
4977  if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))
4978  return Corrected;
4979  }
4980  }
4981  return TypoCorrection();
4982 }
4983 
4984 /// ConvertArgumentsForCall - Converts the arguments specified in
4985 /// Args/NumArgs to the parameter types of the function FDecl with
4986 /// function prototype Proto. Call is the call expression itself, and
4987 /// Fn is the function expression. For a C++ member function, this
4988 /// routine does not attempt to convert the object argument. Returns
4989 /// true if the call is ill-formed.
4990 bool
4992  FunctionDecl *FDecl,
4993  const FunctionProtoType *Proto,
4994  ArrayRef<Expr *> Args,
4995  SourceLocation RParenLoc,
4996  bool IsExecConfig) {
4997  // Bail out early if calling a builtin with custom typechecking.
4998  if (FDecl)
4999  if (unsigned ID = FDecl->getBuiltinID())
5000  if (Context.BuiltinInfo.hasCustomTypechecking(ID))
5001  return false;
5002 
5003  // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
5004  // assignment, to the types of the corresponding parameter, ...
5005  unsigned NumParams = Proto->getNumParams();
5006  bool Invalid = false;
5007  unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumParams;
5008  unsigned FnKind = Fn->getType()->isBlockPointerType()
5009  ? 1 /* block */
5010  : (IsExecConfig ? 3 /* kernel function (exec config) */
5011  : 0 /* function */);
5012 
5013  // If too few arguments are available (and we don't have default
5014  // arguments for the remaining parameters), don't make the call.
5015  if (Args.size() < NumParams) {
5016  if (Args.size() < MinArgs) {
5017  TypoCorrection TC;
5018  if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
5019  unsigned diag_id =
5020  MinArgs == NumParams && !Proto->isVariadic()
5021  ? diag::err_typecheck_call_too_few_args_suggest
5022  : diag::err_typecheck_call_too_few_args_at_least_suggest;
5023  diagnoseTypo(TC, PDiag(diag_id) << FnKind << MinArgs
5024  << static_cast<unsigned>(Args.size())
5025  << TC.getCorrectionRange());
5026  } else if (MinArgs == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName())
5027  Diag(RParenLoc,
5028  MinArgs == NumParams && !Proto->isVariadic()
5029  ? diag::err_typecheck_call_too_few_args_one
5030  : diag::err_typecheck_call_too_few_args_at_least_one)
5031  << FnKind << FDecl->getParamDecl(0) << Fn->getSourceRange();
5032  else
5033  Diag(RParenLoc, MinArgs == NumParams && !Proto->isVariadic()
5034  ? diag::err_typecheck_call_too_few_args
5035  : diag::err_typecheck_call_too_few_args_at_least)
5036  << FnKind << MinArgs << static_cast<unsigned>(Args.size())
5037  << Fn->getSourceRange();
5038 
5039  // Emit the location of the prototype.
5040  if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
5041  Diag(FDecl->getBeginLoc(), diag::note_callee_decl) << FDecl;
5042 
5043  return true;
5044  }
5045  // We reserve space for the default arguments when we create
5046  // the call expression, before calling ConvertArgumentsForCall.
5047  assert((Call->getNumArgs() == NumParams) &&
5048  "We should have reserved space for the default arguments before!");
5049  }
5050 
5051  // If too many are passed and not variadic, error on the extras and drop
5052  // them.
5053  if (Args.size() > NumParams) {
5054  if (!Proto->isVariadic()) {
5055  TypoCorrection TC;
5056  if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
5057  unsigned diag_id =
5058  MinArgs == NumParams && !Proto->isVariadic()
5059  ? diag::err_typecheck_call_too_many_args_suggest
5060  : diag::err_typecheck_call_too_many_args_at_most_suggest;
5061  diagnoseTypo(TC, PDiag(diag_id) << FnKind << NumParams
5062  << static_cast<unsigned>(Args.size())
5063  << TC.getCorrectionRange());
5064  } else if (NumParams == 1 && FDecl &&
5065  FDecl->getParamDecl(0)->getDeclName())
5066  Diag(Args[NumParams]->getBeginLoc(),
5067  MinArgs == NumParams
5068  ? diag::err_typecheck_call_too_many_args_one
5069  : diag::err_typecheck_call_too_many_args_at_most_one)
5070  << FnKind << FDecl->getParamDecl(0)
5071  << static_cast<unsigned>(Args.size()) << Fn->getSourceRange()
5072  << SourceRange(Args[NumParams]->getBeginLoc(),
5073  Args.back()->getEndLoc());
5074  else
5075  Diag(Args[NumParams]->getBeginLoc(),
5076  MinArgs == NumParams
5077  ? diag::err_typecheck_call_too_many_args
5078  : diag::err_typecheck_call_too_many_args_at_most)
5079  << FnKind << NumParams << static_cast<unsigned>(Args.size())
5080  << Fn->getSourceRange()
5081  << SourceRange(Args[NumParams]->getBeginLoc(),
5082  Args.back()->getEndLoc());
5083 
5084  // Emit the location of the prototype.
5085  if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
5086  Diag(FDecl->getBeginLoc(), diag::note_callee_decl) << FDecl;
5087 
5088  // This deletes the extra arguments.
5089  Call->shrinkNumArgs(NumParams);
5090  return true;
5091  }
5092  }
5093  SmallVector<Expr *, 8> AllArgs;
5094  VariadicCallType CallType = getVariadicCallType(FDecl, Proto, Fn);
5095 
5096  Invalid = GatherArgumentsForCall(Call->getBeginLoc(), FDecl, Proto, 0, Args,
5097  AllArgs, CallType);
5098  if (Invalid)
5099  return true;
5100  unsigned TotalNumArgs = AllArgs.size();
5101  for (unsigned i = 0; i < TotalNumArgs; ++i)
5102  Call->setArg(i, AllArgs[i]);
5103 
5104  return false;
5105 }
5106 
5108  const FunctionProtoType *Proto,
5109  unsigned FirstParam, ArrayRef<Expr *> Args,
5110  SmallVectorImpl<Expr *> &AllArgs,
5111  VariadicCallType CallType, bool AllowExplicit,
5112  bool IsListInitialization) {
5113  unsigned NumParams = Proto->getNumParams();
5114  bool Invalid = false;
5115  size_t ArgIx = 0;
5116  // Continue to check argument types (even if we have too few/many args).
5117  for (unsigned i = FirstParam; i < NumParams; i++) {
5118  QualType ProtoArgType = Proto->getParamType(i);
5119 
5120  Expr *Arg;
5121  ParmVarDecl *Param = FDecl ? FDecl->getParamDecl(i) : nullptr;
5122  if (ArgIx < Args.size()) {
5123  Arg = Args[ArgIx++];
5124 
5125  if (RequireCompleteType(Arg->getBeginLoc(), ProtoArgType,
5126  diag::err_call_incomplete_argument, Arg))
5127  return true;
5128 
5129  // Strip the unbridged-cast placeholder expression off, if applicable.
5130  bool CFAudited = false;
5131  if (Arg->getType() == Context.ARCUnbridgedCastTy &&
5132  FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
5133  (!Param || !Param->hasAttr<CFConsumedAttr>()))
5134  Arg = stripARCUnbridgedCast(Arg);
5135  else if (getLangOpts().ObjCAutoRefCount &&
5136  FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
5137  (!Param || !Param->hasAttr<CFConsumedAttr>()))
5138  CFAudited = true;
5139 
5140  if (Proto->getExtParameterInfo(i).isNoEscape())
5141  if (auto *BE = dyn_cast<BlockExpr>(Arg->IgnoreParenNoopCasts(Context)))
5142  BE->getBlockDecl()->setDoesNotEscape();
5143 
5144  InitializedEntity Entity =
5145  Param ? InitializedEntity::InitializeParameter(Context, Param,
5146  ProtoArgType)
5148  Context, ProtoArgType, Proto->isParamConsumed(i));
5149 
5150  // Remember that parameter belongs to a CF audited API.
5151  if (CFAudited)
5152  Entity.setParameterCFAudited();
5153 
5154  ExprResult ArgE = PerformCopyInitialization(
5155  Entity, SourceLocation(), Arg, IsListInitialization, AllowExplicit);
5156  if (ArgE.isInvalid())
5157  return true;
5158 
5159  Arg = ArgE.getAs<Expr>();
5160  } else {
5161  assert(Param && "can't use default arguments without a known callee");
5162 
5163  ExprResult ArgExpr = BuildCXXDefaultArgExpr(CallLoc, FDecl, Param);
5164  if (ArgExpr.isInvalid())
5165  return true;
5166 
5167  Arg = ArgExpr.getAs<Expr>();
5168  }
5169 
5170  // Check for array bounds violations for each argument to the call. This
5171  // check only triggers warnings when the argument isn't a more complex Expr
5172  // with its own checking, such as a BinaryOperator.
5173  CheckArrayAccess(Arg);
5174 
5175  // Check for violations of C99 static array rules (C99 6.7.5.3p7).
5176  CheckStaticArrayArgument(CallLoc, Param, Arg);
5177 
5178  AllArgs.push_back(Arg);
5179  }
5180 
5181  // If this is a variadic call, handle args passed through "...".
5182  if (CallType != VariadicDoesNotApply) {
5183  // Assume that extern "C" functions with variadic arguments that
5184  // return __unknown_anytype aren't *really* variadic.
5185  if (Proto->getReturnType() == Context.UnknownAnyTy && FDecl &&
5186  FDecl->isExternC()) {
5187  for (Expr *A : Args.slice(ArgIx)) {
5188  QualType paramType; // ignored
5189  ExprResult arg = checkUnknownAnyArg(CallLoc, A, paramType);
5190  Invalid |= arg.isInvalid();
5191  AllArgs.push_back(arg.get());
5192  }
5193 
5194  // Otherwise do argument promotion, (C99 6.5.2.2p7).
5195  } else {
5196  for (Expr *A : Args.slice(ArgIx)) {
5197  ExprResult Arg = DefaultVariadicArgumentPromotion(A, CallType, FDecl);
5198  Invalid |= Arg.isInvalid();
5199  AllArgs.push_back(Arg.get());
5200  }
5201  }
5202 
5203  // Check for array bounds violations.
5204  for (Expr *A : Args.slice(ArgIx))
5205  CheckArrayAccess(A);
5206  }
5207  return Invalid;
5208 }
5209 
5211  TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc();
5212  if (DecayedTypeLoc DTL = TL.getAs<DecayedTypeLoc>())
5213  TL = DTL.getOriginalLoc();
5214  if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>())
5215  S.Diag(PVD->getLocation(), diag::note_callee_static_array)
5216  << ATL.getLocalSourceRange();
5217 }
5218 
5219 /// CheckStaticArrayArgument - If the given argument corresponds to a static
5220 /// array parameter, check that it is non-null, and that if it is formed by
5221 /// array-to-pointer decay, the underlying array is sufficiently large.
5222 ///
5223 /// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the
5224 /// array type derivation, then for each call to the function, the value of the
5225 /// corresponding actual argument shall provide access to the first element of
5226 /// an array with at least as many elements as specified by the size expression.
5227 void
5229  ParmVarDecl *Param,
5230  const Expr *ArgExpr) {
5231  // Static array parameters are not supported in C++.
5232  if (!Param || getLangOpts().CPlusPlus)
5233  return;
5234 
5235  QualType OrigTy = Param->getOriginalType();
5236 
5237  const ArrayType *AT = Context.getAsArrayType(OrigTy);
5238  if (!AT || AT->getSizeModifier() != ArrayType::Static)
5239  return;
5240 
5241  if (ArgExpr->isNullPointerConstant(Context,
5243  Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange();
5244  DiagnoseCalleeStaticArrayParam(*this, Param);
5245  return;
5246  }
5247 
5248  const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT);
5249  if (!CAT)
5250  return;
5251 
5252  const ConstantArrayType *ArgCAT =
5253  Context.getAsConstantArrayType(ArgExpr->IgnoreParenCasts()->getType());
5254  if (!ArgCAT)
5255  return;
5256 
5257  if (getASTContext().hasSameUnqualifiedType(CAT->getElementType(),
5258  ArgCAT->getElementType())) {
5259  if (ArgCAT->getSize().ult(CAT->getSize())) {
5260  Diag(CallLoc, diag::warn_static_array_too_small)
5261  << ArgExpr->getSourceRange()
5262  << (unsigned)ArgCAT->getSize().getZExtValue()
5263  << (unsigned)CAT->getSize().getZExtValue() << 0;
5264  DiagnoseCalleeStaticArrayParam(*this, Param);
5265  }
5266  return;
5267  }
5268 
5269  Optional<CharUnits> ArgSize =
5270  getASTContext().getTypeSizeInCharsIfKnown(ArgCAT);
5271  Optional<CharUnits> ParmSize = getASTContext().getTypeSizeInCharsIfKnown(CAT);
5272  if (ArgSize && ParmSize && *ArgSize < *ParmSize) {
5273  Diag(CallLoc, diag::warn_static_array_too_small)
5274  << ArgExpr->getSourceRange() << (unsigned)ArgSize->getQuantity()
5275  << (unsigned)ParmSize->getQuantity() << 1;
5276  DiagnoseCalleeStaticArrayParam(*this, Param);
5277  }
5278 }
5279 
5280 /// Given a function expression of unknown-any type, try to rebuild it
5281 /// to have a function type.
5283 
5284 /// Is the given type a placeholder that we need to lower out
5285 /// immediately during argument processing?
5287  // Placeholders are never sugared.
5288  const BuiltinType *placeholder = dyn_cast<BuiltinType>(type);
5289  if (!placeholder) return false;
5290 
5291  switch (placeholder->getKind()) {
5292  // Ignore all the non-placeholder types.
5293 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
5294  case BuiltinType::Id:
5295 #include "clang/Basic/OpenCLImageTypes.def"
5296 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
5297  case BuiltinType::Id:
5298 #include "clang/Basic/OpenCLExtensionTypes.def"
5299 #define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
5300 #define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
5301 #include "clang/AST/BuiltinTypes.def"
5302  return false;
5303 
5304  // We cannot lower out overload sets; they might validly be resolved
5305  // by the call machinery.
5306  case BuiltinType::Overload:
5307  return false;
5308 
5309  // Unbridged casts in ARC can be handled in some call positions and
5310  // should be left in place.
5311  case BuiltinType::ARCUnbridgedCast:
5312  return false;
5313 
5314  // Pseudo-objects should be converted as soon as possible.
5315  case BuiltinType::PseudoObject:
5316  return true;
5317 
5318  // The debugger mode could theoretically but currently does not try
5319  // to resolve unknown-typed arguments based on known parameter types.
5320  case BuiltinType::UnknownAny:
5321  return true;
5322 
5323  // These are always invalid as call arguments and should be reported.
5324  case BuiltinType::BoundMember:
5325  case BuiltinType::BuiltinFn:
5326  case BuiltinType::OMPArraySection:
5327  return true;
5328 
5329  }
5330  llvm_unreachable("bad builtin type kind");
5331 }
5332 
5333 /// Check an argument list for placeholders that we won't try to
5334 /// handle later.
5336  // Apply this processing to all the arguments at once instead of
5337  // dying at the first failure.
5338  bool hasInvalid = false;
5339  for (size_t i = 0, e = args.size(); i != e; i++) {
5340  if (isPlaceholderToRemoveAsArg(args[i]->getType())) {
5342  if (result.isInvalid()) hasInvalid = true;
5343  else args[i] = result.get();
5344  } else if (hasInvalid) {
5345  (void)S.CorrectDelayedTyposInExpr(args[i]);
5346  }
5347  }
5348  return hasInvalid;
5349 }
5350 
5351 /// If a builtin function has a pointer argument with no explicit address
5352 /// space, then it should be able to accept a pointer to any address
5353 /// space as input. In order to do this, we need to replace the
5354 /// standard builtin declaration with one that uses the same address space
5355 /// as the call.
5356 ///
5357 /// \returns nullptr If this builtin is not a candidate for a rewrite i.e.
5358 /// it does not contain any pointer arguments without
5359 /// an address space qualifer. Otherwise the rewritten
5360 /// FunctionDecl is returned.
5361 /// TODO: Handle pointer return types.
5363  FunctionDecl *FDecl,
5364  MultiExprArg ArgExprs) {
5365 
5366  QualType DeclType = FDecl->getType();
5367  const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(DeclType);
5368 
5369  if (!Context.BuiltinInfo.hasPtrArgsOrResult(FDecl->getBuiltinID()) ||
5370  !FT || FT->isVariadic() || ArgExprs.size() != FT->getNumParams())
5371  return nullptr;
5372 
5373  bool NeedsNewDecl = false;
5374  unsigned i = 0;
5375  SmallVector<QualType, 8> OverloadParams;
5376 
5377  for (QualType ParamType : FT->param_types()) {
5378 
5379  // Convert array arguments to pointer to simplify type lookup.
5380  ExprResult ArgRes =
5381  Sema->DefaultFunctionArrayLvalueConversion(ArgExprs[i++]);
5382  if (ArgRes.isInvalid())
5383  return nullptr;
5384  Expr *Arg = ArgRes.get();
5385  QualType ArgType = Arg->getType();
5386  if (!ParamType->isPointerType() ||
5387  ParamType.getQualifiers().hasAddressSpace() ||
5388  !ArgType->isPointerType() ||
5389  !ArgType->getPointeeType().getQualifiers().hasAddressSpace()) {
5390  OverloadParams.push_back(ParamType);
5391  continue;
5392  }
5393 
5394  QualType PointeeType = ParamType->getPointeeType();
5395  if (PointeeType.getQualifiers().hasAddressSpace())
5396  continue;
5397 
5398  NeedsNewDecl = true;
5399  LangAS AS = ArgType->getPointeeType().getAddressSpace();
5400 
5401  PointeeType = Context.getAddrSpaceQualType(PointeeType, AS);
5402  OverloadParams.push_back(Context.getPointerType(PointeeType));
5403  }
5404 
5405  if (!NeedsNewDecl)
5406  return nullptr;
5407 
5409  QualType OverloadTy = Context.getFunctionType(FT->getReturnType(),
5410  OverloadParams, EPI);
5411  DeclContext *Parent = FDecl->getParent();
5412  FunctionDecl *OverloadDecl = FunctionDecl::Create(Context, Parent,
5413  FDecl->getLocation(),
5414  FDecl->getLocation(),
5415  FDecl->getIdentifier(),
5416  OverloadTy,
5417  /*TInfo=*/nullptr,
5418  SC_Extern, false,
5419  /*hasPrototype=*/true);
5421  FT = cast<FunctionProtoType>(OverloadTy);
5422  for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
5423  QualType ParamType = FT->getParamType(i);
5424  ParmVarDecl *Parm =
5425  ParmVarDecl::Create(Context, OverloadDecl, SourceLocation(),
5426  SourceLocation(), nullptr, ParamType,
5427  /*TInfo=*/nullptr, SC_None, nullptr);
5428  Parm->setScopeInfo(0, i);
5429  Params.push_back(Parm);
5430  }
5431  OverloadDecl->setParams(Params);
5432  return OverloadDecl;
5433 }
5434 
5435 static void checkDirectCallValidity(Sema &S, const Expr *Fn,
5436  FunctionDecl *Callee,
5437  MultiExprArg ArgExprs) {
5438  // `Callee` (when called with ArgExprs) may be ill-formed. enable_if (and
5439  // similar attributes) really don't like it when functions are called with an
5440  // invalid number of args.
5441  if (S.TooManyArguments(Callee->getNumParams(), ArgExprs.size(),
5442  /*PartialOverloading=*/false) &&
5443  !Callee->isVariadic())
5444  return;
5445  if (Callee->getMinRequiredArguments() > ArgExprs.size())
5446  return;
5447 
5448  if (const EnableIfAttr *Attr = S.CheckEnableIf(Callee, ArgExprs, true)) {
5449  S.Diag(Fn->getBeginLoc(),
5450  isa<CXXMethodDecl>(Callee)
5451  ? diag::err_ovl_no_viable_member_function_in_call
5452  : diag::err_ovl_no_viable_function_in_call)
5453  << Callee << Callee->getSourceRange();
5454  S.Diag(Callee->getLocation(),
5455  diag::note_ovl_candidate_disabled_by_function_cond_attr)
5456  << Attr->getCond()->getSourceRange() << Attr->getMessage();
5457  return;
5458  }
5459 }
5460 
5462  const UnresolvedMemberExpr *const UME, Sema &S) {
5463 
5464  const auto GetFunctionLevelDCIfCXXClass =
5465  [](Sema &S) -> const CXXRecordDecl * {
5466  const DeclContext *const DC = S.getFunctionLevelDeclContext();
5467  if (!DC || !DC->getParent())
5468  return nullptr;
5469 
5470  // If the call to some member function was made from within a member
5471  // function body 'M' return return 'M's parent.
5472  if (const auto *MD = dyn_cast<CXXMethodDecl>(DC))
5473  return MD->getParent()->getCanonicalDecl();
5474  // else the call was made from within a default member initializer of a
5475  // class, so return the class.
5476  if (const auto *RD = dyn_cast<CXXRecordDecl>(DC))
5477  return RD->getCanonicalDecl();
5478  return nullptr;
5479  };
5480  // If our DeclContext is neither a member function nor a class (in the
5481  // case of a lambda in a default member initializer), we can't have an
5482  // enclosing 'this'.
5483 
5484  const CXXRecordDecl *const CurParentClass = GetFunctionLevelDCIfCXXClass(S);
5485  if (!CurParentClass)
5486  return false;
5487 
5488  // The naming class for implicit member functions call is the class in which
5489  // name lookup starts.
5490  const CXXRecordDecl *const NamingClass =
5491  UME->getNamingClass()->getCanonicalDecl();
5492  assert(NamingClass && "Must have naming class even for implicit access");
5493 
5494  // If the unresolved member functions were found in a 'naming class' that is
5495  // related (either the same or derived from) to the class that contains the
5496  // member function that itself contained the implicit member access.
5497 
5498  return CurParentClass == NamingClass ||
5499  CurParentClass->isDerivedFrom(NamingClass);
5500 }
5501 
5502 static void
5504  Sema &S, const UnresolvedMemberExpr *const UME, SourceLocation CallLoc) {
5505 
5506  if (!UME)
5507  return;
5508 
5509  LambdaScopeInfo *const CurLSI = S.getCurLambda();
5510  // Only try and implicitly capture 'this' within a C++ Lambda if it hasn't
5511  // already been captured, or if this is an implicit member function call (if
5512  // it isn't, an attempt to capture 'this' should already have been made).
5513  if (!CurLSI || CurLSI->ImpCaptureStyle == CurLSI->ImpCap_None ||
5514  !UME->isImplicitAccess() || CurLSI->isCXXThisCaptured())
5515  return;
5516 
5517  // Check if the naming class in which the unresolved members were found is
5518  // related (same as or is a base of) to the enclosing class.
5519 
5521  return;
5522 
5523 
5524  DeclContext *EnclosingFunctionCtx = S.CurContext->getParent()->getParent();
5525  // If the enclosing function is not dependent, then this lambda is
5526  // capture ready, so if we can capture this, do so.
5527  if (!EnclosingFunctionCtx->isDependentContext()) {
5528  // If the current lambda and all enclosing lambdas can capture 'this' -
5529  // then go ahead and capture 'this' (since our unresolved overload set
5530  // contains at least one non-static member function).
5531  if (!S.CheckCXXThisCapture(CallLoc, /*Explcit*/ false, /*Diagnose*/ false))
5532  S.CheckCXXThisCapture(CallLoc);
5533  } else if (S.CurContext->isDependentContext()) {
5534  // ... since this is an implicit member reference, that might potentially
5535  // involve a 'this' capture, mark 'this' for potential capture in
5536  // enclosing lambdas.
5537  if (CurLSI->ImpCaptureStyle != CurLSI->ImpCap_None)
5538  CurLSI->addPotentialThisCapture(CallLoc);
5539  }
5540 }
5541 
5543  MultiExprArg ArgExprs, SourceLocation RParenLoc,
5544  Expr *ExecConfig) {
5545  ExprResult Call =
5546  BuildCallExpr(Scope, Fn, LParenLoc, ArgExprs, RParenLoc, ExecConfig);
5547  if (Call.isInvalid())
5548  return Call;
5549 
5550  // Diagnose uses of the C++20 "ADL-only template-id call" feature in earlier
5551  // language modes.
5552  if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn)) {
5553  if (ULE->hasExplicitTemplateArgs() &&
5554  ULE->decls_begin() == ULE->decls_end()) {
5555  Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus2a
5556  ? diag::warn_cxx17_compat_adl_only_template_id
5557  : diag::ext_adl_only_template_id)
5558  << ULE->getName();
5559  }
5560  }
5561 
5562  return Call;
5563 }
5564 
5565 /// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
5566 /// This provides the location of the left/right parens and a list of comma
5567 /// locations.
5569  MultiExprArg ArgExprs, SourceLocation RParenLoc,
5570  Expr *ExecConfig, bool IsExecConfig) {
5571  // Since this might be a postfix expression, get rid of ParenListExprs.
5572  ExprResult Result = MaybeConvertParenListExprToParenExpr(Scope, Fn);
5573  if (Result.isInvalid()) return ExprError();
5574  Fn = Result.get();
5575 
5576  if (checkArgsForPlaceholders(*this, ArgExprs))
5577  return ExprError();
5578 
5579  if (getLangOpts().CPlusPlus) {
5580  // If this is a pseudo-destructor expression, build the call immediately.
5581  if (isa<CXXPseudoDestructorExpr>(Fn)) {
5582  if (!ArgExprs.empty()) {
5583  // Pseudo-destructor calls should not have any arguments.
5584  Diag(Fn->getBeginLoc(), diag::err_pseudo_dtor_call_with_args)
5586  SourceRange(ArgExprs.front()->getBeginLoc(),
5587  ArgExprs.back()->getEndLoc()));
5588  }
5589 
5590  return CallExpr::Create(Context, Fn, /*Args=*/{}, Context.VoidTy,
5591  VK_RValue, RParenLoc);
5592  }
5593  if (Fn->getType() == Context.PseudoObjectTy) {
5594  ExprResult result = CheckPlaceholderExpr(Fn);
5595  if (result.isInvalid()) return ExprError();
5596  Fn = result.get();
5597  }
5598 
5599  // Determine whether this is a dependent call inside a C++ template,
5600  // in which case we won't do any semantic analysis now.
5601  if (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs)) {
5602  if (ExecConfig) {
5604  Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs,
5605  Context.DependentTy, VK_RValue, RParenLoc);
5606  } else {
5607 
5609  *this, dyn_cast<UnresolvedMemberExpr>(Fn->IgnoreParens()),
5610  Fn->getBeginLoc());
5611 
5612  return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
5613  VK_RValue, RParenLoc);
5614  }
5615  }
5616 
5617  // Determine whether this is a call to an object (C++ [over.call.object]).
5618  if (Fn->getType()->isRecordType())
5619  return BuildCallToObjectOfClassType(Scope, Fn, LParenLoc, ArgExprs,
5620  RParenLoc);
5621 
5622  if (Fn->getType() == Context.UnknownAnyTy) {
5624  if (result.isInvalid()) return ExprError();
5625  Fn = result.get();
5626  }
5627 
5628  if (Fn->getType() == Context.BoundMemberTy) {
5629  return BuildCallToMemberFunction(Scope, Fn, LParenLoc, ArgExprs,
5630  RParenLoc);
5631  }
5632  }
5633 
5634  // Check for overloaded calls. This can happen even in C due to extensions.
5635  if (Fn->getType() == Context.OverloadTy) {
5637 
5638  // We aren't supposed to apply this logic if there's an '&' involved.
5639  if (!find.HasFormOfMemberPointer) {
5640  if (Expr::hasAnyTypeDependentArguments(ArgExprs))
5641  return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
5642  VK_RValue, RParenLoc);
5643  OverloadExpr *ovl = find.Expression;
5644  if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(ovl))
5645  return BuildOverloadedCallExpr(
5646  Scope, Fn, ULE, LParenLoc, ArgExprs, RParenLoc, ExecConfig,
5647  /*AllowTypoCorrection=*/true, find.IsAddressOfOperand);
5648  return BuildCallToMemberFunction(Scope, Fn, LParenLoc, ArgExprs,
5649  RParenLoc);
5650  }
5651  }
5652 
5653  // If we're directly calling a function, get the appropriate declaration.
5654  if (Fn->getType() == Context.UnknownAnyTy) {
5656  if (result.isInvalid()) return ExprError();
5657  Fn = result.get();
5658  }
5659 
5660  Expr *NakedFn = Fn->IgnoreParens();
5661 
5662  bool CallingNDeclIndirectly = false;
5663  NamedDecl *NDecl = nullptr;
5664  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) {
5665  if (UnOp->getOpcode() == UO_AddrOf) {
5666  CallingNDeclIndirectly = true;
5667  NakedFn = UnOp->getSubExpr()->IgnoreParens();
5668  }
5669  }
5670 
5671  if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
5672  NDecl = DRE->getDecl();
5673 
5674  FunctionDecl *FDecl = dyn_cast<FunctionDecl>(NDecl);
5675  if (FDecl && FDecl->getBuiltinID()) {
5676  // Rewrite the function decl for this builtin by replacing parameters
5677  // with no explicit address space with the address space of the arguments
5678  // in ArgExprs.
5679  if ((FDecl =
5680  rewriteBuiltinFunctionDecl(this, Context, FDecl, ArgExprs))) {
5681  NDecl = FDecl;
5682  Fn = DeclRefExpr::Create(
5683  Context, FDecl->getQualifierLoc(), SourceLocation(), FDecl, false,
5684  SourceLocation(), FDecl->getType(), Fn->getValueKind(), FDecl,
5685  nullptr, DRE->isNonOdrUse());
5686  }
5687  }
5688  } else if (isa<MemberExpr>(NakedFn))
5689  NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl();
5690 
5691  if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
5692  if (CallingNDeclIndirectly && !checkAddressOfFunctionIsAvailable(
5693  FD, /*Complain=*/true, Fn->getBeginLoc()))
5694  return ExprError();
5695 
5696  if (getLangOpts().OpenCL && checkOpenCLDisabledDecl(*FD, *Fn))
5697  return ExprError();
5698 
5699  checkDirectCallValidity(*this, Fn, FD, ArgExprs);
5700  }
5701 
5702  return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
5703  ExecConfig, IsExecConfig);
5704 }
5705 
5706 /// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments.
5707 ///
5708 /// __builtin_astype( value, dst type )
5709 ///
5711  SourceLocation BuiltinLoc,
5712  SourceLocation RParenLoc) {
5713  ExprValueKind VK = VK_RValue;
5715  QualType DstTy = GetTypeFromParser(ParsedDestTy);
5716  QualType SrcTy = E->getType();
5717  if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy))
5718  return ExprError(Diag(BuiltinLoc,
5719  diag::err_invalid_astype_of_different_size)
5720  << DstTy
5721  << SrcTy
5722  << E->getSourceRange());
5723  return new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc, RParenLoc);
5724 }
5725 
5726 /// ActOnConvertVectorExpr - create a new convert-vector expression from the
5727 /// provided arguments.
5728 ///
5729 /// __builtin_convertvector( value, dst type )
5730 ///
5732  SourceLocation BuiltinLoc,
5733  SourceLocation RParenLoc) {
5734  TypeSourceInfo *TInfo;
5735  GetTypeFromParser(ParsedDestTy, &TInfo);
5736  return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc);
5737 }
5738 
5739 /// BuildResolvedCallExpr - Build a call to a resolved expression,
5740 /// i.e. an expression not of \p OverloadTy. The expression should
5741 /// unary-convert to an expression of function-pointer or
5742 /// block-pointer type.
5743 ///
5744 /// \param NDecl the declaration being called, if available
5746  SourceLocation LParenLoc,
5747  ArrayRef<Expr *> Args,
5748  SourceLocation RParenLoc, Expr *Config,
5749  bool IsExecConfig, ADLCallKind UsesADL) {
5750  FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
5751  unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0);
5752 
5753  // Functions with 'interrupt' attribute cannot be called directly.
5754  if (FDecl && FDecl->hasAttr<AnyX86InterruptAttr>()) {
5755  Diag(Fn->getExprLoc(), diag::err_anyx86_interrupt_called);
5756  return ExprError();
5757  }
5758 
5759  // Interrupt handlers don't save off the VFP regs automatically on ARM,
5760  // so there's some risk when calling out to non-interrupt handler functions
5761  // that the callee might not preserve them. This is easy to diagnose here,
5762  // but can be very challenging to debug.
5763  if (auto *Caller = getCurFunctionDecl())
5764  if (Caller->hasAttr<ARMInterruptAttr>()) {
5765  bool VFP = Context.getTargetInfo().hasFeature("vfp");
5766  if (VFP && (!FDecl || !FDecl->hasAttr<ARMInterruptAttr>()))
5767  Diag(Fn->getExprLoc(), diag::warn_arm_interrupt_calling_convention);
5768  }
5769 
5770  // Promote the function operand.
5771  // We special-case function promotion here because we only allow promoting
5772  // builtin functions to function pointers in the callee of a call.
5773  ExprResult Result;
5774  QualType ResultTy;
5775  if (BuiltinID &&
5776  Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) {
5777  // Extract the return type from the (builtin) function pointer type.
5778  // FIXME Several builtins still have setType in
5779  // Sema::CheckBuiltinFunctionCall. One should review their definitions in
5780  // Builtins.def to ensure they are correct before removing setType calls.
5781  QualType FnPtrTy = Context.getPointerType(FDecl->getType());
5782  Result = ImpCastExprToType(Fn, FnPtrTy, CK_BuiltinFnToFnPtr).get();
5783  ResultTy = FDecl->getCallResultType();
5784  } else {
5785  Result = CallExprUnaryConversions(Fn);
5786  ResultTy = Context.BoolTy;
5787  }
5788  if (Result.isInvalid())
5789  return ExprError();
5790  Fn = Result.get();
5791 
5792  // Check for a valid function type, but only if it is not a builtin which
5793  // requires custom type checking. These will be handled by
5794  // CheckBuiltinFunctionCall below just after creation of the call expression.
5795  const FunctionType *FuncT = nullptr;
5796  if (!BuiltinID || !Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) {
5797  retry:
5798  if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) {
5799  // C99 6.5.2.2p1 - "The expression that denotes the called function shall
5800  // have type pointer to function".
5801  FuncT = PT->getPointeeType()->getAs<FunctionType>();
5802  if (!FuncT)
5803  return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
5804  << Fn->getType() << Fn->getSourceRange());
5805  } else if (const BlockPointerType *BPT =
5806  Fn->getType()->getAs<BlockPointerType>()) {
5807  FuncT = BPT->getPointeeType()->castAs<FunctionType>();
5808  } else {
5809  // Handle calls to expressions of unknown-any type.
5810  if (Fn->getType() == Context.UnknownAnyTy) {
5811  ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn);
5812  if (rewrite.isInvalid())
5813  return ExprError();
5814  Fn = rewrite.get();
5815  goto retry;
5816  }
5817 
5818  return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
5819  << Fn->getType() << Fn->getSourceRange());
5820  }
5821  }
5822 
5823  // Get the number of parameters in the function prototype, if any.
5824  // We will allocate space for max(Args.size(), NumParams) arguments
5825  // in the call expression.
5826  const auto *Proto = dyn_cast_or_null<FunctionProtoType>(FuncT);
5827  unsigned NumParams = Proto ? Proto->getNumParams() : 0;
5828 
5829  CallExpr *TheCall;
5830  if (Config) {
5831  assert(UsesADL == ADLCallKind::NotADL &&
5832  "CUDAKernelCallExpr should not use ADL");
5833  TheCall =
5834  CUDAKernelCallExpr::Create(Context, Fn, cast<CallExpr>(Config), Args,
5835  ResultTy, VK_RValue, RParenLoc, NumParams);
5836  } else {
5837  TheCall = CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue,
5838  RParenLoc, NumParams, UsesADL);
5839  }
5840 
5841  if (!getLangOpts().CPlusPlus) {
5842  // Forget about the nulled arguments since typo correction
5843  // do not handle them well.
5844  TheCall->shrinkNumArgs(Args.size());
5845  // C cannot always handle TypoExpr nodes in builtin calls and direct
5846  // function calls as their argument checking don't necessarily handle
5847  // dependent types properly, so make sure any TypoExprs have been
5848  // dealt with.
5849  ExprResult Result = CorrectDelayedTyposInExpr(TheCall);
5850  if (!Result.isUsable()) return ExprError();
5851  CallExpr *TheOldCall = TheCall;
5852  TheCall = dyn_cast<CallExpr>(Result.get());
5853  bool CorrectedTypos = TheCall != TheOldCall;
5854  if (!TheCall) return Result;
5855  Args = llvm::makeArrayRef(TheCall->getArgs(), TheCall->getNumArgs());
5856 
5857  // A new call expression node was created if some typos were corrected.
5858  // However it may not have been constructed with enough storage. In this
5859  // case, rebuild the node with enough storage. The waste of space is
5860  // immaterial since this only happens when some typos were corrected.
5861  if (CorrectedTypos && Args.size() < NumParams) {
5862  if (Config)
5863  TheCall = CUDAKernelCallExpr::Create(
5864  Context, Fn, cast<CallExpr>(Config), Args, ResultTy, VK_RValue,
5865  RParenLoc, NumParams);
5866  else
5867  TheCall = CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue,
5868  RParenLoc, NumParams, UsesADL);
5869  }
5870  // We can now handle the nulled arguments for the default arguments.
5871  TheCall->setNumArgsUnsafe(std::max<unsigned>(Args.size(), NumParams));
5872  }
5873 
5874  // Bail out early if calling a builtin with custom type checking.
5875  if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID))
5876  return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
5877 
5878  if (getLangOpts().CUDA) {
5879  if (Config) {
5880  // CUDA: Kernel calls must be to global functions
5881  if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>())
5882  return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function)
5883  << FDecl << Fn->getSourceRange());
5884 
5885  // CUDA: Kernel function must have 'void' return type
5886  if (!FuncT->getReturnType()->isVoidType())
5887  return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return)
5888  << Fn->getType() << Fn->getSourceRange());
5889  } else {
5890  // CUDA: Calls to global functions must be configured
5891  if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>())
5892  return ExprError(Diag(LParenLoc, diag::err_global_call_not_config)
5893  << FDecl << Fn->getSourceRange());
5894  }
5895  }
5896 
5897  // Check for a valid return type
5898  if (CheckCallReturnType(FuncT->getReturnType(), Fn->getBeginLoc(), TheCall,
5899  FDecl))
5900  return ExprError();
5901 
5902  // We know the result type of the call, set it.
5903  TheCall->setType(FuncT->getCallResultType(Context));
5905 
5906  if (Proto) {
5907  if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, RParenLoc,
5908  IsExecConfig))
5909  return ExprError();
5910  } else {
5911  assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
5912 
5913  if (FDecl) {
5914  // Check if we have too few/too many template arguments, based
5915  // on our knowledge of the function definition.
5916  const FunctionDecl *Def = nullptr;
5917  if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) {
5918  Proto = Def->getType()->getAs<FunctionProtoType>();
5919  if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size()))
5920  Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
5921  << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange();
5922  }
5923 
5924  // If the function we're calling isn't a function prototype, but we have
5925  // a function prototype from a prior declaratiom, use that prototype.
5926  if (!FDecl->hasPrototype())
5927  Proto = FDecl->getType()->getAs<FunctionProtoType>();
5928  }
5929 
5930  // Promote the arguments (C99 6.5.2.2p6).
5931  for (unsigned i = 0, e = Args.size(); i != e; i++) {
5932  Expr *Arg = Args[i];
5933 
5934  if (Proto && i < Proto->getNumParams()) {
5936  Context, Proto->getParamType(i), Proto->isParamConsumed(i));
5937  ExprResult ArgE =
5938  PerformCopyInitialization(Entity, SourceLocation(), Arg);
5939  if (ArgE.isInvalid())
5940  return true;
5941 
5942  Arg = ArgE.getAs<Expr>();
5943 
5944  } else {
5945  ExprResult ArgE = DefaultArgumentPromotion(Arg);
5946 
5947  if (ArgE.isInvalid())
5948  return true;
5949 
5950  Arg = ArgE.getAs<Expr>();
5951  }
5952 
5953  if (RequireCompleteType(Arg->getBeginLoc(), Arg->getType(),
5954  diag::err_call_incomplete_argument, Arg))
5955  return ExprError();
5956 
5957  TheCall->setArg(i, Arg);
5958  }
5959  }
5960 
5961  if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
5962  if (!Method->isStatic())
5963  return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
5964  << Fn->getSourceRange());
5965 
5966  // Check for sentinels
5967  if (NDecl)
5968  DiagnoseSentinelCalls(NDecl, LParenLoc, Args);
5969 
5970  // Do special checking on direct calls to functions.
5971  if (FDecl) {
5972  if (CheckFunctionCall(FDecl, TheCall, Proto))
5973  return ExprError();
5974 
5975  checkFortifiedBuiltinMemoryFunction(FDecl, TheCall);
5976 
5977  if (BuiltinID)
5978  return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall);
5979  } else if (NDecl) {
5980  if (CheckPointerCall(NDecl, TheCall, Proto))
5981  return ExprError();
5982  } else {
5983  if (CheckOtherCall(TheCall, Proto))
5984  return ExprError();
5985  }
5986 
5987  return MaybeBindToTemporary(TheCall);
5988 }
5989 
5990 ExprResult
5992  SourceLocation RParenLoc, Expr *InitExpr) {
5993  assert(Ty && "ActOnCompoundLiteral(): missing type");
5994  assert(InitExpr && "ActOnCompoundLiteral(): missing expression");
5995 
5996  TypeSourceInfo *TInfo;
5997  QualType literalType = GetTypeFromParser(Ty, &TInfo);
5998  if (!TInfo)
5999  TInfo = Context.getTrivialTypeSourceInfo(literalType);
6000 
6001  return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr);
6002 }
6003 
6004 ExprResult
6006  SourceLocation RParenLoc, Expr *LiteralExpr) {
6007  QualType literalType = TInfo->getType();
6008 
6009  if (literalType->isArrayType()) {
6010  if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType),
6011  diag::err_illegal_decl_array_incomplete_type,
6012  SourceRange(LParenLoc,
6013  LiteralExpr->getSourceRange().getEnd())))
6014  return ExprError();
6015  if (literalType->isVariableArrayType())
6016  return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
6017  << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd()));
6018  } else if (!literalType->isDependentType() &&
6019  RequireCompleteType(LParenLoc, literalType,
6020  diag::err_typecheck_decl_incomplete_type,
6021  SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
6022  return ExprError();
6023 
6024  InitializedEntity Entity
6028  SourceRange(LParenLoc, RParenLoc),
6029  /*InitList=*/true);
6030  InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr);
6031  ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr,
6032  &literalType);
6033  if (Result.isInvalid())
6034  return ExprError();
6035  LiteralExpr = Result.get();
6036 
6037  bool isFileScope = !CurContext->isFunctionOrMethod();
6038 
6039  // In C, compound literals are l-values for some reason.
6040  // For GCC compatibility, in C++, file-scope array compound literals with
6041  // constant initializers are also l-values, and compound literals are
6042  // otherwise prvalues.
6043  //
6044  // (GCC also treats C++ list-initialized file-scope array prvalues with
6045  // constant initializers as l-values, but that's non-conforming, so we don't
6046  // follow it there.)
6047  //
6048  // FIXME: It would be better to handle the lvalue cases as materializing and
6049  // lifetime-extending a temporary object, but our materialized temporaries
6050  // representation only supports lifetime extension from a variable, not "out
6051  // of thin air".
6052  // FIXME: For C++, we might want to instead lifetime-extend only if a pointer
6053  // is bound to the result of applying array-to-pointer decay to the compound
6054  // literal.
6055  // FIXME: GCC supports compound literals of reference type, which should
6056  // obviously have a value kind derived from the kind of reference involved.
6057  ExprValueKind VK =
6058  (getLangOpts().CPlusPlus && !(isFileScope && literalType->isArrayType()))
6059  ? VK_RValue
6060  : VK_LValue;
6061 
6062  if (isFileScope)
6063  if (auto ILE = dyn_cast<InitListExpr>(LiteralExpr))
6064  for (unsigned i = 0, j = ILE->getNumInits(); i != j; i++) {
6065  Expr *Init = ILE->getInit(i);
6066  ILE->setInit(i, ConstantExpr::Create(Context, Init));
6067  }
6068 
6069  auto *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
6070  VK, LiteralExpr, isFileScope);
6071  if (isFileScope) {
6072  if (!LiteralExpr->isTypeDependent() &&
6073  !LiteralExpr->isValueDependent() &&
6074  !literalType->isDependentType()) // C99 6.5.2.5p3
6075  if (CheckForConstantInitializer(LiteralExpr, literalType))
6076  return ExprError();
6077  } else if (literalType.getAddressSpace() != LangAS::opencl_private &&
6078  literalType.getAddressSpace() != LangAS::Default) {
6079  // Embedded-C extensions to C99 6.5.2.5:
6080  // "If the compound literal occurs inside the body of a function, the
6081  // type name shall not be qualified by an address-space qualifier."
6082  Diag(LParenLoc, diag::err_compound_literal_with_address_space)
6083  << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
6084  return ExprError();
6085  }
6086 
6087  // Compound literals that have automatic storage duration are destroyed at
6088  // the end of the scope. Emit diagnostics if it is or contains a C union type
6089  // that is non-trivial to destruct.
6090  if (!isFileScope)
6092  checkNonTrivialCUnion(E->getType(), E->getExprLoc(),
6093  NTCUC_CompoundLiteral, NTCUK_Destruct);
6094 
6097  checkNonTrivialCUnionInInitializer(E->getInitializer(),
6098  E->getInitializer()->getExprLoc());
6099 
6100  return MaybeBindToTemporary(E);
6101 }
6102 
6103 ExprResult
6105  SourceLocation RBraceLoc) {
6106  // Immediately handle non-overload placeholders. Overloads can be
6107  // resolved contextually, but everything else here can't.
6108  for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
6109  if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
6110  ExprResult result = CheckPlaceholderExpr(InitArgList[I]);
6111 
6112  // Ignore failures; dropping the entire initializer list because
6113  // of one failure would be terrible for indexing/etc.
6114  if (result.isInvalid()) continue;
6115 
6116  InitArgList[I] = result.get();
6117  }
6118  }
6119 
6120  // Semantic analysis for initializers is done by ActOnDeclarator() and
6121  // CheckInitializer() - it requires knowledge of the object being initialized.
6122 
6123  InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
6124  RBraceLoc);
6125  E->setType(Context.VoidTy); // FIXME: just a place holder for now.
6126  return E;
6127 }
6128 
6129 /// Do an explicit extend of the given block pointer if we're in ARC.
6131  assert(E.get()->getType()->isBlockPointerType());
6132  assert(E.get()->isRValue());
6133 
6134  // Only do this in an r-value context.
6135  if (!getLangOpts().ObjCAutoRefCount) return;
6136 
6137  E = ImplicitCastExpr::Create(Context, E.get()->getType(),
6138  CK_ARCExtendBlockObject, E.get(),
6139  /*base path*/ nullptr, VK_RValue);
6140  Cleanup.setExprNeedsCleanups(true);
6141 }
6142 
6143 /// Prepare a conversion of the given expression to an ObjC object
6144 /// pointer type.
6146  QualType type = E.get()->getType();
6147  if (type->isObjCObjectPointerType()) {
6148  return CK_BitCast;
6149  } else if (type->isBlockPointerType()) {
6150  maybeExtendBlockObject(E);
6151  return CK_BlockPointerToObjCPointerCast;
6152  } else {
6153  assert(type->isPointerType());
6154  return CK_CPointerToObjCPointerCast;
6155  }
6156 }
6157 
6158 /// Prepares for a scalar cast, performing all the necessary stages
6159 /// except the final cast and returning the kind required.
6161  // Both Src and Dest are scalar types, i.e. arithmetic or pointer.
6162  // Also, callers should have filtered out the invalid cases with
6163  // pointers. Everything else should be possible.
6164 
6165  QualType SrcTy = Src.get()->getType();
6166  if (Context.hasSameUnqualifiedType(SrcTy, DestTy))
6167  return CK_NoOp;
6168 
6169  switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) {
6171  llvm_unreachable("member pointer type in C");
6172 
6173  case Type::STK_CPointer:
6176  switch (DestTy->getScalarTypeKind()) {
6177  case Type::STK_CPointer: {
6178  LangAS SrcAS = SrcTy->getPointeeType().getAddressSpace();
6179  LangAS DestAS = DestTy->getPointeeType().getAddressSpace();
6180  if (SrcAS != DestAS)
6181  return CK_AddressSpaceConversion;
6182  if (Context.hasCvrSimilarType(SrcTy, DestTy))
6183  return CK_NoOp;
6184  return CK_BitCast;
6185  }
6187  return (SrcKind == Type::STK_BlockPointer
6188  ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
6190  if (SrcKind == Type::STK_ObjCObjectPointer)
6191  return CK_BitCast;
6192  if (SrcKind == Type::STK_CPointer)
6193  return CK_CPointerToObjCPointerCast;
6194  maybeExtendBlockObject(Src);
6195  return CK_BlockPointerToObjCPointerCast;
6196  case Type::STK_Bool:
6197  return CK_PointerToBoolean;
6198  case Type::STK_Integral:
6199  return CK_PointerToIntegral;
6200  case Type::STK_Floating:
6204  case Type::STK_FixedPoint:
6205  llvm_unreachable("illegal cast from pointer");
6206  }
6207  llvm_unreachable("Should have returned before this");
6208 
6209  case Type::STK_FixedPoint:
6210  switch (DestTy->getScalarTypeKind()) {
6211  case Type::STK_FixedPoint:
6212  return CK_FixedPointCast;
6213  case Type::STK_Bool:
6214  return CK_FixedPointToBoolean;
6215  case Type::STK_Integral:
6216  return CK_FixedPointToIntegral;
6217  case Type::STK_Floating:
6220  Diag(Src.get()->getExprLoc(),
6221  diag::err_unimplemented_conversion_with_fixed_point_type)
6222  << DestTy;
6223  return CK_IntegralCast;
6224  case Type::STK_CPointer:
6228  llvm_unreachable("illegal cast to pointer type");
6229  }
6230  llvm_unreachable("Should have returned before this");
6231 
6232  case Type::STK_Bool: // casting from bool is like casting from an integer
6233  case Type::STK_Integral:
6234  switch (DestTy->getScalarTypeKind()) {
6235  case Type::STK_CPointer:
6238  if (Src.get()->isNullPointerConstant(Context,
6240  return CK_NullToPointer;
6241  return CK_IntegralToPointer;
6242  case Type::STK_Bool:
6243  return CK_IntegralToBoolean;
6244  case Type::STK_Integral:
6245  return CK_IntegralCast;
6246  case Type::STK_Floating:
6247  return CK_IntegralToFloating;
6249  Src = ImpCastExprToType(Src.get(),
6250  DestTy->castAs<ComplexType>()->getElementType(),
6251  CK_IntegralCast);
6252  return CK_IntegralRealToComplex;
6254  Src = ImpCastExprToType(Src.get(),
6255  DestTy->castAs<ComplexType>()->getElementType(),
6256  CK_IntegralToFloating);
6257  return CK_FloatingRealToComplex;
6259  llvm_unreachable("member pointer type in C");
6260  case Type::STK_FixedPoint:
6261  return CK_IntegralToFixedPoint;
6262  }
6263  llvm_unreachable("Should have returned before this");
6264 
6265  case Type::STK_Floating:
6266  switch (DestTy->getScalarTypeKind()) {
6267  case Type::STK_Floating:
6268  return CK_FloatingCast;
6269  case Type::STK_Bool:
6270  return CK_FloatingToBoolean;
6271  case Type::STK_Integral:
6272  return CK_FloatingToIntegral;
6274  Src = ImpCastExprToType(Src.get(),
6275  DestTy->castAs<ComplexType>()->getElementType(),
6276  CK_FloatingCast);
6277  return CK_FloatingRealToComplex;
6279  Src = ImpCastExprToType(Src.get(),
6280  DestTy->castAs<ComplexType>()->getElementType(),
6281  CK_FloatingToIntegral);
6282  return CK_IntegralRealToComplex;
6283  case Type::STK_CPointer:
6286  llvm_unreachable("valid float->pointer cast?");
6288  llvm_unreachable("member pointer type in C");
6289  case Type::STK_FixedPoint:
6290  Diag(Src.get()->getExprLoc(),
6291  diag::err_unimplemented_conversion_with_fixed_point_type)
6292  << SrcTy;
6293  return CK_IntegralCast;
6294  }
6295  llvm_unreachable("Should have returned before this");
6296 
6298  switch (DestTy->getScalarTypeKind()) {
6300  return CK_FloatingComplexCast;
6302  return CK_FloatingComplexToIntegralComplex;
6303  case Type::STK_Floating: {
6304  QualType ET = SrcTy->castAs<ComplexType>()->getElementType();
6305  if (Context.hasSameType(ET, DestTy))
6306  return CK_FloatingComplexToReal;
6307  Src = ImpCastExprToType(Src.get(), ET, CK_FloatingComplexToReal);
6308  return CK_FloatingCast;
6309  }
6310  case Type::STK_Bool:
6311  return CK_FloatingComplexToBoolean;
6312  case Type::STK_Integral:
6313  Src = ImpCastExprToType(Src.get(),
6314  SrcTy->castAs<ComplexType>()->getElementType(),
6315  CK_FloatingComplexToReal);
6316  return CK_FloatingToIntegral;
6317  case Type::STK_CPointer:
6320  llvm_unreachable("valid complex float->pointer cast?");
6322  llvm_unreachable("member pointer type in C");
6323  case Type::STK_FixedPoint:
6324  Diag(Src.get()->getExprLoc(),
6325  diag::err_unimplemented_conversion_with_fixed_point_type)
6326  << SrcTy;
6327  return CK_IntegralCast;
6328  }
6329  llvm_unreachable("Should have returned before this");
6330 
6332  switch (DestTy->getScalarTypeKind()) {
6334  return CK_IntegralComplexToFloatingComplex;
6336  return CK_IntegralComplexCast;
6337  case Type::STK_Integral: {
6338  QualType ET = SrcTy->castAs<ComplexType>()->getElementType();
6339  if (Context.hasSameType(ET, DestTy))
6340  return CK_IntegralComplexToReal;
6341  Src = ImpCastExprToType(Src.get(), ET, CK_IntegralComplexToReal);
6342  return CK_IntegralCast;
6343  }
6344  case Type::STK_Bool:
6345  return CK_IntegralComplexToBoolean;
6346  case Type::STK_Floating:
6347  Src = ImpCastExprToType(Src.get(),
6348  SrcTy->castAs<ComplexType>()->getElementType(),
6349  CK_IntegralComplexToReal);
6350  return CK_IntegralToFloating;
6351  case Type::STK_CPointer:
6354  llvm_unreachable("valid complex int->pointer cast?");
6356  llvm_unreachable("member pointer type in C");
6357  case Type::STK_FixedPoint:
6358  Diag(Src.get()->getExprLoc(),
6359  diag::err_unimplemented_conversion_with_fixed_point_type)
6360  << SrcTy;
6361  return CK_IntegralCast;
6362  }
6363  llvm_unreachable("Should have returned before this");
6364  }
6365 
6366  llvm_unreachable("Unhandled scalar cast");
6367 }
6368 
6369 static bool breakDownVectorType(QualType type, uint64_t &len,
6370  QualType &eltType) {
6371  // Vectors are simple.
6372  if (const VectorType *vecType = type->getAs<VectorType>()) {
6373  len = vecType->getNumElements();
6374  eltType = vecType->getElementType();
6375  assert(eltType->isScalarType());
6376  return true;
6377  }
6378 
6379  // We allow lax conversion to and from non-vector types, but only if
6380  // they're real types (i.e. non-complex, non-pointer scalar types).
6381  if (!type->isRealType()) return false;
6382 
6383  len = 1;
6384  eltType = type;
6385  return true;
6386 }
6387 
6388 /// Are the two types lax-compatible vector types? That is, given
6389 /// that one of them is a vector, do they have equal storage sizes,
6390 /// where the storage size is the number of elements times the element
6391 /// size?
6392 ///
6393 /// This will also return false if either of the types is neither a
6394 /// vector nor a real type.
6396  assert(destTy->isVectorType() || srcTy->isVectorType());
6397 
6398  // Disallow lax conversions between scalars and ExtVectors (these
6399  // conversions are allowed for other vector types because common headers
6400  // depend on them). Most scalar OP ExtVector cases are handled by the
6401  // splat path anyway, which does what we want (convert, not bitcast).
6402  // What this rules out for ExtVectors is crazy things like char4*float.
6403  if (srcTy->isScalarType() && destTy->isExtVectorType()) return false;
6404  if (destTy->isScalarType() && srcTy->isExtVectorType()) return false;
6405 
6406  uint64_t srcLen, destLen;
6407  QualType srcEltTy, destEltTy;
6408  if (!breakDownVectorType(srcTy, srcLen, srcEltTy)) return false;
6409  if (!breakDownVectorType(destTy, destLen, destEltTy)) return false;
6410 
6411  // ASTContext::getTypeSize will return the size rounded up to a
6412  // power of 2, so instead of using that, we need to use the raw
6413  // element size multiplied by the element count.
6414  uint64_t srcEltSize = Context.getTypeSize(srcEltTy);
6415  uint64_t destEltSize = Context.getTypeSize(destEltTy);
6416 
6417  return (srcLen * srcEltSize == destLen * destEltSize);
6418 }
6419 
6420 /// Is this a legal conversion between two types, one of which is
6421 /// known to be a vector type?
6423  assert(destTy->isVectorType() || srcTy->isVectorType());
6424 
6425  if (!Context.getLangOpts().LaxVectorConversions)
6426  return false;
6427  return areLaxCompatibleVectorTypes(srcTy, destTy);
6428 }
6429 
6431  CastKind &Kind) {
6432  assert(VectorTy->isVectorType() && "Not a vector type!");
6433 
6434  if (Ty->isVectorType() || Ty->isIntegralType(Context)) {
6435  if (!areLaxCompatibleVectorTypes(Ty, VectorTy))
6436  return Diag(R.getBegin(),
6437  Ty->isVectorType() ?
6438  diag::err_invalid_conversion_between_vectors :
6439  diag::err_invalid_conversion_between_vector_and_integer)
6440  << VectorTy << Ty << R;
6441  } else
6442  return Diag(R.getBegin(),
6443  diag::err_invalid_conversion_between_vector_and_scalar)
6444  << VectorTy << Ty << R;
6445 
6446  Kind = CK_BitCast;
6447  return false;
6448 }
6449 
6451  QualType DestElemTy = VectorTy->castAs<VectorType>()->getElementType();
6452 
6453  if (DestElemTy == SplattedExpr->getType())
6454  return SplattedExpr;
6455 
6456  assert(DestElemTy->isFloatingType() ||
6457  DestElemTy->isIntegralOrEnumerationType());
6458 
6459  CastKind CK;
6460  if (VectorTy->isExtVectorType() && SplattedExpr->getType()->isBooleanType()) {
6461  // OpenCL requires that we convert `true` boolean expressions to -1, but
6462  // only when splatting vectors.
6463  if (DestElemTy->isFloatingType()) {
6464  // To avoid having to have a CK_BooleanToSignedFloating cast kind, we cast
6465  // in two steps: boolean to signed integral, then to floating.
6466  ExprResult CastExprRes = ImpCastExprToType(SplattedExpr, Context.IntTy,
6467  CK_BooleanToSignedIntegral);
6468  SplattedExpr = CastExprRes.get();
6469  CK = CK_IntegralToFloating;
6470  } else {
6471  CK = CK_BooleanToSignedIntegral;
6472  }
6473  } else {
6474  ExprResult CastExprRes = SplattedExpr;
6475  CK = PrepareScalarCast(CastExprRes, DestElemTy);
6476  if (CastExprRes.isInvalid())
6477  return ExprError();
6478  SplattedExpr = CastExprRes.get();
6479  }
6480  return ImpCastExprToType(SplattedExpr, DestElemTy, CK);
6481 }
6482 
6484  Expr *CastExpr, CastKind &Kind) {
6485  assert(DestTy->isExtVectorType() && "Not an extended vector type!");
6486 
6487  QualType SrcTy = CastExpr->getType();
6488 
6489  // If SrcTy is a VectorType, the total size must match to explicitly cast to
6490  // an ExtVectorType.
6491  // In OpenCL, casts between vectors of different types are not allowed.
6492  // (See OpenCL 6.2).
6493  if (SrcTy->isVectorType()) {
6494  if (!areLaxCompatibleVectorTypes(SrcTy, DestTy) ||
6495  (getLangOpts().OpenCL &&
6496  !Context.hasSameUnqualifiedType(DestTy, SrcTy))) {
6497  Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
6498  << DestTy << SrcTy << R;
6499  return ExprError();
6500  }
6501  Kind = CK_BitCast;
6502  return CastExpr;
6503  }
6504 
6505  // All non-pointer scalars can be cast to ExtVector type. The appropriate
6506  // conversion will take place first from scalar to elt type, and then
6507  // splat from elt type to vector.
6508  if (SrcTy->isPointerType())
6509  return Diag(R.getBegin(),
6510  diag::err_invalid_conversion_between_vector_and_scalar)
6511  << DestTy << SrcTy << R;
6512 
6513  Kind = CK_VectorSplat;
6514  return prepareVectorSplat(DestTy, CastExpr);
6515 }
6516 
6517 ExprResult
6519  Declarator &D, ParsedType &Ty,
6520  SourceLocation RParenLoc, Expr *CastExpr) {
6521  assert(!D.isInvalidType() && (CastExpr != nullptr) &&
6522  "ActOnCastExpr(): missing type or expr");
6523 
6524  TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType());
6525  if (D.isInvalidType())
6526  return ExprError();
6527 
6528  if (getLangOpts().CPlusPlus) {
6529  // Check that there are no default arguments (C++ only).
6530  CheckExtraCXXDefaultArguments(D);
6531  } else {
6532  // Make sure any TypoExprs have been dealt with.
6533  ExprResult Res = CorrectDelayedTyposInExpr(CastExpr);
6534  if (!Res.isUsable())
6535  return ExprError();
6536  CastExpr = Res.get();
6537  }
6538 
6539  checkUnusedDeclAttributes(D);
6540 
6541  QualType castType = castTInfo->getType();
6542  Ty = CreateParsedType(castType, castTInfo);
6543 
6544  bool isVectorLiteral = false;
6545 
6546  // Check for an altivec or OpenCL literal,
6547  // i.e. all the elements are integer constants.
6548  ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr);
6549  ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr);
6550  if ((getLangOpts().AltiVec || getLangOpts().ZVector || getLangOpts().OpenCL)
6551  && castType->isVectorType() && (PE || PLE)) {
6552  if (PLE && PLE->getNumExprs() == 0) {
6553  Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer);
6554  return ExprError();
6555  }
6556  if (PE || PLE->getNumExprs() == 1) {
6557  Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0));
6558  if (!E->getType()->isVectorType())
6559  isVectorLiteral = true;
6560  }
6561  else
6562  isVectorLiteral = true;
6563  }
6564 
6565  // If this is a vector initializer, '(' type ')' '(' init, ..., init ')'
6566  // then handle it as such.
6567  if (isVectorLiteral)
6568  return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo);
6569 
6570  // If the Expr being casted is a ParenListExpr, handle it specially.
6571  // This is not an AltiVec-style cast, so turn the ParenListExpr into a
6572  // sequence of BinOp comma operators.
6573  if (isa<ParenListExpr>(CastExpr)) {
6574  ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr);
6575  if (Result.isInvalid()) return ExprError();
6576  CastExpr = Result.get();
6577  }
6578 
6579  if (getLangOpts().CPlusPlus && !castType->isVoidType() &&
6580  !getSourceManager().isInSystemMacro(LParenLoc))
6581  Diag(LParenLoc, diag::warn_old_style_cast) << CastExpr->getSourceRange();
6582 
6583  CheckTollFreeBridgeCast(castType, CastExpr);
6584 
6585  CheckObjCBridgeRelatedCast(castType, CastExpr);
6586 
6587  DiscardMisalignedMemberAddress(castType.getTypePtr(), CastExpr);
6588 
6589  return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr);
6590 }
6591 
6593  SourceLocation RParenLoc, Expr *E,
6594  TypeSourceInfo *TInfo) {
6595  assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&
6596  "Expected paren or paren list expression");
6597 
6598  Expr **exprs;
6599  unsigned numExprs;
6600  Expr *subExpr;
6601  SourceLocation LiteralLParenLoc, LiteralRParenLoc;
6602  if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) {
6603  LiteralLParenLoc = PE->getLParenLoc();
6604  LiteralRParenLoc = PE->getRParenLoc();
6605  exprs = PE->getExprs();
6606  numExprs = PE->getNumExprs();
6607  } else { // isa<ParenExpr> by assertion at function entrance
6608  LiteralLParenLoc = cast<ParenExpr>(E)->getLParen();
6609  LiteralRParenLoc = cast<ParenExpr>(E)->getRParen();
6610  subExpr = cast<ParenExpr>(E)->getSubExpr();
6611  exprs = &subExpr;
6612  numExprs = 1;
6613  }
6614 
6615  QualType Ty = TInfo->getType();
6616  assert(Ty->isVectorType() && "Expected vector type");
6617 
6618  SmallVector<Expr *, 8> initExprs;
6619  const VectorType *VTy = Ty->getAs<VectorType>();
6620  unsigned numElems = Ty->getAs<VectorType>()->getNumElements();
6621 
6622  // '(...)' form of vector initialization in AltiVec: the number of
6623  // initializers must be one or must match the size of the vector.
6624  // If a single value is specified in the initializer then it will be
6625  // replicated to all the components of the vector
6626  if (VTy->getVectorKind() == VectorType::AltiVecVector) {
6627  // The number of initializers must be one or must match the size of the
6628  // vector. If a single value is specified in the initializer then it will
6629  // be replicated to all the components of the vector
6630  if (numExprs == 1) {
6631  QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
6632  ExprResult Literal = DefaultLvalueConversion(exprs[0]);
6633  if (Literal.isInvalid())
6634  return ExprError();
6635  Literal = ImpCastExprToType(Literal.get(), ElemTy,
6636  PrepareScalarCast(Literal, ElemTy));
6637  return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
6638  }
6639  else if (numExprs < numElems) {
6640  Diag(E->getExprLoc(),
6641  diag::err_incorrect_number_of_vector_initializers);
6642  return ExprError();
6643  }
6644  else
6645  initExprs.append(exprs, exprs + numExprs);
6646  }
6647  else {
6648  // For OpenCL, when the number of initializers is a single value,
6649  // it will be replicated to all components of the vector.
6650  if (getLangOpts().OpenCL &&
6652  numExprs == 1) {
6653  QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
6654  ExprResult Literal = DefaultLvalueConversion(exprs[0]);
6655  if (Literal.isInvalid())
6656  return ExprError();
6657  Literal = ImpCastExprToType(Literal.get(), ElemTy,
6658  PrepareScalarCast(Literal, ElemTy));
6659  return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
6660  }
6661 
6662  initExprs.append(exprs, exprs + numExprs);
6663  }
6664  // FIXME: This means that pretty-printing the final AST will produce curly
6665  // braces instead of the original commas.
6666  InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc,
6667  initExprs, LiteralRParenLoc);
6668  initE->setType(Ty);
6669  return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE);
6670 }
6671 
6672 /// This is not an AltiVec-style cast or or C++ direct-initialization, so turn
6673 /// the ParenListExpr into a sequence of comma binary operators.
6674 ExprResult
6676  ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr);
6677  if (!E)
6678  return OrigExpr;
6679 
6680  ExprResult Result(E->getExpr(0));
6681 
6682  for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
6683  Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(),
6684  E->getExpr(i));
6685 
6686  if (Result.isInvalid()) return ExprError();
6687 
6688  return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get());
6689 }
6690 
6692  SourceLocation R,
6693  MultiExprArg Val) {
6694  return ParenListExpr::Create(Context, L, Val, R);
6695 }
6696 
6697 /// Emit a specialized diagnostic when one expression is a null pointer
6698 /// constant and the other is not a pointer. Returns true if a diagnostic is
6699 /// emitted.
6701  SourceLocation QuestionLoc) {
6702  Expr *NullExpr = LHSExpr;
6703  Expr *NonPointerExpr = RHSExpr;
6705  NullExpr->isNullPointerConstant(Context,
6707 
6708  if (NullKind == Expr::NPCK_NotNull) {
6709  NullExpr = RHSExpr;
6710  NonPointerExpr = LHSExpr;
6711  NullKind =
6712  NullExpr->isNullPointerConstant(Context,
6714  }
6715 
6716  if (NullKind == Expr::NPCK_NotNull)
6717  return false;
6718 
6719  if (NullKind == Expr::NPCK_ZeroExpression)
6720  return false;
6721 
6722  if (NullKind == Expr::NPCK_ZeroLiteral) {
6723  // In this case, check to make sure that we got here from a "NULL"
6724  // string in the source code.
6725  NullExpr = NullExpr->IgnoreParenImpCasts();
6726  SourceLocation loc = NullExpr->getExprLoc();
6727  if (!findMacroSpelling(loc, "NULL"))
6728  return false;
6729  }
6730 
6731  int DiagType = (NullKind == Expr::NPCK_CXX11_nullptr);
6732  Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
6733  << NonPointerExpr->getType() << DiagType
6734  << NonPointerExpr->getSourceRange();
6735  return true;
6736 }
6737 
6738 /// Return false if the condition expression is valid, true otherwise.
6739 static bool checkCondition(Sema &S, Expr *Cond, SourceLocation QuestionLoc) {
6740  QualType CondTy = Cond->getType();
6741 
6742  // OpenCL v1.1 s6.3.i says the condition cannot be a floating point type.
6743  if (S.getLangOpts().OpenCL && CondTy->isFloatingType()) {
6744  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
6745  << CondTy << Cond->getSourceRange();
6746  return true;
6747  }
6748 
6749  // C99 6.5.15p2
6750  if (CondTy->isScalarType()) return false;
6751 
6752  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
6753  << CondTy << Cond->getSourceRange();
6754  return true;
6755 }
6756 
6757 /// Handle when one or both operands are void type.
6759  ExprResult &RHS) {
6760  Expr *LHSExpr = LHS.get();
6761  Expr *RHSExpr = RHS.get();
6762 
6763  if (!LHSExpr->getType()->isVoidType())
6764  S.Diag(RHSExpr->getBeginLoc(), diag::ext_typecheck_cond_one_void)
6765  << RHSExpr->getSourceRange();
6766  if (!RHSExpr->getType()->isVoidType())
6767  S.Diag(LHSExpr->getBeginLoc(), diag::ext_typecheck_cond_one_void)
6768  << LHSExpr->getSourceRange();
6769  LHS = S.ImpCastExprToType(LHS.get(), S.Context.VoidTy, CK_ToVoid);
6770  RHS = S.ImpCastExprToType(RHS.get(), S.Context.VoidTy, CK_ToVoid);
6771  return S.Context.VoidTy;
6772 }
6773 
6774 /// Return false if the NullExpr can be promoted to PointerTy,
6775 /// true otherwise.
6776 static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr,
6777  QualType PointerTy) {
6778  if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) ||
6779  !NullExpr.get()->isNullPointerConstant(S.Context,
6781  return true;
6782 
6783  NullExpr = S.ImpCastExprToType(NullExpr.get(), PointerTy, CK_NullToPointer);
6784  return false;
6785 }
6786 
6787 /// Checks compatibility between two pointers and return the resulting
6788 /// type.
6790  ExprResult &RHS,
6791  SourceLocation Loc) {
6792  QualType LHSTy = LHS.get()->getType();
6793  QualType RHSTy = RHS.get()->getType();
6794 
6795  if (S.Context.hasSameType(LHSTy, RHSTy)) {
6796  // Two identical pointers types are always compatible.
6797  return LHSTy;
6798  }
6799 
6800  QualType lhptee, rhptee;
6801 
6802  // Get the pointee types.
6803  bool IsBlockPointer = false;
6804  if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) {
6805  lhptee = LHSBTy->getPointeeType();
6806  rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType();
6807  IsBlockPointer = true;
6808  } else {
6809  lhptee = LHSTy->castAs<PointerType>()->getPointeeType();
6810  rhptee = RHSTy->castAs<PointerType>()->getPointeeType();
6811  }
6812 
6813  // C99 6.5.15p6: If both operands are pointers to compatible types or to
6814  // differently qualified versions of compatible types, the result type is
6815  // a pointer to an appropriately qualified version of the composite
6816  // type.
6817 
6818  // Only CVR-qualifiers exist in the standard, and the differently-qualified
6819  // clause doesn't make sense for our extensions. E.g. address space 2 should
6820  // be incompatible with address space 3: they may live on different devices or
6821  // anything.
6822  Qualifiers lhQual = lhptee.getQualifiers();
6823  Qualifiers rhQual = rhptee.getQualifiers();
6824 
6825  LangAS ResultAddrSpace = LangAS::Default;
6826  LangAS LAddrSpace = lhQual.getAddressSpace();
6827  LangAS RAddrSpace = rhQual.getAddressSpace();
6828 
6829  // OpenCL v1.1 s6.5 - Conversion between pointers to distinct address
6830  // spaces is disallowed.
6831  if (lhQual.isAddressSpaceSupersetOf(rhQual))
6832  ResultAddrSpace = LAddrSpace;
6833  else if (rhQual.isAddressSpaceSupersetOf(lhQual))
6834  ResultAddrSpace = RAddrSpace;
6835  else {
6836  S.Diag(Loc, diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
6837  << LHSTy << RHSTy << 2 << LHS.get()->getSourceRange()
6838  << RHS.get()->getSourceRange();
6839  return QualType();
6840  }
6841 
6842  unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers();
6843  auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
6844  lhQual.removeCVRQualifiers();
6845  rhQual.removeCVRQualifiers();
6846 
6847  // OpenCL v2.0 specification doesn't extend compatibility of type qualifiers
6848  // (C99 6.7.3) for address spaces. We assume that the check should behave in
6849  // the same manner as it's defined for CVR qualifiers, so for OpenCL two
6850  // qual types are compatible iff
6851  // * corresponded types are compatible
6852  // * CVR qualifiers are equal
6853  // * address spaces are equal
6854  // Thus for conditional operator we merge CVR and address space unqualified
6855  // pointees and if there is a composite type we return a pointer to it with
6856  // merged qualifiers.
6857  LHSCastKind =
6858  LAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
6859  RHSCastKind =
6860  RAddrSpace == ResultAddrSpace ? CK_BitCast : CK_AddressSpaceConversion;
6861  lhQual.removeAddressSpace();
6862  rhQual.removeAddressSpace();
6863 
6864  lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual);
6865  rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual);
6866 
6867  QualType CompositeTy = S.Context.mergeTypes(lhptee, rhptee);
6868 
6869  if (CompositeTy.isNull()) {
6870  // In this situation, we assume void* type. No especially good
6871  // reason, but this is what gcc does, and we do have to pick
6872  // to get a consistent AST.
6873  QualType incompatTy;
6874  incompatTy = S.Context.getPointerType(
6875  S.Context.getAddrSpaceQualType(S.Context.VoidTy, ResultAddrSpace));
6876  LHS = S.ImpCastExprToType(LHS.get(), incompatTy, LHSCastKind);
6877  RHS = S.ImpCastExprToType(RHS.get(), incompatTy, RHSCastKind);
6878 
6879  // FIXME: For OpenCL the warning emission and cast to void* leaves a room
6880  // for casts between types with incompatible address space qualifiers.
6881  // For the following code the compiler produces casts between global and
6882  // local address spaces of the corresponded innermost pointees:
6883  // local int *global *a;
6884  // global int *global *b;
6885  // a = (0 ? a : b); // see C99 6.5.16.1.p1.
6886  S.Diag(Loc, diag::ext_typecheck_cond_incompatible_pointers)
6887  << LHSTy << RHSTy << LHS.get()->getSourceRange()
6888  << RHS.get()->getSourceRange();
6889 
6890  return incompatTy;
6891  }
6892 
6893  // The pointer types are compatible.
6894  // In case of OpenCL ResultTy should have the address space qualifier
6895  // which is a superset of address spaces of both the 2nd and the 3rd
6896  // operands of the conditional operator.
6897  QualType ResultTy = [&, ResultAddrSpace]() {
6898  if (S.getLangOpts().OpenCL) {
6899  Qualifiers CompositeQuals = CompositeTy.getQualifiers();
6900  CompositeQuals.setAddressSpace(ResultAddrSpace);
6901  return S.Context
6902  .getQualifiedType(CompositeTy.getUnqualifiedType(), CompositeQuals)
6903  .withCVRQualifiers(MergedCVRQual);
6904  }
6905  return CompositeTy.withCVRQualifiers(MergedCVRQual);
6906  }();
6907  if (IsBlockPointer)
6908  ResultTy = S.Context.getBlockPointerType(ResultTy);
6909  else
6910  ResultTy = S.Context.getPointerType(ResultTy);
6911 
6912  LHS = S.ImpCastExprToType(LHS.get(), ResultTy, LHSCastKind);
6913  RHS = S.ImpCastExprToType(RHS.get(), ResultTy, RHSCastKind);
6914  return ResultTy;
6915 }
6916 
6917 /// Return the resulting type when the operands are both block pointers.
6919  ExprResult &LHS,
6920  ExprResult &RHS,
6921  SourceLocation Loc) {
6922  QualType LHSTy = LHS.get()->getType();
6923  QualType RHSTy = RHS.get()->getType();
6924 
6925  if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) {
6926  if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) {
6927  QualType destType = S.Context.getPointerType(S.Context.VoidTy);
6928  LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast);
6929  RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast);
6930  return destType;
6931  }
6932  S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
6933  << LHSTy << RHSTy << LHS.get()->getSourceRange()
6934  << RHS.get()->getSourceRange();
6935  return QualType();
6936  }
6937 
6938  // We have 2 block pointer types.
6939  return checkConditionalPointerCompatibility(S, LHS, RHS, Loc);
6940 }
6941 
6942 /// Return the resulting type when the operands are both pointers.
6943 static QualType
6945  ExprResult &RHS,
6946  SourceLocation Loc) {
6947  // get the pointer types
6948  QualType LHSTy = LHS.get()->getType();
6949  QualType RHSTy = RHS.get()->getType();
6950 
6951  // get the "pointed to" types
6952  QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
6953  QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
6954 
6955  // ignore qualifiers on void (C99 6.5.15p3, clause 6)
6956  if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
6957  // Figure out necessary qualifiers (C99 6.5.15p6)
6958  QualType destPointee
6959  = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers());
6960  QualType destType = S.Context.getPointerType(destPointee);
6961  // Add qualifiers if necessary.
6962  LHS = S.ImpCastExprToType(LHS.get(), destType, CK_NoOp);
6963  // Promote to void*.
6964  RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast);
6965  return destType;
6966  }
6967  if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
6968  QualType destPointee
6969  = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers());
6970  QualType destType = S.Context.getPointerType(destPointee);
6971  // Add qualifiers if necessary.
6972  RHS = S.ImpCastExprToType(RHS.get(), destType, CK_NoOp);
6973  // Promote to void*.
6974  LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast);
6975  return destType;
6976  }
6977 
6978  return checkConditionalPointerCompatibility(S, LHS, RHS, Loc);
6979 }
6980 
6981 /// Return false if the first expression is not an integer and the second
6982 /// expression is not a pointer, true otherwise.
6984  Expr* PointerExpr, SourceLocation Loc,
6985  bool IsIntFirstExpr) {
6986  if (!PointerExpr->getType()->isPointerType() ||
6987  !Int.get()->getType()->isIntegerType())
6988  return false;
6989 
6990  Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
6991  Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
6992 
6993  S.Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
6994  << Expr1->getType() << Expr2->getType()
6995  << Expr1->getSourceRange() << Expr2->getSourceRange();
6996  Int = S.ImpCastExprToType(Int.get(), PointerExpr->getType(),
6997  CK_IntegralToPointer);
6998  return true;
6999 }
7000 
7001 /// Simple conversion between integer and floating point types.
7002 ///
7003 /// Used when handling the OpenCL conditional operator where the
7004 /// condition is a vector while the other operands are scalar.
7005 ///
7006 /// OpenCL v1.1 s6.3.i and s6.11.6 together require that the scalar
7007 /// types are either integer or floating type. Between the two
7008 /// operands, the type with the higher rank is defined as the "result
7009 /// type". The other operand needs to be promoted to the same type. No
7010 /// other type promotion is allowed. We cannot use
7011 /// UsualArithmeticConversions() for this purpose, since it always
7012 /// promotes promotable types.
7014  ExprResult &RHS,
7015  SourceLocation QuestionLoc) {
7017  if (LHS.isInvalid())
7018  return QualType();
7020  if (RHS.isInvalid())
7021  return QualType();
7022 
7023  // For conversion purposes, we ignore any qualifiers.
7024  // For example, "const float" and "float" are equivalent.
7025  QualType LHSType =
7026  S.Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
7027  QualType RHSType =
7028  S.Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
7029 
7030  if (!LHSType->isIntegerType() && !LHSType->isRealFloatingType()) {
7031  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
7032  << LHSType << LHS.get()->getSourceRange();
7033  return QualType();
7034  }
7035 
7036  if (!RHSType->isIntegerType() && !RHSType->isRealFloatingType()) {
7037  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
7038  << RHSType << RHS.get()->getSourceRange();
7039  return QualType();
7040  }
7041 
7042  // If both types are identical, no conversion is needed.
7043  if (LHSType == RHSType)
7044  return LHSType;
7045 
7046  // Now handle "real" floating types (i.e. float, double, long double).
7047  if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
7048  return handleFloatConversion(S, LHS, RHS, LHSType, RHSType,
7049  /*IsCompAssign = */ false);
7050 
7051  // Finally, we have two differing integer types.
7052  return handleIntegerConversion<doIntegralCast, doIntegralCast>
7053  (S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false);
7054 }
7055 
7056 /// Convert scalar operands to a vector that matches the
7057 /// condition in length.
7058 ///
7059 /// Used when handling the OpenCL conditional operator where the
7060 /// condition is a vector while the other operands are scalar.
7061 ///
7062 /// We first compute the "result type" for the scalar operands
7063 /// according to OpenCL v1.1 s6.3.i. Both operands are then converted
7064 /// into a vector of that type where the length matches the condition
7065 /// vector type. s6.11.6 requires that the element types of the result
7066 /// and the condition must have the same number of bits.
7067 static QualType
7069  QualType CondTy, SourceLocation QuestionLoc) {
7070  QualType ResTy = OpenCLArithmeticConversions(S, LHS, RHS, QuestionLoc);
7071  if (ResTy.isNull()) return QualType();
7072 
7073  const VectorType *CV = CondTy->getAs<VectorType>();
7074  assert(CV);
7075 
7076  // Determine the vector result type
7077  unsigned NumElements = CV->getNumElements();
7078  QualType VectorTy = S.Context.getExtVectorType(ResTy, NumElements);
7079 
7080  // Ensure that all types have the same number of bits
7081  if (S.Context.getTypeSize(CV->getElementType())
7082  != S.Context.getTypeSize(ResTy)) {
7083  // Since VectorTy is created internally, it does not pretty print
7084  // with an OpenCL name. Instead, we just print a description.
7085  std::string EleTyName = ResTy.getUnqualifiedType().getAsString();
7086  SmallString<64> Str;
7087  llvm::raw_svector_ostream OS(Str);
7088  OS << "(vector of " << NumElements << " '" << EleTyName << "' values)";
7089  S.Diag(QuestionLoc, diag::err_conditional_vector_element_size)
7090  << CondTy << OS.str();
7091  return QualType();
7092  }
7093 
7094  // Convert operands to the vector result type
7095  LHS = S.ImpCastExprToType(LHS.get(), VectorTy, CK_VectorSplat);
7096  RHS = S.ImpCastExprToType(RHS.get(), VectorTy, CK_VectorSplat);
7097 
7098  return VectorTy;
7099 }
7100 
7101 /// Return false if this is a valid OpenCL condition vector
7102 static bool checkOpenCLConditionVector(Sema &S, Expr *Cond,
7103  SourceLocation QuestionLoc) {
7104  // OpenCL v1.1 s6.11.6 says the elements of the vector must be of
7105  // integral type.
7106  const VectorType *CondTy = Cond->getType()->getAs<VectorType>();
7107  assert(CondTy);
7108  QualType EleTy = CondTy->getElementType();
7109  if (EleTy->isIntegerType()) return false;
7110 
7111  S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
7112  << Cond->getType() << Cond->getSourceRange();
7113  return true;
7114 }
7115 
7116 /// Return false if the vector condition type and the vector
7117 /// result type are compatible.
7118 ///
7119 /// OpenCL v1.1 s6.11.6 requires that both vector types have the same
7120 /// number of elements, and their element types have the same number
7121 /// of bits.
7122 static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy,
7123  SourceLocation QuestionLoc) {
7124  const VectorType *CV = CondTy->getAs<VectorType>();
7125  const VectorType *RV = VecResTy->getAs<VectorType>();
7126  assert(CV && RV);
7127 
7128  if (CV->getNumElements() != RV->getNumElements()) {
7129  S.Diag(QuestionLoc, diag::err_conditional_vector_size)
7130  << CondTy << VecResTy;
7131  return true;
7132  }
7133 
7134  QualType CVE = CV->getElementType();
7135  QualType RVE = RV->getElementType();
7136 
7137  if (S.Context.getTypeSize(CVE) != S.Context.getTypeSize(RVE)) {
7138  S.Diag(QuestionLoc, diag::err_conditional_vector_element_size)
7139  << CondTy << VecResTy;
7140  return true;
7141  }
7142 
7143  return false;
7144 }
7145 
7146 /// Return the resulting type for the conditional operator in
7147 /// OpenCL (aka "ternary selection operator", OpenCL v1.1
7148 /// s6.3.i) when the condition is a vector type.
7149 static QualType
7151  ExprResult &LHS, ExprResult &RHS,
7152  SourceLocation QuestionLoc) {
7153  Cond = S.DefaultFunctionArrayLvalueConversion(Cond.get());
7154  if (Cond.isInvalid())
7155  return QualType();
7156  QualType CondTy = Cond.get()->getType();
7157 
7158  if (checkOpenCLConditionVector(S, Cond.get(), QuestionLoc))
7159  return QualType();
7160 
7161  // If either operand is a vector then find the vector type of the
7162  // result as specified in OpenCL v1.1 s6.3.i.
7163  if (LHS.get()->getType()->isVectorType() ||
7164  RHS.get()->getType()->isVectorType()) {
7165  QualType VecResTy = S.CheckVectorOperands(LHS, RHS, QuestionLoc,
7166  /*isCompAssign*/false,
7167  /*AllowBothBool*/true,
7168  /*AllowBoolConversions*/false);
7169  if (VecResTy.isNull()) return QualType();
7170  // The result type must match the condition type as specified in
7171  // OpenCL v1.1 s6.11.6.
7172  if (checkVectorResult(S, CondTy, VecResTy, QuestionLoc))
7173  return QualType();
7174  return VecResTy;
7175  }
7176 
7177  // Both operands are scalar.
7178  return OpenCLConvertScalarsToVectors(S, LHS, RHS, CondTy, QuestionLoc);
7179 }
7180 
7181 /// Return true if the Expr is block type
7182 static bool checkBlockType(Sema &S, const Expr *E) {
7183  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
7184  QualType Ty = CE->getCallee()->getType();
7185  if (Ty->isBlockPointerType()) {
7186  S.Diag(E->getExprLoc(), diag::err_opencl_ternary_with_block);
7187  return true;
7188  }
7189  }
7190  return false;
7191 }
7192 
7193 /// Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
7194 /// In that case, LHS = cond.
7195 /// C99 6.5.15
7197  ExprResult &RHS, ExprValueKind &VK,
7198  ExprObjectKind &OK,
7199  SourceLocation QuestionLoc) {
7200 
7201  ExprResult LHSResult = CheckPlaceholderExpr(LHS.get());
7202  if (!LHSResult.isUsable()) return QualType();
7203  LHS = LHSResult;
7204 
7205  ExprResult RHSResult = CheckPlaceholderExpr(RHS.get());
7206  if (!RHSResult.isUsable()) return QualType();
7207  RHS = RHSResult;
7208 
7209  // C++ is sufficiently different to merit its own checker.
7210  if (getLangOpts().CPlusPlus)
7211  return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);
7212 
7213  VK = VK_RValue;
7214  OK = OK_Ordinary;
7215 
7216  // The OpenCL operator with a vector condition is sufficiently
7217  // different to merit its own checker.
7218  if (getLangOpts().OpenCL && Cond.get()->getType()->isVectorType())
7219  return OpenCLCheckVectorConditional(*this, Cond, LHS, RHS, QuestionLoc);
7220 
7221  // First, check the condition.
7222  Cond = UsualUnaryConversions(Cond.get());
7223  if (Cond.isInvalid())
7224  return QualType();
7225  if (checkCondition(*this, Cond.get(), QuestionLoc))
7226  return QualType();
7227 
7228  // Now check the two expressions.
7229  if (LHS.get()->getType()->isVectorType() ||
7230  RHS.get()->getType()->isVectorType())
7231  return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false,
7232  /*AllowBothBool*/true,
7233  /*AllowBoolConversions*/false);
7234 
7235  QualType ResTy = UsualArithmeticConversions(LHS, RHS);
7236  if (LHS.isInvalid() || RHS.isInvalid())
7237  return QualType();
7238 
7239  QualType LHSTy = LHS.get()->getType();
7240  QualType RHSTy = RHS.get()->getType();
7241 
7242  // Diagnose attempts to convert between __float128 and long double where
7243  // such conversions currently can't be handled.
7244  if (unsupportedTypeConversion(*this, LHSTy, RHSTy)) {
7245  Diag(QuestionLoc,
7246  diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
7247  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7248  return QualType();
7249  }
7250 
7251  // OpenCL v2.0 s6.12.5 - Blocks cannot be used as expressions of the ternary
7252  // selection operator (?:).
7253  if (getLangOpts().OpenCL &&
7254  (checkBlockType(*this, LHS.get()) | checkBlockType(*this, RHS.get()))) {
7255  return QualType();
7256  }
7257 
7258  // If both operands have arithmetic type, do the usual arithmetic conversions
7259  // to find a common type: C99 6.5.15p3,5.
7260  if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
7261  LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
7262  RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
7263 
7264  return ResTy;
7265  }
7266 
7267  // If both operands are the same structure or union type, the result is that
7268  // type.
7269  if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3
7270  if (const RecordType *RHSRT = RHSTy->getAs<RecordType>())
7271  if (LHSRT->getDecl() == RHSRT->getDecl())
7272  // "If both the operands have structure or union type, the result has
7273  // that type." This implies that CV qualifiers are dropped.
7274  return LHSTy.getUnqualifiedType();
7275  // FIXME: Type of conditional expression must be complete in C mode.
7276  }
7277 
7278  // C99 6.5.15p5: "If both operands have void type, the result has void type."
7279  // The following || allows only one side to be void (a GCC-ism).
7280  if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
7281  return checkConditionalVoidType(*this, LHS, RHS);
7282  }
7283 
7284  // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
7285  // the type of the other operand."
7286  if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy;
7287  if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy;
7288 
7289  // All objective-c pointer type analysis is done here.
7290  QualType compositeType = FindCompositeObjCPointerType(LHS, RHS,
7291  QuestionLoc);
7292  if (LHS.isInvalid() || RHS.isInvalid())
7293  return QualType();
7294  if (!compositeType.isNull())
7295  return compositeType;
7296 
7297 
7298  // Handle block pointer types.
7299  if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType())
7300  return checkConditionalBlockPointerCompatibility(*this, LHS, RHS,
7301  QuestionLoc);
7302 
7303  // Check constraints for C object pointers types (C99 6.5.15p3,6).
7304  if (LHSTy->isPointerType() && RHSTy->isPointerType())
7305  return checkConditionalObjectPointersCompatibility(*this, LHS, RHS,
7306  QuestionLoc);
7307 
7308  // GCC compatibility: soften pointer/integer mismatch. Note that
7309  // null pointers have been filtered out by this point.
7310  if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc,
7311  /*IsIntFirstExpr=*/true))
7312  return RHSTy;
7313  if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc,
7314  /*IsIntFirstExpr=*/false))
7315  return LHSTy;
7316 
7317  // Emit a better diagnostic if one of the expressions is a null pointer
7318  // constant and the other is not a pointer type. In this case, the user most
7319  // likely forgot to take the address of the other expression.
7320  if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
7321  return QualType();
7322 
7323  // Otherwise, the operands are not compatible.
7324  Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
7325  << LHSTy << RHSTy << LHS.get()->getSourceRange()
7326  << RHS.get()->getSourceRange();
7327  return QualType();
7328 }
7329 
7330 /// FindCompositeObjCPointerType - Helper method to find composite type of
7331 /// two objective-c pointer types of the two input expressions.
7333  SourceLocation QuestionLoc) {
7334  QualType LHSTy = LHS.get()->getType();
7335  QualType RHSTy = RHS.get()->getType();
7336 
7337  // Handle things like Class and struct objc_class*. Here we case the result
7338  // to the pseudo-builtin, because that will be implicitly cast back to the
7339  // redefinition type if an attempt is made to access its fields.
7340  if (LHSTy->isObjCClassType() &&
7341  (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) {
7342  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast);
7343  return LHSTy;
7344  }
7345  if (RHSTy->isObjCClassType() &&
7346  (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) {
7347  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast);
7348  return RHSTy;
7349  }
7350  // And the same for struct objc_object* / id
7351  if (LHSTy->isObjCIdType() &&
7352  (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) {
7353  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast);
7354  return LHSTy;
7355  }
7356  if (RHSTy->isObjCIdType() &&
7357  (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) {
7358  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast);
7359  return RHSTy;
7360  }
7361  // And the same for struct objc_selector* / SEL
7362  if (Context.isObjCSelType(LHSTy) &&
7363  (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) {
7364  RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_BitCast);
7365  return LHSTy;
7366  }
7367  if (Context.isObjCSelType(RHSTy) &&
7368  (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) {
7369  LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_BitCast);
7370  return RHSTy;
7371  }
7372  // Check constraints for Objective-C object pointers types.
7373  if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) {
7374 
7375  if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
7376  // Two identical object pointer types are always compatible.
7377  return LHSTy;
7378  }
7379  const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>();
7380  const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>();
7381  QualType compositeType = LHSTy;
7382 
7383  // If both operands are interfaces and either operand can be
7384  // assigned to the other, use that type as the composite
7385  // type. This allows
7386  // xxx ? (A*) a : (B*) b
7387  // where B is a subclass of A.
7388  //
7389  // Additionally, as for assignment, if either type is 'id'
7390  // allow silent coercion. Finally, if the types are
7391  // incompatible then make sure to use 'id' as the composite
7392  // type so the result is acceptable for sending messages to.
7393 
7394  // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
7395  // It could return the composite type.
7396  if (!(compositeType =
7397  Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) {
7398  // Nothing more to do.
7399  } else if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) {
7400  compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy;
7401  } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) {
7402  compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy;
7403  } else if ((LHSTy->isObjCQualifiedIdType() ||
7404  RHSTy->isObjCQualifiedIdType()) &&
7405  Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) {
7406  // Need to handle "id<xx>" explicitly.
7407  // GCC allows qualified id and any Objective-C type to devolve to
7408  // id. Currently localizing to here until clear this should be
7409  // part of ObjCQualifiedIdTypesAreCompatible.
7410  compositeType = Context.getObjCIdType();
7411  } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) {
7412  compositeType = Context.getObjCIdType();
7413  } else {
7414  Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
7415  << LHSTy << RHSTy
7416  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7417  QualType incompatTy = Context.getObjCIdType();
7418  LHS = ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast);
7419  RHS = ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast);
7420  return incompatTy;
7421  }
7422  // The object pointer types are compatible.
7423  LHS = ImpCastExprToType(LHS.get(), compositeType, CK_BitCast);
7424  RHS = ImpCastExprToType(RHS.get(), compositeType, CK_BitCast);
7425  return compositeType;
7426  }
7427  // Check Objective-C object pointer types and 'void *'
7428  if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) {
7429  if (getLangOpts().ObjCAutoRefCount) {
7430  // ARC forbids the implicit conversion of object pointers to 'void *',
7431  // so these types are not compatible.
7432  Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
7433  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7434  LHS = RHS = true;
7435  return QualType();
7436  }
7437  QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
7438  QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
7439  QualType destPointee
7440  = Context.getQualifiedType(lhptee, rhptee.getQualifiers());
7441  QualType destType = Context.getPointerType(destPointee);
7442  // Add qualifiers if necessary.
7443  LHS = ImpCastExprToType(LHS.get(), destType, CK_NoOp);
7444  // Promote to void*.
7445  RHS = ImpCastExprToType(RHS.get(), destType, CK_BitCast);
7446  return destType;
7447  }
7448  if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) {
7449  if (getLangOpts().ObjCAutoRefCount) {
7450  // ARC forbids the implicit conversion of object pointers to 'void *',
7451  // so these types are not compatible.
7452  Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
7453  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7454  LHS = RHS = true;
7455  return QualType();
7456  }
7457  QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
7458  QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
7459  QualType destPointee
7460  = Context.getQualifiedType(rhptee, lhptee.getQualifiers());
7461  QualType destType = Context.getPointerType(destPointee);
7462  // Add qualifiers if necessary.
7463  RHS = ImpCastExprToType(RHS.get(), destType, CK_NoOp);
7464  // Promote to void*.
7465  LHS = ImpCastExprToType(LHS.get(), destType, CK_BitCast);
7466  return destType;
7467  }
7468  return QualType();
7469 }
7470 
7471 /// SuggestParentheses - Emit a note with a fixit hint that wraps
7472 /// ParenRange in parentheses.
7473 static void SuggestParentheses(Sema &Self, SourceLocation Loc,
7474  const PartialDiagnostic &Note,
7475  SourceRange ParenRange) {
7476  SourceLocation EndLoc = Self.getLocForEndOfToken(ParenRange.getEnd());
7477  if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() &&
7478  EndLoc.isValid()) {
7479  Self.Diag(Loc, Note)
7480  << FixItHint::CreateInsertion(ParenRange.getBegin(), "(")
7481  << FixItHint::CreateInsertion(EndLoc, ")");
7482  } else {
7483  // We can't display the parentheses, so just show the bare note.
7484  Self.Diag(Loc, Note) << ParenRange;
7485  }
7486 }
7487 
7489  return BinaryOperator::isAdditiveOp(Opc) ||
7492 }
7493 
7494 /// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary
7495 /// expression, either using a built-in or overloaded operator,
7496 /// and sets *OpCode to the opcode and *RHSExprs to the right-hand side
7497 /// expression.
7499  Expr **RHSExprs) {
7500  // Don't strip parenthesis: we should not warn if E is in parenthesis.
7501  E = E->IgnoreImpCasts();
7502  E = E->IgnoreConversionOperator();
7503  E = E->IgnoreImpCasts();
7504  if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
7505  E = MTE->GetTemporaryExpr();
7506  E = E->IgnoreImpCasts();
7507  }
7508 
7509  // Built-in binary operator.
7510  if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) {
7511  if (IsArithmeticOp(OP->getOpcode())) {
7512  *Opcode = OP->getOpcode();
7513  *RHSExprs = OP->getRHS();
7514  return true;
7515  }
7516  }
7517 
7518  // Overloaded operator.
7519  if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) {
7520  if (Call->getNumArgs() != 2)
7521  return false;
7522 
7523  // Make sure this is really a binary operator that is safe to pass into
7524  // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
7525  OverloadedOperatorKind OO = Call->getOperator();
7526  if (OO < OO_Plus || OO > OO_Arrow ||
7527  OO == OO_PlusPlus || OO == OO_MinusMinus)
7528  return false;
7529 
7531  if (IsArithmeticOp(OpKind)) {
7532  *Opcode = OpKind;
7533  *RHSExprs = Call->getArg(1);
7534  return true;
7535  }
7536  }
7537 
7538  return false;
7539 }
7540 
7541 /// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type
7542 /// or is a logical expression such as (x==y) which has int type, but is
7543 /// commonly interpreted as boolean.
7544 static bool ExprLooksBoolean(Expr *E) {
7545  E = E->IgnoreParenImpCasts();
7546 
7547  if (E->getType()->isBooleanType())
7548  return true;
7549  if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E))
7550  return OP->isComparisonOp() || OP->isLogicalOp();
7551  if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E))
7552  return OP->getOpcode() == UO_LNot;
7553  if (E->getType()->isPointerType())
7554  return true;
7555  // FIXME: What about overloaded operator calls returning "unspecified boolean
7556  // type"s (commonly pointer-to-members)?
7557 
7558  return false;
7559 }
7560 
7561 /// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator
7562 /// and binary operator are mixed in a way that suggests the programmer assumed
7563 /// the conditional operator has higher precedence, for example:
7564 /// "int x = a + someBinaryCondition ? 1 : 2".
7566  SourceLocation OpLoc,
7567  Expr *Condition,
7568  Expr *LHSExpr,
7569  Expr *RHSExpr) {
7570  BinaryOperatorKind CondOpcode;
7571  Expr *CondRHS;
7572 
7573  if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS))
7574  return;
7575  if (!ExprLooksBoolean(CondRHS))
7576  return;
7577 
7578  // The condition is an arithmetic binary expression, with a right-
7579  // hand side that looks boolean, so warn.
7580 
7581  Self.Diag(OpLoc, diag::warn_precedence_conditional)
7582  << Condition->getSourceRange()
7583  << BinaryOperator::getOpcodeStr(CondOpcode);
7584 
7586  Self, OpLoc,
7587  Self.PDiag(diag::note_precedence_silence)
7588  << BinaryOperator::getOpcodeStr(CondOpcode),
7589  SourceRange(Condition->getBeginLoc(), Condition->getEndLoc()));
7590 
7591  SuggestParentheses(Self, OpLoc,
7592  Self.PDiag(diag::note_precedence_conditional_first),
7593  SourceRange(CondRHS->getBeginLoc(), RHSExpr->getEndLoc()));
7594 }
7595 
7596 /// Compute the nullability of a conditional expression.
7598  QualType LHSTy, QualType RHSTy,
7599  ASTContext &Ctx) {
7600  if (!ResTy->isAnyPointerType())
7601  return ResTy;
7602 
7603  auto GetNullability = [&Ctx](QualType Ty) {
7604  Optional<NullabilityKind> Kind = Ty->getNullability(Ctx);
7605  if (Kind)
7606  return *Kind;
7608  };
7609 
7610  auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
7611  NullabilityKind MergedKind;
7612 
7613  // Compute nullability of a binary conditional expression.
7614  if (IsBin) {
7615  if (LHSKind == NullabilityKind::NonNull)
7616  MergedKind = NullabilityKind::NonNull;
7617  else
7618  MergedKind = RHSKind;
7619  // Compute nullability of a normal conditional expression.
7620  } else {
7621  if (LHSKind == NullabilityKind::Nullable ||
7622  RHSKind == NullabilityKind::Nullable)
7623  MergedKind = NullabilityKind::Nullable;
7624  else if (LHSKind == NullabilityKind::NonNull)
7625  MergedKind = RHSKind;
7626  else if (RHSKind == NullabilityKind::NonNull)
7627  MergedKind = LHSKind;
7628  else
7629  MergedKind = NullabilityKind::Unspecified;
7630  }
7631 
7632  // Return if ResTy already has the correct nullability.
7633  if (GetNullability(ResTy) == MergedKind)
7634  return ResTy;
7635 
7636  // Strip all nullability from ResTy.
7637  while (ResTy->getNullability(Ctx))
7638  ResTy = ResTy.getSingleStepDesugaredType(Ctx);
7639 
7640  // Create a new AttributedType with the new nullability kind.
7641  auto NewAttr = AttributedType::getNullabilityAttrKind(MergedKind);
7642  return Ctx.getAttributedType(NewAttr, ResTy, ResTy);
7643 }
7644 
7645 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
7646 /// in the case of a the GNU conditional expr extension.
7649  Expr *CondExpr, Expr *LHSExpr,
7650  Expr *RHSExpr) {
7651  if (!getLangOpts().CPlusPlus) {
7652  // C cannot handle TypoExpr nodes in the condition because it
7653  // doesn't handle dependent types properly, so make sure any TypoExprs have
7654  // been dealt with before checking the operands.
7655  ExprResult CondResult = CorrectDelayedTyposInExpr(CondExpr);
7656  ExprResult LHSResult = CorrectDelayedTyposInExpr(LHSExpr);
7657  ExprResult RHSResult = CorrectDelayedTyposInExpr(RHSExpr);
7658 
7659  if (!CondResult.isUsable())
7660  return ExprError();
7661 
7662  if (LHSExpr) {
7663  if (!LHSResult.isUsable())
7664  return ExprError();
7665  }
7666 
7667  if (!RHSResult.isUsable())
7668  return ExprError();
7669 
7670  CondExpr = CondResult.get();
7671  LHSExpr = LHSResult.get();
7672  RHSExpr = RHSResult.get();
7673  }
7674 
7675  // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
7676  // was the condition.
7677  OpaqueValueExpr *opaqueValue = nullptr;
7678  Expr *commonExpr = nullptr;
7679  if (!LHSExpr) {
7680  commonExpr = CondExpr;
7681  // Lower out placeholder types first. This is important so that we don't
7682  // try to capture a placeholder. This happens in few cases in C++; such
7683  // as Objective-C++'s dictionary subscripting syntax.
7684  if (commonExpr->hasPlaceholderType()) {
7685  ExprResult result = CheckPlaceholderExpr(commonExpr);
7686  if (!result.isUsable()) return ExprError();
7687  commonExpr = result.get();
7688  }
7689  // We usually want to apply unary conversions *before* saving, except
7690  // in the special case of a C++ l-value conditional.
7691  if (!(getLangOpts().CPlusPlus
7692  && !commonExpr->isTypeDependent()
7693  && commonExpr->getValueKind() == RHSExpr->getValueKind()
7694  && commonExpr->isGLValue()
7695  && commonExpr->isOrdinaryOrBitFieldObject()
7696  && RHSExpr->isOrdinaryOrBitFieldObject()
7697  && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) {
7698  ExprResult commonRes = UsualUnaryConversions(commonExpr);
7699  if (commonRes.isInvalid())
7700  return ExprError();
7701  commonExpr = commonRes.get();
7702  }
7703 
7704  // If the common expression is a class or array prvalue, materialize it
7705  // so that we can safely refer to it multiple times.
7706  if (commonExpr->isRValue() && (commonExpr->getType()->isRecordType() ||
7707  commonExpr->getType()->isArrayType())) {
7708  ExprResult MatExpr = TemporaryMaterializationConversion(commonExpr);
7709  if (MatExpr.isInvalid())
7710  return ExprError();
7711  commonExpr = MatExpr.get();
7712  }
7713 
7714  opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(),
7715  commonExpr->getType(),
7716  commonExpr->getValueKind(),
7717  commonExpr->getObjectKind(),
7718  commonExpr);
7719  LHSExpr = CondExpr = opaqueValue;
7720  }
7721 
7722  QualType LHSTy = LHSExpr->getType(), RHSTy = RHSExpr->getType();
7723  ExprValueKind VK = VK_RValue;
7725  ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
7726  QualType result = CheckConditionalOperands(Cond, LHS, RHS,
7727  VK, OK, QuestionLoc);
7728  if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() ||
7729  RHS.isInvalid())
7730  return ExprError();
7731 
7732  DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(),
7733  RHS.get());
7734 
7735  CheckBoolLikeConversion(Cond.get(), QuestionLoc);
7736 
7737  result = computeConditionalNullability(result, commonExpr, LHSTy, RHSTy,
7738  Context);
7739 
7740  if (!commonExpr)
7741  return new (Context)
7742  ConditionalOperator(Cond.get(), QuestionLoc, LHS.get(), ColonLoc,
7743  RHS.get(), result, VK, OK);
7744 
7745  return new (Context) BinaryConditionalOperator(
7746  commonExpr, opaqueValue, Cond.get(), LHS.get(), RHS.get(), QuestionLoc,
7747  ColonLoc, result, VK, OK);
7748 }
7749 
7750 // checkPointerTypesForAssignment - This is a very tricky routine (despite
7751 // being closely modeled after the C99 spec:-). The odd characteristic of this
7752 // routine is it effectively iqnores the qualifiers on the top level pointee.
7753 // This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
7754 // FIXME: add a couple examples in this comment.
7757  assert(LHSType.isCanonical() && "LHS not canonicalized!");
7758  assert(RHSType.isCanonical() && "RHS not canonicalized!");
7759 
7760  // get the "pointed to" type (ignoring qualifiers at the top level)
7761  const Type *lhptee, *rhptee;
7762  Qualifiers lhq, rhq;
7763  std::tie(lhptee, lhq) =
7764  cast<PointerType>(LHSType)->getPointeeType().split().asPair();
7765  std::tie(rhptee, rhq) =
7766  cast<PointerType>(RHSType)->getPointeeType().split().asPair();
7767 
7769 
7770  // C99 6.5.16.1p1: This following citation is common to constraints
7771  // 3 & 4 (below). ...and the type *pointed to* by the left has all the
7772  // qualifiers of the type *pointed to* by the right;
7773 
7774  // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay.
7775  if (lhq.getObjCLifetime() != rhq.getObjCLifetime() &&
7776  lhq.compatiblyIncludesObjCLifetime(rhq)) {
7777  // Ignore lifetime for further calculation.
7778  lhq.removeObjCLifetime();
7779  rhq.removeObjCLifetime();
7780  }
7781 
7782  if (!lhq.compatiblyIncludes(rhq)) {
7783  // Treat address-space mismatches as fatal.
7784  if (!lhq.isAddressSpaceSupersetOf(rhq))
7786 
7787  // It's okay to add or remove GC or lifetime qualifiers when converting to
7788  // and from void*.
7789  else if (lhq.withoutObjCGCAttr().withoutObjCLifetime()
7792  && (lhptee->isVoidType() || rhptee->isVoidType()))
7793  ; // keep old
7794 
7795  // Treat lifetime mismatches as fatal.
7796  else if (lhq.getObjCLifetime() != rhq.getObjCLifetime())
7798 
7799  // For GCC/MS compatibility, other qualifier mismatches are treated
7800  // as still compatible in C.
7802  }
7803 
7804  // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
7805  // incomplete type and the other is a pointer to a qualified or unqualified
7806  // version of void...
7807  if (lhptee->isVoidType()) {
7808  if (rhptee->isIncompleteOrObjectType())
7809  return ConvTy;
7810 
7811  // As an extension, we allow cast to/from void* to function pointer.
7812  assert(rhptee->isFunctionType());
7814  }
7815 
7816  if (rhptee->isVoidType()) {
7817  if (lhptee->isIncompleteOrObjectType())
7818  return ConvTy;
7819 
7820  // As an extension, we allow cast to/from void* to function pointer.
7821  assert(lhptee->isFunctionType());
7823  }
7824 
7825  // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
7826  // unqualified versions of compatible types, ...
7827  QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0);
7828  if (!S.Context.typesAreCompatible(ltrans, rtrans)) {
7829  // Check if the pointee types are compatible ignoring the sign.
7830  // We explicitly check for char so that we catch "char" vs
7831  // "unsigned char" on systems where "char" is unsigned.
7832  if (lhptee->isCharType())
7833  ltrans = S.Context.UnsignedCharTy;
7834  else if (lhptee->hasSignedIntegerRepresentation())
7835  ltrans = S.Context.getCorrespondingUnsignedType(ltrans);
7836 
7837  if (rhptee->isCharType())
7838  rtrans = S.Context.UnsignedCharTy;
7839  else if (rhptee->hasSignedIntegerRepresentation())
7840  rtrans = S.Context.getCorrespondingUnsignedType(rtrans);
7841 
7842  if (ltrans == rtrans) {
7843  // Types are compatible ignoring the sign. Qualifier incompatibility
7844  // takes priority over sign incompatibility because the sign
7845  // warning can be disabled.
7846  if (ConvTy != Sema::Compatible)
7847  return ConvTy;
7848 
7850  }
7851 
7852  // If we are a multi-level pointer, it's possible that our issue is simply
7853  // one of qualification - e.g. char ** -> const char ** is not allowed. If
7854  // the eventual target type is the same and the pointers have the same
7855  // level of indirection, this must be the issue.
7856  if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
7857  do {
7858  std::tie(lhptee, lhq) =
7859  cast<PointerType>(lhptee)->getPointeeType().split().asPair();
7860  std::tie(rhptee, rhq) =
7861  cast<PointerType>(rhptee)->getPointeeType().split().asPair();
7862 
7863  // Inconsistent address spaces at this point is invalid, even if the
7864  // address spaces would be compatible.
7865  // FIXME: This doesn't catch address space mismatches for pointers of
7866  // different nesting levels, like:
7867  // __local int *** a;
7868  // int ** b = a;
7869  // It's not clear how to actually determine when such pointers are
7870  // invalidly incompatible.
7871  if (lhq.getAddressSpace() != rhq.getAddressSpace())
7873 
7874  } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
7875 
7876  if (lhptee == rhptee)
7878  }
7879 
7880  // General pointer incompatibility takes priority over qualifiers.
7882  }
7883  if (!S.getLangOpts().CPlusPlus &&
7884  S.IsFunctionConversion(ltrans, rtrans, ltrans))
7886  return ConvTy;
7887 }
7888 
7889 /// checkBlockPointerTypesForAssignment - This routine determines whether two
7890 /// block pointer types are compatible or whether a block and normal pointer
7891 /// are compatible. It is more restrict than comparing two function pointer
7892 // types.
7895  QualType RHSType) {
7896  assert(LHSType.isCanonical() && "LHS not canonicalized!");
7897  assert(RHSType.isCanonical() && "RHS not canonicalized!");
7898 
7899  QualType lhptee, rhptee;
7900 
7901  // get the "pointed to" type (ignoring qualifiers at the top level)
7902  lhptee = cast<BlockPointerType>(LHSType)->getPointeeType();
7903  rhptee = cast<BlockPointerType>(RHSType)->getPointeeType();
7904 
7905  // In C++, the types have to match exactly.
7906  if (S.getLangOpts().CPlusPlus)
7908 
7910 
7911  // For blocks we enforce that qualifiers are identical.
7912  Qualifiers LQuals = lhptee.getLocalQualifiers();
7913  Qualifiers RQuals = rhptee.getLocalQualifiers();
7914  if (S.getLangOpts().OpenCL) {
7915  LQuals.removeAddressSpace();
7916  RQuals.removeAddressSpace();
7917  }
7918  if (LQuals != RQuals)
7920 
7921  // FIXME: OpenCL doesn't define the exact compile time semantics for a block
7922  // assignment.
7923  // The current behavior is similar to C++ lambdas. A block might be
7924  // assigned to a variable iff its return type and parameters are compatible
7925  // (C99 6.2.7) with the corresponding return type and parameters of the LHS of
7926  // an assignment. Presumably it should behave in way that a function pointer
7927  // assignment does in C, so for each parameter and return type:
7928  // * CVR and address space of LHS should be a superset of CVR and address
7929  // space of RHS.
7930  // * unqualified types should be compatible.
7931  if (S.getLangOpts().OpenCL) {
7933  S.Context.getQualifiedType(LHSType.getUnqualifiedType(), LQuals),
7934  S.Context.getQualifiedType(RHSType.getUnqualifiedType(), RQuals)))
7936  } else if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType))
7938 
7939  return ConvTy;
7940 }
7941 
7942 /// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types
7943 /// for assignment compatibility.
7946  QualType RHSType) {
7947  assert(LHSType.isCanonical() && "LHS was not canonicalized!");
7948  assert(RHSType.isCanonical() && "RHS was not canonicalized!");
7949 
7950  if (LHSType->isObjCBuiltinType()) {
7951  // Class is not compatible with ObjC object pointers.
7952  if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() &&
7953  !RHSType->isObjCQualifiedClassType())
7955  return Sema::Compatible;
7956  }
7957  if (RHSType->isObjCBuiltinType()) {
7958  if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() &&
7959  !LHSType->isObjCQualifiedClassType())
7961  return Sema::Compatible;
7962  }
7963  QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType();
7964  QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType();
7965 
7966  if (!lhptee.isAtLeastAsQualifiedAs(rhptee) &&
7967  // make an exception for id<P>
7968  !LHSType->isObjCQualifiedIdType())
7970 
7971  if (S.Context.typesAreCompatible(LHSType, RHSType))
7972  return Sema::Compatible;
7973  if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType())
7976 }
7977 
7980  QualType LHSType, QualType RHSType) {
7981  // Fake up an opaque expression. We don't actually care about what
7982  // cast operations are required, so if CheckAssignmentConstraints
7983  // adds casts to this they'll be wasted, but fortunately that doesn't
7984  // usually happen on valid code.
7985  OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue);
7986  ExprResult RHSPtr = &RHSExpr;
7987  CastKind K;
7988 
7989  return CheckAssignmentConstraints(LHSType, RHSPtr, K, /*ConvertRHS=*/false);
7990 }
7991 
7992 /// This helper function returns true if QT is a vector type that has element
7993 /// type ElementType.
7994 static bool isVector(QualType QT, QualType ElementType) {
7995  if (const VectorType *VT = QT->getAs<VectorType>())
7996  return VT->getElementType() == ElementType;
7997  return false;
7998 }
7999 
8000 /// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
8001 /// has code to accommodate several GCC extensions when type checking
8002 /// pointers. Here are some objectionable examples that GCC considers warnings:
8003 ///
8004 /// int a, *pint;
8005 /// short *pshort;
8006 /// struct foo *pfoo;
8007 ///
8008 /// pint = pshort; // warning: assignment from incompatible pointer type
8009 /// a = pint; // warning: assignment makes integer from pointer without a cast
8010 /// pint = a; // warning: assignment makes pointer from integer without a cast
8011 /// pint = pfoo; // warning: assignment from incompatible pointer type
8012 ///
8013 /// As a result, the code for dealing with pointers is more complex than the
8014 /// C99 spec dictates.
8015 ///
8016 /// Sets 'Kind' for any result kind except Incompatible.
8019  CastKind &Kind, bool ConvertRHS) {
8020  QualType RHSType = RHS.get()->getType();
8021  QualType OrigLHSType = LHSType;
8022 
8023  // Get canonical types. We're not formatting these types, just comparing
8024  // them.
8025  LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType();
8026  RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType();
8027 
8028  // Common case: no conversion required.
8029  if (LHSType == RHSType) {
8030  Kind = CK_NoOp;
8031  return Compatible;
8032  }
8033 
8034  // If we have an atomic type, try a non-atomic assignment, then just add an
8035  // atomic qualification step.
8036  if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
8038  CheckAssignmentConstraints(AtomicTy->getValueType(), RHS, Kind);
8039  if (result != Compatible)
8040  return result;
8041  if (Kind != CK_NoOp && ConvertRHS)
8042  RHS = ImpCastExprToType(RHS.get(), AtomicTy->getValueType(), Kind);
8043  Kind = CK_NonAtomicToAtomic;
8044  return Compatible;
8045  }
8046 
8047  // If the left-hand side is a reference type, then we are in a
8048  // (rare!) case where we've allowed the use of references in C,
8049  // e.g., as a parameter type in a built-in function. In this case,
8050  // just make sure that the type referenced is compatible with the
8051  // right-hand side type. The caller is responsible for adjusting
8052  // LHSType so that the resulting expression does not have reference
8053  // type.
8054  if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) {
8055  if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) {
8056  Kind = CK_LValueBitCast;
8057  return Compatible;
8058  }
8059  return Incompatible;
8060  }
8061 
8062  // Allow scalar to ExtVector assignments, and assignments of an ExtVector type
8063  // to the same ExtVector type.
8064  if (LHSType->isExtVectorType()) {
8065  if (RHSType->isExtVectorType())
8066  return Incompatible;
8067  if (RHSType->isArithmeticType()) {
8068  // CK_VectorSplat does T -> vector T, so first cast to the element type.
8069  if (ConvertRHS)
8070  RHS = prepareVectorSplat(LHSType, RHS.get());
8071  Kind = CK_VectorSplat;
8072  return Compatible;
8073  }
8074  }
8075 
8076  // Conversions to or from vector type.
8077  if (LHSType->isVectorType() || RHSType->isVectorType()) {
8078  if (LHSType->isVectorType() && RHSType->isVectorType()) {
8079  // Allow assignments of an AltiVec vector type to an equivalent GCC
8080  // vector type and vice versa
8081  if (Context.areCompatibleVectorTypes(LHSType, RHSType)) {
8082  Kind = CK_BitCast;
8083  return Compatible;
8084  }
8085 
8086  // If we are allowing lax vector conversions, and LHS and RHS are both
8087  // vectors, the total size only needs to be the same. This is a bitcast;
8088  // no bits are changed but the result type is different.
8089  if (isLaxVectorConversion(RHSType, LHSType)) {
8090  Kind = CK_BitCast;
8091  return IncompatibleVectors;
8092  }
8093  }
8094 
8095  // When the RHS comes from another lax conversion (e.g. binops between
8096  // scalars and vectors) the result is canonicalized as a vector. When the
8097  // LHS is also a vector, the lax is allowed by the condition above. Handle
8098  // the case where LHS is a scalar.
8099  if (LHSType->isScalarType()) {
8100  const VectorType *VecType = RHSType->getAs<VectorType>();
8101  if (VecType && VecType->getNumElements() == 1 &&
8102  isLaxVectorConversion(RHSType, LHSType)) {
8103  ExprResult *VecExpr = &RHS;
8104  *VecExpr = ImpCastExprToType(VecExpr->get(), LHSType, CK_BitCast);
8105  Kind = CK_BitCast;
8106  return Compatible;
8107  }
8108  }
8109 
8110  return Incompatible;
8111  }
8112 
8113  // Diagnose attempts to convert between __float128 and long double where
8114  // such conversions currently can't be handled.
8115  if (unsupportedTypeConversion(*this, LHSType, RHSType))
8116  return Incompatible;
8117 
8118  // Disallow assigning a _Complex to a real type in C++ mode since it simply
8119  // discards the imaginary part.
8120  if (getLangOpts().CPlusPlus && RHSType->getAs<ComplexType>() &&
8121  !LHSType->getAs<ComplexType>())
8122  return Incompatible;
8123 
8124  // Arithmetic conversions.
8125  if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
8126  !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) {
8127  if (ConvertRHS)
8128  Kind = PrepareScalarCast(RHS, LHSType);
8129  return Compatible;
8130  }
8131 
8132  // Conversions to normal pointers.
8133  if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
8134  // U* -> T*
8135  if (isa<PointerType>(RHSType)) {
8136  LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
8137  LangAS AddrSpaceR = RHSType->getPointeeType().getAddressSpace();
8138  if (AddrSpaceL != AddrSpaceR)
8139  Kind = CK_AddressSpaceConversion;
8140  else if (Context.hasCvrSimilarType(RHSType, LHSType))
8141  Kind = CK_NoOp;
8142  else
8143  Kind = CK_BitCast;
8144  return checkPointerTypesForAssignment(*this, LHSType, RHSType);
8145  }
8146 
8147  // int -> T*
8148  if (RHSType->isIntegerType()) {
8149  Kind = CK_IntegralToPointer; // FIXME: null?
8150  return IntToPointer;
8151  }
8152 
8153  // C pointers are not compatible with ObjC object pointers,
8154  // with two exceptions:
8155  if (isa<ObjCObjectPointerType>(RHSType)) {
8156  // - conversions to void*
8157  if (LHSPointer->getPointeeType()->isVoidType()) {
8158  Kind = CK_BitCast;
8159  return Compatible;
8160  }
8161 
8162  // - conversions from 'Class' to the redefinition type
8163  if (RHSType->isObjCClassType() &&
8164  Context.hasSameType(LHSType,
8165  Context.getObjCClassRedefinitionType())) {
8166  Kind = CK_BitCast;
8167  return Compatible;
8168  }
8169 
8170  Kind = CK_BitCast;
8171  return IncompatiblePointer;
8172  }
8173 
8174  // U^ -> void*
8175  if (RHSType->getAs<BlockPointerType>()) {
8176  if (LHSPointer->getPointeeType()->isVoidType()) {
8177  LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
8178  LangAS AddrSpaceR = RHSType->getAs<BlockPointerType>()
8179  ->getPointeeType()
8180  .getAddressSpace();
8181  Kind =
8182  AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
8183  return Compatible;
8184  }
8185  }
8186 
8187  return Incompatible;
8188  }
8189 
8190  // Conversions to block pointers.
8191  if (isa<BlockPointerType>(LHSType)) {
8192  // U^ -> T^
8193  if (RHSType->isBlockPointerType()) {
8194  LangAS AddrSpaceL = LHSType->getAs<BlockPointerType>()
8195  ->getPointeeType()
8196  .getAddressSpace();
8197  LangAS AddrSpaceR = RHSType->getAs<BlockPointerType>()
8198  ->getPointeeType()
8199  .getAddressSpace();
8200  Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
8201  return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType);
8202  }
8203 
8204  // int or null -> T^
8205  if (RHSType->isIntegerType()) {
8206  Kind = CK_IntegralToPointer; // FIXME: null
8207  return IntToBlockPointer;
8208  }
8209 
8210  // id -> T^
8211  if (getLangOpts().ObjC && RHSType->isObjCIdType()) {
8212  Kind = CK_AnyPointerToBlockPointerCast;
8213  return Compatible;
8214  }
8215 
8216  // void* -> T^
8217  if (const PointerType *RHSPT = RHSType->getAs<PointerType>())
8218  if (RHSPT->getPointeeType()->isVoidType()) {
8219  Kind = CK_AnyPointerToBlockPointerCast;
8220  return Compatible;
8221  }
8222 
8223  return Incompatible;
8224  }
8225 
8226  // Conversions to Objective-C pointers.
8227  if (isa<ObjCObjectPointerType>(LHSType)) {
8228  // A* -> B*
8229  if (RHSType->isObjCObjectPointerType()) {
8230  Kind = CK_BitCast;
8232  checkObjCPointerTypesForAssignment(*this, LHSType, RHSType);
8233  if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
8234  result == Compatible &&
8235  !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
8236  result = IncompatibleObjCWeakRef;
8237  return result;
8238  }
8239 
8240  // int or null -> A*
8241  if (RHSType->isIntegerType()) {
8242  Kind = CK_IntegralToPointer; // FIXME: null
8243  return IntToPointer;
8244  }
8245 
8246  // In general, C pointers are not compatible with ObjC object pointers,
8247  // with two exceptions:
8248  if (isa<PointerType>(RHSType)) {
8249  Kind = CK_CPointerToObjCPointerCast;
8250 
8251  // - conversions from 'void*'
8252  if (RHSType->isVoidPointerType()) {
8253  return Compatible;
8254  }
8255 
8256  // - conversions to 'Class' from its redefinition type
8257  if (LHSType->isObjCClassType() &&
8258  Context.hasSameType(RHSType,
8259  Context.getObjCClassRedefinitionType())) {
8260  return Compatible;
8261  }
8262 
8263  return IncompatiblePointer;
8264  }
8265 
8266  // Only under strict condition T^ is compatible with an Objective-C pointer.
8267  if (RHSType->isBlockPointerType() &&
8268  LHSType->isBlockCompatibleObjCPointerType(Context)) {
8269  if (ConvertRHS)
8270  maybeExtendBlockObject(RHS);
8271  Kind = CK_BlockPointerToObjCPointerCast;
8272  return Compatible;
8273  }
8274 
8275  return Incompatible;
8276  }
8277 
8278  // Conversions from pointers that are not covered by the above.
8279  if (isa<PointerType>(RHSType)) {
8280  // T* -> _Bool
8281  if (LHSType == Context.BoolTy) {
8282  Kind = CK_PointerToBoolean;
8283  return Compatible;
8284  }
8285 
8286  // T* -> int
8287  if (LHSType->isIntegerType()) {
8288  Kind = CK_PointerToIntegral;
8289  return PointerToInt;
8290  }
8291 
8292  return Incompatible;
8293  }
8294 
8295  // Conversions from Objective-C pointers that are not covered by the above.
8296  if (isa<ObjCObjectPointerType>(RHSType)) {
8297  // T* -> _Bool
8298  if (LHSType == Context.BoolTy) {
8299  Kind = CK_PointerToBoolean;
8300  return Compatible;
8301  }
8302 
8303  // T* -> int
8304  if (LHSType->isIntegerType()) {
8305  Kind = CK_PointerToIntegral;
8306  return PointerToInt;
8307  }
8308 
8309  return Incompatible;
8310  }
8311 
8312  // struct A -> struct B
8313  if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
8314  if (Context.typesAreCompatible(LHSType, RHSType)) {
8315  Kind = CK_NoOp;
8316  return Compatible;
8317  }
8318  }
8319 
8320  if (LHSType->isSamplerT() && RHSType->isIntegerType()) {
8321  Kind = CK_IntToOCLSampler;
8322  return Compatible;
8323  }
8324 
8325  return Incompatible;
8326 }
8327 
8328 /// Constructs a transparent union from an expression that is
8329 /// used to initialize the transparent union.
8331  ExprResult &EResult, QualType UnionType,
8332  FieldDecl *Field) {
8333  // Build an initializer list that designates the appropriate member
8334  // of the transparent union.
8335  Expr *E = EResult.get();
8337  E, SourceLocation());
8338  Initializer->setType(UnionType);
8339  Initializer->setInitializedFieldInUnion(Field);
8340 
8341  // Build a compound literal constructing a value of the transparent
8342  // union type from this initializer list.
8343  TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType);
8344  EResult = new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType,
8345  VK_RValue, Initializer, false);
8346 }
8347 
8350  ExprResult &RHS) {
8351  QualType RHSType = RHS.get()->getType();
8352 
8353  // If the ArgType is a Union type, we want to handle a potential
8354  // transparent_union GCC extension.
8355  const RecordType *UT = ArgType->getAsUnionType();
8356  if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
8357  return Incompatible;
8358 
8359  // The field to initialize within the transparent union.
8360  RecordDecl *UD = UT->getDecl();
8361  FieldDecl *InitField = nullptr;
8362  // It's compatible if the expression matches any of the fields.
8363  for (auto *it : UD->fields()) {
8364  if (it->getType()->isPointerType()) {
8365  // If the transparent union contains a pointer type, we allow:
8366  // 1) void pointer
8367  // 2) null pointer constant
8368  if (RHSType->isPointerType())
8369  if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
8370  RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_BitCast);
8371  InitField = it;
8372  break;
8373  }
8374 
8375  if (RHS.get()->isNullPointerConstant(Context,
8377  RHS = ImpCastExprToType(RHS.get(), it->getType(),
8378  CK_NullToPointer);
8379  InitField = it;
8380  break;
8381  }
8382  }
8383 
8384  CastKind Kind;
8385  if (CheckAssignmentConstraints(it->getType(), RHS, Kind)
8386  == Compatible) {
8387  RHS = ImpCastExprToType(RHS.get(), it->getType(), Kind);
8388  InitField = it;
8389  break;
8390  }
8391  }
8392 
8393  if (!InitField)
8394  return Incompatible;
8395 
8396  ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField);
8397  return Compatible;
8398 }
8399 
8402  bool Diagnose,
8403  bool DiagnoseCFAudited,
8404  bool ConvertRHS) {
8405  // We need to be able to tell the caller whether we diagnosed a problem, if
8406  // they ask us to issue diagnostics.
8407  assert((ConvertRHS || !Diagnose) && "can't indicate whether we diagnosed");
8408 
8409  // If ConvertRHS is false, we want to leave the caller's RHS untouched. Sadly,
8410  // we can't avoid *all* modifications at the moment, so we need some somewhere
8411  // to put the updated value.
8412  ExprResult LocalRHS = CallerRHS;
8413  ExprResult &RHS = ConvertRHS ? CallerRHS : LocalRHS;
8414 
8415  if (const auto *LHSPtrType = LHSType->getAs<PointerType>()) {
8416  if (const auto *RHSPtrType = RHS.get()->getType()->getAs<PointerType>()) {
8417  if (RHSPtrType->getPointeeType()->hasAttr(attr::NoDeref) &&
8418  !LHSPtrType->getPointeeType()->hasAttr(attr::NoDeref)) {
8419  Diag(RHS.get()->getExprLoc(),
8420  diag::warn_noderef_to_dereferenceable_pointer)
8421  << RHS.get()->getSourceRange();
8422  }
8423  }
8424  }
8425 
8426  if (getLangOpts().CPlusPlus) {
8427  if (!LHSType->isRecordType() && !LHSType->isAtomicType()) {
8428  // C++ 5.17p3: If the left operand is not of class type, the
8429  // expression is implicitly converted (C++ 4) to the
8430  // cv-unqualified type of the left operand.
8431  QualType RHSType = RHS.get()->getType();
8432  if (Diagnose) {
8433  RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
8434  AA_Assigning);
8435  } else {
8437  TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
8438  /*SuppressUserConversions=*/false,
8439  /*AllowExplicit=*/false,
8440  /*InOverloadResolution=*/false,
8441  /*CStyle=*/false,
8442  /*AllowObjCWritebackConversion=*/false);
8443  if (ICS.isFailure())
8444  return Incompatible;
8445  RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
8446  ICS, AA_Assigning);
8447  }
8448  if (RHS.isInvalid())
8449  return Incompatible;
8450  Sema::AssignConvertType result = Compatible;
8451  if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
8452  !CheckObjCARCUnavailableWeakConversion(LHSType, RHSType))
8453  result = IncompatibleObjCWeakRef;
8454  return result;
8455  }
8456 
8457  // FIXME: Currently, we fall through and treat C++ classes like C
8458  // structures.
8459  // FIXME: We also fall through for atomics; not sure what should
8460  // happen there, though.
8461  } else if (RHS.get()->getType() == Context.OverloadTy) {
8462  // As a set of extensions to C, we support overloading on functions. These
8463  // functions need to be resolved here.
8464  DeclAccessPair DAP;
8465  if (FunctionDecl *FD = ResolveAddressOfOverloadedFunction(
8466  RHS.get(), LHSType, /*Complain=*/false, DAP))
8467  RHS = FixOverloadedFunctionReference(RHS.get(), DAP, FD);
8468  else
8469  return Incompatible;
8470  }
8471 
8472  // C99 6.5.16.1p1: the left operand is a pointer and the right is
8473  // a null pointer constant.
8474  if ((LHSType->isPointerType() || LHSType->isObjCObjectPointerType() ||
8475  LHSType->isBlockPointerType()) &&
8476  RHS.get()->isNullPointerConstant(Context,
8478  if (Diagnose || ConvertRHS) {
8479  CastKind Kind;
8480  CXXCastPath Path;
8481  CheckPointerConversion(RHS.get(), LHSType, Kind, Path,
8482  /*IgnoreBaseAccess=*/false, Diagnose);
8483  if (ConvertRHS)
8484  RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_RValue, &Path);
8485  }
8486  return Compatible;
8487  }
8488 
8489  // OpenCL queue_t type assignment.
8490  if (LHSType->isQueueT() && RHS.get()->isNullPointerConstant(
8491  Context, Expr::NPC_ValueDependentIsNull)) {
8492  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
8493  return Compatible;
8494  }
8495 
8496  // This check seems unnatural, however it is necessary to ensure the proper
8497  // conversion of functions/arrays. If the conversion were done for all
8498  // DeclExpr's (created by ActOnIdExpression), it would mess up the unary
8499  // expressions that suppress this implicit conversion (&, sizeof).
8500  //
8501  // Suppress this for references: C++ 8.5.3p5.
8502  if (!LHSType->isReferenceType()) {
8503  // FIXME: We potentially allocate here even if ConvertRHS is false.
8504  RHS = DefaultFunctionArrayLvalueConversion(RHS.get(), Diagnose);
8505  if (RHS.isInvalid())
8506  return Incompatible;
8507  }
8508  CastKind Kind;
8510  CheckAssignmentConstraints(LHSType, RHS, Kind, ConvertRHS);
8511 
8512  // C99 6.5.16.1p2: The value of the right operand is converted to the
8513  // type of the assignment expression.
8514  // CheckAssignmentConstraints allows the left-hand side to be a reference,
8515  // so that we can use references in built-in functions even in C.
8516  // The getNonReferenceType() call makes sure that the resulting expression
8517  // does not have reference type.
8518  if (result != Incompatible && RHS.get()->getType() != LHSType) {
8519  QualType Ty = LHSType.getNonLValueExprType(Context);
8520  Expr *E = RHS.get();
8521 
8522  // Check for various Objective-C errors. If we are not reporting
8523  // diagnostics and just checking for errors, e.g., during overload
8524  // resolution, return Incompatible to indicate the failure.
8525  if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() &&
8526  CheckObjCConversion(SourceRange(), Ty, E, CCK_ImplicitConversion,
8527  Diagnose, DiagnoseCFAudited) != ACR_okay) {
8528  if (!Diagnose)
8529  return Incompatible;
8530  }
8531  if (getLangOpts().ObjC &&
8532  (CheckObjCBridgeRelatedConversions(E->getBeginLoc(), LHSType,
8533  E->getType(), E, Diagnose) ||
8534  ConversionToObjCStringLiteralCheck(LHSType, E, Diagnose))) {
8535  if (!Diagnose)
8536  return Incompatible;
8537  // Replace the expression with a corrected version and continue so we
8538  // can find further errors.
8539  RHS = E;
8540  return Compatible;
8541  }
8542 
8543  if (ConvertRHS)
8544  RHS = ImpCastExprToType(E, Ty, Kind);
8545  }
8546 
8547  return result;
8548 }
8549 
8550 namespace {
8551 /// The original operand to an operator, prior to the application of the usual
8552 /// arithmetic conversions and converting the arguments of a builtin operator
8553 /// candidate.
8554 struct OriginalOperand {
8555  explicit OriginalOperand(Expr *Op) : Orig(Op), Conversion(nullptr) {
8556  if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Op))
8557  Op = MTE->GetTemporaryExpr();
8558  if (auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Op))
8559  Op = BTE->getSubExpr();
8560  if (auto *ICE = dyn_cast<ImplicitCastExpr>(Op)) {
8561  Orig = ICE->getSubExprAsWritten();
8562  Conversion = ICE->getConversionFunction();
8563  }
8564  }
8565 
8566  QualType getType() const { return Orig->getType(); }
8567 
8568  Expr *Orig;
8569  NamedDecl *Conversion;
8570 };
8571 }
8572 
8574  ExprResult &RHS) {
8575  OriginalOperand OrigLHS(LHS.get()), OrigRHS(RHS.get());
8576 
8577  Diag(Loc, diag::err_typecheck_invalid_operands)
8578  << OrigLHS.getType() << OrigRHS.getType()
8579  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
8580 
8581  // If a user-defined conversion was applied to either of the operands prior
8582  // to applying the built-in operator rules, tell the user about it.
8583  if (OrigLHS.Conversion) {
8584  Diag(OrigLHS.Conversion->getLocation(),
8585  diag::note_typecheck_invalid_operands_converted)
8586  << 0 << LHS.get()->getType();
8587  }
8588  if (OrigRHS.Conversion) {
8589  Diag(OrigRHS.Conversion->getLocation(),
8590  diag::note_typecheck_invalid_operands_converted)
8591  << 1 << RHS.get()->getType();
8592  }
8593 
8594  return QualType();
8595 }
8596 
8597 // Diagnose cases where a scalar was implicitly converted to a vector and
8598 // diagnose the underlying types. Otherwise, diagnose the error
8599 // as invalid vector logical operands for non-C++ cases.
8601  ExprResult &RHS) {
8602  QualType LHSType = LHS.get()->IgnoreImpCasts()->getType();
8603  QualType RHSType = RHS.get()->IgnoreImpCasts()->getType();
8604 
8605  bool LHSNatVec = LHSType->isVectorType();
8606  bool RHSNatVec = RHSType->isVectorType();
8607 
8608  if (!(LHSNatVec && RHSNatVec)) {
8609  Expr *Vector = LHSNatVec ? LHS.get() : RHS.get();
8610  Expr *NonVector = !LHSNatVec ? LHS.get() : RHS.get();
8611  Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
8612  << 0 << Vector->getType() << NonVector->IgnoreImpCasts()->getType()
8613  << Vector->getSourceRange();
8614  return QualType();
8615  }
8616 
8617  Diag(Loc, diag::err_typecheck_logical_vector_expr_gnu_cpp_restrict)
8618  << 1 << LHSType << RHSType << LHS.get()->getSourceRange()
8619  << RHS.get()->getSourceRange();
8620 
8621  return QualType();
8622 }
8623 
8624 /// Try to convert a value of non-vector type to a vector type by converting
8625 /// the type to the element type of the vector and then performing a splat.
8626 /// If the language is OpenCL, we only use conversions that promote scalar
8627 /// rank; for C, Obj-C, and C++ we allow any real scalar conversion except
8628 /// for float->int.
8629 ///
8630 /// OpenCL V2.0 6.2.6.p2:
8631 /// An error shall occur if any scalar operand type has greater rank
8632 /// than the type of the vector element.
8633 ///
8634 /// \param scalar - if non-null, actually perform the conversions
8635 /// \return true if the operation fails (but without diagnosing the failure)
8636 static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
8637  QualType scalarTy,
8638  QualType vectorEltTy,
8639  QualType vectorTy,
8640  unsigned &DiagID) {
8641  // The conversion to apply to the scalar before splatting it,
8642  // if necessary.
8643  CastKind scalarCast = CK_NoOp;
8644 
8645  if (vectorEltTy->isIntegralType(S.Context)) {
8646  if (S.getLangOpts().OpenCL && (scalarTy->isRealFloatingType() ||
8647  (scalarTy->isIntegerType() &&
8648  S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0))) {
8649  DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
8650  return true;
8651  }
8652  if (!scalarTy->isIntegralType(S.Context))
8653  return true;
8654  scalarCast = CK_IntegralCast;
8655  } else if (vectorEltTy->isRealFloatingType()) {
8656  if (scalarTy->isRealFloatingType()) {
8657  if (S.getLangOpts().OpenCL &&
8658  S.Context.getFloatingTypeOrder(vectorEltTy, scalarTy) < 0) {
8659  DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
8660  return true;
8661  }
8662  scalarCast = CK_FloatingCast;
8663  }
8664  else if (scalarTy->isIntegralType(S.Context))
8665  scalarCast = CK_IntegralToFloating;
8666  else
8667  return true;
8668  } else {
8669  return true;
8670  }
8671 
8672  // Adjust scalar if desired.
8673  if (scalar) {
8674  if (scalarCast != CK_NoOp)
8675  *scalar = S.ImpCastExprToType(scalar->get(), vectorEltTy, scalarCast);
8676  *scalar = S.ImpCastExprToType(scalar->get(), vectorTy, CK_VectorSplat);
8677  }
8678  return false;
8679 }
8680 
8681 /// Convert vector E to a vector with the same number of elements but different
8682 /// element type.
8683 static ExprResult convertVector(Expr *E, QualType ElementType, Sema &S) {
8684  const auto *VecTy = E->getType()->getAs<VectorType>();
8685  assert(VecTy && "Expression E must be a vector");
8686  QualType NewVecTy = S.Context.getVectorType(ElementType,
8687  VecTy->getNumElements(),
8688  VecTy->getVectorKind());
8689 
8690  // Look through the implicit cast. Return the subexpression if its type is
8691  // NewVecTy.
8692  if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
8693  if (ICE->getSubExpr()->getType() == NewVecTy)
8694  return ICE->getSubExpr();
8695 
8696  auto Cast = ElementType->isIntegerType() ? CK_IntegralCast : CK_FloatingCast;
8697  return S.ImpCastExprToType(E, NewVecTy, Cast);
8698 }
8699 
8700 /// Test if a (constant) integer Int can be casted to another integer type
8701 /// IntTy without losing precision.
8703  QualType OtherIntTy) {
8704  QualType IntTy = Int->get()->getType().getUnqualifiedType();
8705 
8706  // Reject cases where the value of the Int is unknown as that would
8707  // possibly cause truncation, but accept cases where the scalar can be
8708  // demoted without loss of precision.
8709  Expr::EvalResult EVResult;
8710  bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.Context);
8711  int Order = S.Context.getIntegerTypeOrder(OtherIntTy, IntTy);
8712  bool IntSigned = IntTy->hasSignedIntegerRepresentation();
8713  bool OtherIntSigned = OtherIntTy->hasSignedIntegerRepresentation();
8714 
8715  if (CstInt) {
8716  // If the scalar is constant and is of a higher order and has more active
8717  // bits that the vector element type, reject it.
8718  llvm::APSInt Result = EVResult.Val.getInt();
8719  unsigned NumBits = IntSigned
8720  ? (Result.isNegative() ? Result.getMinSignedBits()
8721  : Result.getActiveBits())
8722  : Result.getActiveBits();
8723  if (Order < 0 && S.Context.getIntWidth(OtherIntTy) < NumBits)
8724  return true;
8725 
8726  // If the signedness of the scalar type and the vector element type
8727  // differs and the number of bits is greater than that of the vector
8728  // element reject it.
8729  return (IntSigned != OtherIntSigned &&
8730  NumBits > S.Context.getIntWidth(OtherIntTy));
8731  }
8732 
8733  // Reject cases where the value of the scalar is not constant and it's
8734  // order is greater than that of the vector element type.
8735  return (Order < 0);
8736 }
8737 
8738 /// Test if a (constant) integer Int can be casted to floating point type
8739 /// FloatTy without losing precision.
8741  QualType FloatTy) {
8742  QualType IntTy = Int->get()->getType().getUnqualifiedType();
8743 
8744  // Determine if the integer constant can be expressed as a floating point
8745  // number of the appropriate type.
8746  Expr::EvalResult EVResult;
8747  bool CstInt = Int->get()->EvaluateAsInt(EVResult, S.Context);
8748 
8749  uint64_t Bits = 0;
8750  if (CstInt) {
8751  // Reject constants that would be truncated if they were converted to
8752  // the floating point type. Test by simple to/from conversion.
8753  // FIXME: Ideally the conversion to an APFloat and from an APFloat
8754  // could be avoided if there was a convertFromAPInt method
8755  // which could signal back if implicit truncation occurred.
8756  llvm::APSInt Result = EVResult.Val.getInt();
8757  llvm::APFloat Float(S.Context.getFloatTypeSemantics(FloatTy));
8758  Float.convertFromAPInt(Result, IntTy->hasSignedIntegerRepresentation(),
8759  llvm::APFloat::rmTowardZero);
8760  llvm::APSInt ConvertBack(S.Context.getIntWidth(IntTy),
8761  !IntTy->hasSignedIntegerRepresentation());
8762  bool Ignored = false;
8763  Float.convertToInteger(ConvertBack, llvm::APFloat::rmNearestTiesToEven,
8764  &Ignored);
8765  if (Result != ConvertBack)
8766  return true;
8767  } else {
8768  // Reject types that cannot be fully encoded into the mantissa of
8769  // the float.
8770  Bits = S.Context.getTypeSize(IntTy);
8771  unsigned FloatPrec = llvm::APFloat::semanticsPrecision(
8772  S.Context.getFloatTypeSemantics(FloatTy));
8773  if (Bits > FloatPrec)
8774  return true;
8775  }
8776 
8777  return false;
8778 }
8779 
8780 /// Attempt to convert and splat Scalar into a vector whose types matches
8781 /// Vector following GCC conversion rules. The rule is that implicit
8782 /// conversion can occur when Scalar can be casted to match Vector's element
8783 /// type without causing truncation of Scalar.
8785  ExprResult *Vector) {
8786  QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
8787  QualType VectorTy = Vector->get()->getType().getUnqualifiedType();
8788  const VectorType *VT = VectorTy->getAs<VectorType>();
8789 
8790  assert(!isa<ExtVectorType>(VT) &&
8791  "ExtVectorTypes should not be handled here!");
8792 
8793  QualType VectorEltTy = VT->getElementType();
8794 
8795  // Reject cases where the vector element type or the scalar element type are
8796  // not integral or floating point types.
8797  if (!VectorEltTy->isArithmeticType() || !ScalarTy->isArithmeticType())
8798  return true;
8799 
8800  // The conversion to apply to the scalar before splatting it,
8801  // if necessary.
8802  CastKind ScalarCast = CK_NoOp;
8803 
8804  // Accept cases where the vector elements are integers and the scalar is
8805  // an integer.
8806  // FIXME: Notionally if the scalar was a floating point value with a precise
8807  // integral representation, we could cast it to an appropriate integer
8808  // type and then perform the rest of the checks here. GCC will perform
8809  // this conversion in some cases as determined by the input language.
8810  // We should accept it on a language independent basis.
8811  if (VectorEltTy->isIntegralType(S.Context) &&
8812  ScalarTy->isIntegralType(S.Context) &&
8813  S.Context.getIntegerTypeOrder(VectorEltTy, ScalarTy)) {
8814 
8815  if (canConvertIntToOtherIntTy(S, Scalar, VectorEltTy))
8816  return true;
8817 
8818  ScalarCast = CK_IntegralCast;
8819  } else if (VectorEltTy->isRealFloatingType()) {
8820  if (ScalarTy->isRealFloatingType()) {
8821 
8822  // Reject cases where the scalar type is not a constant and has a higher
8823  // Order than the vector element type.
8824  llvm::APFloat Result(0.0);
8825  bool CstScalar = Scalar->get()->EvaluateAsFloat(Result, S.Context);
8826  int Order = S.Context.getFloatingTypeOrder(VectorEltTy, ScalarTy);
8827  if (!CstScalar && Order < 0)
8828  return true;
8829 
8830  // If the scalar cannot be safely casted to the vector element type,
8831  // reject it.
8832  if (CstScalar) {
8833  bool Truncated = false;
8834  Result.convert(S.Context.getFloatTypeSemantics(VectorEltTy),
8835  llvm::APFloat::rmNearestTiesToEven, &Truncated);
8836  if (Truncated)
8837  return true;
8838  }
8839 
8840  ScalarCast = CK_FloatingCast;
8841  } else if (ScalarTy->isIntegralType(S.Context)) {
8842  if (canConvertIntTyToFloatTy(S, Scalar, VectorEltTy))
8843  return true;
8844 
8845  ScalarCast = CK_IntegralToFloating;
8846  } else
8847  return true;
8848  }
8849 
8850  // Adjust scalar if desired.
8851  if (Scalar) {
8852  if (ScalarCast != CK_NoOp)
8853  *Scalar = S.ImpCastExprToType(Scalar->get(), VectorEltTy, ScalarCast);
8854  *Scalar = S.ImpCastExprToType(Scalar->get(), VectorTy, CK_VectorSplat);
8855  }
8856  return false;
8857 }
8858 
8860  SourceLocation Loc, bool IsCompAssign,
8861  bool AllowBothBool,
8862  bool AllowBoolConversions) {
8863  if (!IsCompAssign) {
8864  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
8865  if (LHS.isInvalid())
8866  return QualType();
8867  }
8868  RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
8869  if (RHS.isInvalid())
8870  return QualType();
8871 
8872  // For conversion purposes, we ignore any qualifiers.
8873  // For example, "const float" and "float" are equivalent.
8874  QualType LHSType = LHS.get()->getType().getUnqualifiedType();
8875  QualType RHSType = RHS.get()->getType().getUnqualifiedType();
8876 
8877  const VectorType *LHSVecType = LHSType->getAs<VectorType>();
8878  const VectorType *RHSVecType = RHSType->getAs<VectorType>();
8879  assert(LHSVecType || RHSVecType);
8880 
8881  // AltiVec-style "vector bool op vector bool" combinations are allowed
8882  // for some operators but not others.
8883  if (!AllowBothBool &&
8884  LHSVecType && LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
8885  RHSVecType && RHSVecType->getVectorKind() == VectorType::AltiVecBool)
8886  return InvalidOperands(Loc, LHS, RHS);
8887 
8888  // If the vector types are identical, return.
8889  if (Context.hasSameType(LHSType, RHSType))
8890  return LHSType;
8891 
8892  // If we have compatible AltiVec and GCC vector types, use the AltiVec type.
8893  if (LHSVecType && RHSVecType &&
8894  Context.areCompatibleVectorTypes(LHSType, RHSType)) {
8895  if (isa<ExtVectorType>(LHSVecType)) {
8896  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
8897  return LHSType;
8898  }
8899 
8900  if (!IsCompAssign)
8901  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
8902  return RHSType;
8903  }
8904 
8905  // AllowBoolConversions says that bool and non-bool AltiVec vectors
8906  // can be mixed, with the result being the non-bool type. The non-bool
8907  // operand must have integer element type.
8908  if (AllowBoolConversions && LHSVecType && RHSVecType &&
8909  LHSVecType->getNumElements() == RHSVecType->getNumElements() &&
8910  (Context.getTypeSize(LHSVecType->getElementType()) ==
8911  Context.getTypeSize(RHSVecType->getElementType()))) {
8912  if (LHSVecType->getVectorKind() == VectorType::AltiVecVector &&
8913  LHSVecType->getElementType()->isIntegerType() &&
8914  RHSVecType->getVectorKind() == VectorType::AltiVecBool) {
8915  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
8916  return LHSType;
8917  }
8918  if (!IsCompAssign &&
8919  LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
8920  RHSVecType->getVectorKind() == VectorType::AltiVecVector &&
8921  RHSVecType->getElementType()->isIntegerType()) {
8922  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
8923  return RHSType;
8924  }
8925  }
8926 
8927  // If there's a vector type and a scalar, try to convert the scalar to
8928  // the vector element type and splat.
8929  unsigned DiagID = diag::err_typecheck_vector_not_convertable;
8930  if (!RHSVecType) {
8931  if (isa<ExtVectorType>(LHSVecType)) {
8932  if (!tryVectorConvertAndSplat(*this, &RHS, RHSType,
8933  LHSVecType->getElementType(), LHSType,
8934  DiagID))
8935  return LHSType;
8936  } else {
8937  if (!tryGCCVectorConvertAndSplat(*this, &RHS, &LHS))
8938  return LHSType;
8939  }
8940  }
8941  if (!LHSVecType) {
8942  if (isa<ExtVectorType>(RHSVecType)) {
8943  if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS),
8944  LHSType, RHSVecType->getElementType(),
8945  RHSType, DiagID))
8946  return RHSType;
8947  } else {
8948  if (LHS.get()->getValueKind() == VK_LValue ||
8949  !tryGCCVectorConvertAndSplat(*this, &LHS, &RHS))
8950  return RHSType;
8951  }
8952  }
8953 
8954  // FIXME: The code below also handles conversion between vectors and
8955  // non-scalars, we should break this down into fine grained specific checks
8956  // and emit proper diagnostics.
8957  QualType VecType = LHSVecType ? LHSType : RHSType;
8958  const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
8959  QualType OtherType = LHSVecType ? RHSType : LHSType;
8960  ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
8961  if (isLaxVectorConversion(OtherType, VecType)) {
8962  // If we're allowing lax vector conversions, only the total (data) size
8963  // needs to be the same. For non compound assignment, if one of the types is
8964  // scalar, the result is always the vector type.
8965  if (!IsCompAssign) {
8966  *OtherExpr = ImpCastExprToType(OtherExpr->get(), VecType, CK_BitCast);
8967  return VecType;
8968  // In a compound assignment, lhs += rhs, 'lhs' is a lvalue src, forbidding
8969  // any implicit cast. Here, the 'rhs' should be implicit casted to 'lhs'
8970  // type. Note that this is already done by non-compound assignments in
8971  // CheckAssignmentConstraints. If it's a scalar type, only bitcast for
8972  // <1 x T> -> T. The result is also a vector type.
8973  } else if (OtherType->isExtVectorType() || OtherType->isVectorType() ||
8974  (OtherType->isScalarType() && VT->getNumElements() == 1)) {
8975  ExprResult *RHSExpr = &RHS;
8976  *RHSExpr = ImpCastExprToType(RHSExpr->get(), LHSType, CK_BitCast);
8977  return VecType;
8978  }
8979  }
8980 
8981  // Okay, the expression is invalid.
8982 
8983  // If there's a non-vector, non-real operand, diagnose that.
8984  if ((!RHSVecType && !RHSType->isRealType()) ||
8985  (!LHSVecType && !LHSType->isRealType())) {
8986  Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
8987  << LHSType << RHSType
8988  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
8989  return QualType();
8990  }
8991 
8992  // OpenCL V1.1 6.2.6.p1:
8993  // If the operands are of more than one vector type, then an error shall
8994  // occur. Implicit conversions between vector types are not permitted, per
8995  // section 6.2.1.
8996  if (getLangOpts().OpenCL &&
8997  RHSVecType && isa<ExtVectorType>(RHSVecType) &&
8998  LHSVecType && isa<ExtVectorType>(LHSVecType)) {
8999  Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
9000  << RHSType;
9001  return QualType();
9002  }
9003 
9004 
9005  // If there is a vector type that is not a ExtVector and a scalar, we reach
9006  // this point if scalar could not be converted to the vector's element type
9007  // without truncation.
9008  if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
9009  (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
9010  QualType Scalar = LHSVecType ? RHSType : LHSType;
9011  QualType Vector = LHSVecType ? LHSType : RHSType;
9012  unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
9013  Diag(Loc,
9014  diag::err_typecheck_vector_not_convertable_implict_truncation)
9015  << ScalarOrVector << Scalar << Vector;
9016 
9017  return QualType();
9018  }
9019 
9020  // Otherwise, use the generic diagnostic.
9021  Diag(Loc, DiagID)
9022  << LHSType << RHSType
9023  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9024  return QualType();
9025 }
9026 
9027 // checkArithmeticNull - Detect when a NULL constant is used improperly in an
9028 // expression. These are mainly cases where the null pointer is used as an
9029 // integer instead of a pointer.
9030 static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS,
9031  SourceLocation Loc, bool IsCompare) {
9032  // The canonical way to check for a GNU null is with isNullPointerConstant,
9033  // but we use a bit of a hack here for speed; this is a relatively
9034  // hot path, and isNullPointerConstant is slow.
9035  bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts());
9036  bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts());
9037 
9038  QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType();
9039 
9040  // Avoid analyzing cases where the result will either be invalid (and
9041  // diagnosed as such) or entirely valid and not something to warn about.
9042  if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() ||
9043  NonNullType->isMemberPointerType() || NonNullType->isFunctionType())
9044  return;
9045 
9046  // Comparison operations would not make sense with a null pointer no matter
9047  // what the other expression is.
9048  if (!IsCompare) {
9049  S.Diag(Loc, diag::warn_null_in_arithmetic_operation)
9050  << (LHSNull ? LHS.get()->getSourceRange() : SourceRange())
9051  << (RHSNull ? RHS.get()->getSourceRange() : SourceRange());
9052  return;
9053  }
9054 
9055  // The rest of the operations only make sense with a null pointer
9056  // if the other expression is a pointer.
9057  if (LHSNull == RHSNull || NonNullType->isAnyPointerType() ||
9058  NonNullType->canDecayToPointerType())
9059  return;
9060 
9061  S.Diag(Loc, diag::warn_null_in_comparison_operation)
9062  << LHSNull /* LHS is NULL */ << NonNullType
9063  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9064 }
9065 
9066 static void DiagnoseDivisionSizeofPointer(Sema &S, Expr *LHS, Expr *RHS,
9067  SourceLocation Loc) {
9068  const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
9069  const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
9070  if (!LUE || !RUE)
9071  return;
9072  if (LUE->getKind() != UETT_SizeOf || LUE->isArgumentType() ||
9073  RUE->getKind() != UETT_SizeOf)
9074  return;
9075 
9076  QualType LHSTy = LUE->getArgumentExpr()->IgnoreParens()->getType();
9077  QualType RHSTy;
9078 
9079  if (RUE->isArgumentType())
9080  RHSTy = RUE->getArgumentType();
9081  else
9082  RHSTy = RUE->getArgumentExpr()->IgnoreParens()->getType();
9083 
9084  if (!LHSTy->isPointerType() || RHSTy->isPointerType())
9085  return;
9086  if (LHSTy->getPointeeType() != RHSTy)
9087  return;
9088 
9089  S.Diag(Loc, diag::warn_division_sizeof_ptr) << LHS << LHS->getSourceRange();
9090 }
9091 
9093  ExprResult &RHS,
9094  SourceLocation Loc, bool IsDiv) {
9095  // Check for division/remainder by zero.
9096  Expr::EvalResult RHSValue;
9097  if (!RHS.get()->isValueDependent() &&
9098  RHS.get()->EvaluateAsInt(RHSValue, S.Context) &&
9099  RHSValue.Val.getInt() == 0)
9100  S.DiagRuntimeBehavior(Loc, RHS.get(),
9101  S.PDiag(diag::warn_remainder_division_by_zero)
9102  << IsDiv << RHS.get()->getSourceRange());
9103 }
9104 
9106  SourceLocation Loc,
9107  bool IsCompAssign, bool IsDiv) {
9108  checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
9109 
9110  if (LHS.get()->getType()->isVectorType() ||
9111  RHS.get()->getType()->isVectorType())
9112  return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
9113  /*AllowBothBool*/getLangOpts().AltiVec,
9114  /*AllowBoolConversions*/false);
9115 
9116  QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign);
9117  if (LHS.isInvalid() || RHS.isInvalid())
9118  return QualType();
9119 
9120 
9121  if (compType.isNull() || !compType->isArithmeticType())
9122  return InvalidOperands(Loc, LHS, RHS);
9123  if (IsDiv) {
9124  DiagnoseBadDivideOrRemainderValues(*this, LHS, RHS, Loc, IsDiv);
9125  DiagnoseDivisionSizeofPointer(*this, LHS.get(), RHS.get(), Loc);
9126  }
9127  return compType;
9128 }
9129 
9131  ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
9132  checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
9133 
9134  if (LHS.get()->getType()->isVectorType() ||
9135  RHS.get()->getType()->isVectorType()) {
9136  if (LHS.get()->getType()->hasIntegerRepresentation() &&
9137  RHS.get()->getType()->hasIntegerRepresentation())
9138  return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
9139  /*AllowBothBool*/getLangOpts().AltiVec,
9140  /*AllowBoolConversions*/false);
9141  return InvalidOperands(Loc, LHS, RHS);
9142  }
9143 
9144  QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign);
9145  if (LHS.isInvalid() || RHS.isInvalid())
9146  return QualType();
9147 
9148  if (compType.isNull() || !compType->isIntegerType())
9149  return InvalidOperands(Loc, LHS, RHS);
9150  DiagnoseBadDivideOrRemainderValues(*this, LHS, RHS, Loc, false /* IsDiv */);
9151  return compType;
9152 }
9153 
9154 /// Diagnose invalid arithmetic on two void pointers.
9156  Expr *LHSExpr, Expr *RHSExpr) {
9157  S.Diag(Loc, S.getLangOpts().CPlusPlus
9158  ? diag::err_typecheck_pointer_arith_void_type
9159  : diag::ext_gnu_void_ptr)
9160  << 1 /* two pointers */ << LHSExpr->getSourceRange()
9161  << RHSExpr->getSourceRange();
9162 }
9163 
9164 /// Diagnose invalid arithmetic on a void pointer.
9166  Expr *Pointer) {
9167  S.Diag(Loc, S.getLangOpts().CPlusPlus
9168  ? diag::err_typecheck_pointer_arith_void_type
9169  : diag::ext_gnu_void_ptr)
9170  << 0 /* one pointer */ << Pointer->getSourceRange();
9171 }
9172 
9173 /// Diagnose invalid arithmetic on a null pointer.
9174 ///
9175 /// If \p IsGNUIdiom is true, the operation is using the 'p = (i8*)nullptr + n'
9176 /// idiom, which we recognize as a GNU extension.
9177 ///
9179  Expr *Pointer, bool IsGNUIdiom) {
9180  if (IsGNUIdiom)
9181  S.Diag(Loc, diag::warn_gnu_null_ptr_arith)
9182  << Pointer->getSourceRange();
9183  else
9184  S.Diag(Loc, diag::warn_pointer_arith_null_ptr)
9185  << S.getLangOpts().CPlusPlus << Pointer->getSourceRange();
9186 }
9187 
9188 /// Diagnose invalid arithmetic on two function pointers.
9190  Expr *LHS, Expr *RHS) {
9191  assert(LHS->getType()->isAnyPointerType());
9192  assert(RHS->getType()->isAnyPointerType());
9193  S.Diag(Loc, S.getLangOpts().CPlusPlus
9194  ? diag::err_typecheck_pointer_arith_function_type
9195  : diag::ext_gnu_ptr_func_arith)
9196  << 1 /* two pointers */ << LHS->getType()->getPointeeType()
9197  // We only show the second type if it differs from the first.
9198  << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(),
9199  RHS->getType())
9200  << RHS->getType()->getPointeeType()
9201  << LHS->getSourceRange() << RHS->getSourceRange();
9202 }
9203 
9204 /// Diagnose invalid arithmetic on a function pointer.
9206  Expr *Pointer) {
9207  assert(Pointer->getType()->isAnyPointerType());
9208  S.Diag(Loc, S.getLangOpts().CPlusPlus
9209  ? diag::err_typecheck_pointer_arith_function_type
9210  : diag::ext_gnu_ptr_func_arith)
9211  << 0 /* one pointer */ << Pointer->getType()->getPointeeType()
9212  << 0 /* one pointer, so only one type */
9213  << Pointer->getSourceRange();
9214 }
9215 
9216 /// Emit error if Operand is incomplete pointer type
9217 ///
9218 /// \returns True if pointer has incomplete type
9220  Expr *Operand) {
9221  QualType ResType = Operand->getType();
9222  if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
9223  ResType = ResAtomicType->getValueType();
9224 
9225  assert(ResType->isAnyPointerType() && !ResType->isDependentType());
9226  QualType PointeeTy = ResType->getPointeeType();
9227  return S.RequireCompleteType(Loc, PointeeTy,
9228  diag::err_typecheck_arithmetic_incomplete_type,
9229  PointeeTy, Operand->getSourceRange());
9230 }
9231 
9232 /// Check the validity of an arithmetic pointer operand.
9233 ///
9234 /// If the operand has pointer type, this code will check for pointer types
9235 /// which are invalid in arithmetic operations. These will be diagnosed
9236 /// appropriately, including whether or not the use is supported as an
9237 /// extension.
9238 ///
9239 /// \returns True when the operand is valid to use (even if as an extension).
9241  Expr *Operand) {
9242  QualType ResType = Operand->getType();
9243  if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
9244  ResType = ResAtomicType->getValueType();
9245 
9246  if (!ResType->isAnyPointerType()) return true;
9247 
9248  QualType PointeeTy = ResType->getPointeeType();
9249  if (PointeeTy->isVoidType()) {
9250  diagnoseArithmeticOnVoidPointer(S, Loc, Operand);
9251  return !S.getLangOpts().CPlusPlus;
9252  }
9253  if (PointeeTy->isFunctionType()) {
9254  diagnoseArithmeticOnFunctionPointer(S, Loc, Operand);
9255  return !S.getLangOpts().CPlusPlus;
9256  }
9257 
9258  if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false;
9259 
9260  return true;
9261 }
9262 
9263 /// Check the validity of a binary arithmetic operation w.r.t. pointer
9264 /// operands.
9265 ///
9266 /// This routine will diagnose any invalid arithmetic on pointer operands much
9267 /// like \see checkArithmeticOpPointerOperand. However, it has special logic
9268 /// for emitting a single diagnostic even for operations where both LHS and RHS
9269 /// are (potentially problematic) pointers.
9270 ///
9271 /// \returns True when the operand is valid to use (even if as an extension).
9273  Expr *LHSExpr, Expr *RHSExpr) {
9274  bool isLHSPointer = LHSExpr->getType()->isAnyPointerType();
9275  bool isRHSPointer = RHSExpr->getType()->isAnyPointerType();
9276  if (!isLHSPointer && !isRHSPointer) return true;
9277 
9278  QualType LHSPointeeTy, RHSPointeeTy;
9279  if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType();
9280  if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
9281 
9282  // if both are pointers check if operation is valid wrt address spaces
9283  if (S.getLangOpts().OpenCL && isLHSPointer && isRHSPointer) {
9284  const PointerType *lhsPtr = LHSExpr->getType()->getAs<PointerType>();
9285  const PointerType *rhsPtr = RHSExpr->getType()->getAs<PointerType>();
9286  if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) {
9287  S.Diag(Loc,
9288  diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
9289  << LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/
9290  << LHSExpr->getSourceRange() << RHSExpr->getSourceRange();
9291  return false;
9292  }
9293  }
9294 
9295  // Check for arithmetic on pointers to incomplete types.
9296  bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType();
9297  bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType();
9298  if (isLHSVoidPtr || isRHSVoidPtr) {
9299  if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr);
9300  else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr);
9301  else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr);
9302 
9303  return !S.getLangOpts().CPlusPlus;
9304  }
9305 
9306  bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType();
9307  bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType();
9308  if (isLHSFuncPtr || isRHSFuncPtr) {
9309  if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
9310  else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc,
9311  RHSExpr);
9312  else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);
9313 
9314  return !S.getLangOpts().CPlusPlus;
9315  }
9316 
9317  if (isLHSPointer && checkArithmeticIncompletePointerType(S, Loc, LHSExpr))
9318  return false;
9319  if (isRHSPointer && checkArithmeticIncompletePointerType(S, Loc, RHSExpr))
9320  return false;
9321 
9322  return true;
9323 }
9324 
9325 /// diagnoseStringPlusInt - Emit a warning when adding an integer to a string
9326 /// literal.
9327 static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc,
9328  Expr *LHSExpr, Expr *RHSExpr) {
9329  StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts());
9330  Expr* IndexExpr = RHSExpr;
9331  if (!StrExpr) {
9332  StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts());
9333  IndexExpr = LHSExpr;
9334  }
9335 
9336  bool IsStringPlusInt = StrExpr &&
9338  if (!IsStringPlusInt || IndexExpr->isValueDependent())
9339  return;
9340 
9341  SourceRange DiagRange(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
9342  Self.Diag(OpLoc, diag::warn_string_plus_int)
9343  << DiagRange << IndexExpr->IgnoreImpCasts()->getType();
9344 
9345  // Only print a fixit for "str" + int, not for int + "str".
9346  if (IndexExpr == RHSExpr) {
9347  SourceLocation EndLoc = Self.getLocForEndOfToken(RHSExpr->getEndLoc());
9348  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
9349  << FixItHint::CreateInsertion(LHSExpr->getBeginLoc(), "&")
9351  << FixItHint::CreateInsertion(EndLoc, "]");
9352  } else
9353  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
9354 }
9355 
9356 /// Emit a warning when adding a char literal to a string.
9357 static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc,
9358  Expr *LHSExpr, Expr *RHSExpr) {
9359  const Expr *StringRefExpr = LHSExpr;
9360  const CharacterLiteral *CharExpr =
9361  dyn_cast<CharacterLiteral>(RHSExpr->IgnoreImpCasts());
9362 
9363  if (!CharExpr) {
9364  CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->IgnoreImpCasts());
9365  StringRefExpr = RHSExpr;
9366  }
9367 
9368  if (!CharExpr || !StringRefExpr)
9369  return;
9370 
9371  const QualType StringType = StringRefExpr->getType();
9372 
9373  // Return if not a PointerType.
9374  if (!StringType->isAnyPointerType())
9375  return;
9376 
9377  // Return if not a CharacterType.
9378  if (!StringType->getPointeeType()->isAnyCharacterType())
9379  return;
9380 
9381  ASTContext &Ctx = Self.getASTContext();
9382  SourceRange DiagRange(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
9383 
9384  const QualType CharType = CharExpr->getType();
9385  if (!CharType->isAnyCharacterType() &&
9386  CharType->isIntegerType() &&
9387  llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) {
9388  Self.Diag(OpLoc, diag::warn_string_plus_char)
9389  << DiagRange << Ctx.CharTy;
9390  } else {
9391  Self.Diag(OpLoc, diag::warn_string_plus_char)
9392  << DiagRange << CharExpr->getType();
9393  }
9394 
9395  // Only print a fixit for str + char, not for char + str.
9396  if (isa<CharacterLiteral>(RHSExpr->IgnoreImpCasts())) {
9397  SourceLocation EndLoc = Self.getLocForEndOfToken(RHSExpr->getEndLoc());
9398  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
9399  << FixItHint::CreateInsertion(LHSExpr->getBeginLoc(), "&")
9401  << FixItHint::CreateInsertion(EndLoc, "]");
9402  } else {
9403  Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
9404  }
9405 }
9406 
9407 /// Emit error when two pointers are incompatible.
9409  Expr *LHSExpr, Expr *RHSExpr) {
9410  assert(LHSExpr->getType()->isAnyPointerType());
9411  assert(RHSExpr->getType()->isAnyPointerType());
9412  S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
9413  << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
9414  << RHSExpr->getSourceRange();
9415 }
9416 
9417 // C99 6.5.6
9420  QualType* CompLHSTy) {
9421  checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
9422 
9423  if (LHS.get()->getType()->isVectorType() ||
9424  RHS.get()->getType()->isVectorType()) {
9425  QualType compType = CheckVectorOperands(
9426  LHS, RHS, Loc, CompLHSTy,
9427  /*AllowBothBool*/getLangOpts().AltiVec,
9428  /*AllowBoolConversions*/getLangOpts().ZVector);
9429  if (CompLHSTy) *CompLHSTy = compType;
9430  return compType;
9431  }
9432 
9433  QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy);
9434  if (LHS.isInvalid() || RHS.isInvalid())
9435  return QualType();
9436 
9437  // Diagnose "string literal" '+' int and string '+' "char literal".
9438  if (Opc == BO_Add) {
9439  diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get());
9440  diagnoseStringPlusChar(*this, Loc, LHS.get(), RHS.get());
9441  }
9442 
9443  // handle the common case first (both operands are arithmetic).
9444  if (!compType.isNull() && compType->isArithmeticType()) {
9445  if (CompLHSTy) *CompLHSTy = compType;
9446  return compType;
9447  }
9448 
9449  // Type-checking. Ultimately the pointer's going to be in PExp;
9450  // note that we bias towards the LHS being the pointer.
9451  Expr *PExp = LHS.get(), *IExp = RHS.get();
9452 
9453  bool isObjCPointer;
9454  if (PExp->getType()->isPointerType()) {
9455  isObjCPointer = false;
9456  } else if (PExp->getType()->isObjCObjectPointerType()) {
9457  isObjCPointer = true;
9458  } else {
9459  std::swap(PExp, IExp);
9460  if (PExp->getType()->isPointerType()) {
9461  isObjCPointer = false;
9462  } else if (PExp->getType()->isObjCObjectPointerType()) {
9463  isObjCPointer = true;
9464  } else {
9465  return InvalidOperands(Loc, LHS, RHS);
9466  }
9467  }
9468  assert(PExp->getType()->isAnyPointerType());
9469 
9470  if (!IExp->getType()->isIntegerType())
9471  return InvalidOperands(Loc, LHS, RHS);
9472 
9473  // Adding to a null pointer results in undefined behavior.
9476  // In C++ adding zero to a null pointer is defined.
9477  Expr::EvalResult KnownVal;
9478  if (!getLangOpts().CPlusPlus ||
9479  (!IExp->isValueDependent() &&
9480  (!IExp->EvaluateAsInt(KnownVal, Context) ||
9481  KnownVal.Val.getInt() != 0))) {
9482  // Check the conditions to see if this is the 'p = nullptr + n' idiom.
9484  Context, BO_Add, PExp, IExp);
9485  diagnoseArithmeticOnNullPointer(*this, Loc, PExp, IsGNUIdiom);
9486  }
9487  }
9488 
9489  if (!checkArithmeticOpPointerOperand(*this, Loc, PExp))
9490  return QualType();
9491 
9492  if (isObjCPointer && checkArithmeticOnObjCPointer(*this, Loc, PExp))
9493  return QualType();
9494 
9495  // Check array bounds for pointer arithemtic
9496  CheckArrayAccess(PExp, IExp);
9497 
9498  if (CompLHSTy) {
9499  QualType LHSTy = Context.isPromotableBitField(LHS.get());
9500  if (LHSTy.isNull()) {
9501  LHSTy = LHS.get()->getType();
9502  if (LHSTy->isPromotableIntegerType())
9503  LHSTy = Context.getPromotedIntegerType(LHSTy);
9504  }
9505  *CompLHSTy = LHSTy;
9506  }
9507 
9508  return PExp->getType();
9509 }
9510 
9511 // C99 6.5.6
9513  SourceLocation Loc,
9514  QualType* CompLHSTy) {
9515  checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
9516 
9517  if (LHS.get()->getType()->isVectorType() ||
9518  RHS.get()->getType()->isVectorType()) {
9519  QualType compType = CheckVectorOperands(
9520  LHS, RHS, Loc, CompLHSTy,
9521  /*AllowBothBool*/getLangOpts().AltiVec,
9522  /*AllowBoolConversions*/getLangOpts().ZVector);
9523  if (CompLHSTy) *CompLHSTy = compType;
9524  return compType;
9525  }
9526 
9527  QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy);
9528  if (LHS.isInvalid() || RHS.isInvalid())
9529  return QualType();
9530 
9531  // Enforce type constraints: C99 6.5.6p3.
9532 
9533  // Handle the common case first (both operands are arithmetic).
9534  if (!compType.isNull() && compType->isArithmeticType()) {
9535  if (CompLHSTy) *CompLHSTy = compType;
9536  return compType;
9537  }
9538 
9539  // Either ptr - int or ptr - ptr.
9540  if (LHS.get()->getType()->isAnyPointerType()) {
9541  QualType lpointee = LHS.get()->getType()->getPointeeType();
9542 
9543  // Diagnose bad cases where we step over interface counts.
9544  if (LHS.get()->getType()->isObjCObjectPointerType() &&
9545  checkArithmeticOnObjCPointer(*this, Loc, LHS.get()))
9546  return QualType();
9547 
9548  // The result type of a pointer-int computation is the pointer type.
9549  if (RHS.get()->getType()->isIntegerType()) {
9550  // Subtracting from a null pointer should produce a warning.
9551  // The last argument to the diagnose call says this doesn't match the
9552  // GNU int-to-pointer idiom.
9553  if (LHS.get()->IgnoreParenCasts()->isNullPointerConstant(Context,
9555  // In C++ adding zero to a null pointer is defined.
9556  Expr::EvalResult KnownVal;
9557  if (!getLangOpts().CPlusPlus ||
9558  (!RHS.get()->isValueDependent() &&
9559  (!RHS.get()->EvaluateAsInt(KnownVal, Context) ||
9560  KnownVal.Val.getInt() != 0))) {
9561  diagnoseArithmeticOnNullPointer(*this, Loc, LHS.get(), false);
9562  }
9563  }
9564 
9565  if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get()))
9566  return QualType();
9567 
9568  // Check array bounds for pointer arithemtic
9569  CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/nullptr,
9570  /*AllowOnePastEnd*/true, /*IndexNegated*/true);
9571 
9572  if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
9573  return LHS.get()->getType();
9574  }
9575 
9576  // Handle pointer-pointer subtractions.
9577  if (const PointerType *RHSPTy
9578  = RHS.get()->getType()->getAs<PointerType>()) {
9579  QualType rpointee = RHSPTy->getPointeeType();
9580 
9581  if (getLangOpts().CPlusPlus) {
9582  // Pointee types must be the same: C++ [expr.add]
9583  if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
9584  diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
9585  }
9586  } else {
9587  // Pointee types must be compatible C99 6.5.6p3
9588  if (!Context.typesAreCompatible(
9589  Context.getCanonicalType(lpointee).getUnqualifiedType(),
9590  Context.getCanonicalType(rpointee).getUnqualifiedType())) {
9591  diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
9592  return QualType();
9593  }
9594  }
9595 
9596  if (!checkArithmeticBinOpPointerOperands(*this, Loc,
9597  LHS.get(), RHS.get()))
9598  return QualType();
9599 
9600  // FIXME: Add warnings for nullptr - ptr.
9601 
9602  // The pointee type may have zero size. As an extension, a structure or
9603  // union may have zero size or an array may have zero length. In this
9604  // case subtraction does not make sense.
9605  if (!rpointee->isVoidType() && !rpointee->isFunctionType()) {
9606  CharUnits ElementSize = Context.getTypeSizeInChars(rpointee);
9607  if (ElementSize.isZero()) {
9608  Diag(Loc,diag::warn_sub_ptr_zero_size_types)
9609  << rpointee.getUnqualifiedType()
9610  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9611  }
9612  }
9613 
9614  if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
9615  return Context.getPointerDiffType();
9616  }
9617  }
9618 
9619  return InvalidOperands(Loc, LHS, RHS);
9620 }
9621 
9623  if (const EnumType *ET = T->getAs<EnumType>())
9624  return ET->getDecl()->isScoped();
9625  return false;
9626 }
9627 
9630  QualType LHSType) {
9631  // OpenCL 6.3j: shift values are effectively % word size of LHS (more defined),
9632  // so skip remaining warnings as we don't want to modify values within Sema.
9633  if (S.getLangOpts().OpenCL)
9634  return;
9635 
9636  // Check right/shifter operand
9637  Expr::EvalResult RHSResult;
9638  if (RHS.get()->isValueDependent() ||
9639  !RHS.get()->EvaluateAsInt(RHSResult, S.Context))
9640  return;
9641  llvm::APSInt Right = RHSResult.Val.getInt();
9642 
9643  if (Right.isNegative()) {
9644  S.DiagRuntimeBehavior(Loc, RHS.get(),
9645  S.PDiag(diag::warn_shift_negative)
9646  << RHS.get()->getSourceRange());
9647  return;
9648  }
9649  llvm::APInt LeftBits(Right.getBitWidth(),
9650  S.Context.getTypeSize(LHS.get()->getType()));
9651  if (Right.uge(LeftBits)) {
9652  S.DiagRuntimeBehavior(Loc, RHS.get(),
9653  S.PDiag(diag::warn_shift_gt_typewidth)
9654  << RHS.get()->getSourceRange());
9655  return;
9656  }
9657  if (Opc != BO_Shl)
9658  return;
9659 
9660  // When left shifting an ICE which is signed, we can check for overflow which
9661  // according to C++ standards prior to C++2a has undefined behavior
9662  // ([expr.shift] 5.8/2). Unsigned integers have defined behavior modulo one
9663  // more than the maximum value representable in the result type, so never
9664  // warn for those. (FIXME: Unsigned left-shift overflow in a constant
9665  // expression is still probably a bug.)
9666  Expr::EvalResult LHSResult;
9667  if (LHS.get()->isValueDependent() ||
9668  LHSType->hasUnsignedIntegerRepresentation() ||
9669  !LHS.get()->EvaluateAsInt(LHSResult, S.Context))
9670  return;
9671  llvm::APSInt Left = LHSResult.Val.getInt();
9672 
9673  // If LHS does not have a signed type and non-negative value
9674  // then, the behavior is undefined before C++2a. Warn about it.
9675  if (Left.isNegative() && !S.getLangOpts().isSignedOverflowDefined() &&
9676  !S.getLangOpts().CPlusPlus2a) {
9677  S.DiagRuntimeBehavior(Loc, LHS.get(),
9678  S.PDiag(diag::warn_shift_lhs_negative)
9679  << LHS.get()->getSourceRange());
9680  return;
9681  }
9682 
9683  llvm::APInt ResultBits =
9684  static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits();
9685  if (LeftBits.uge(ResultBits))
9686  return;
9687  llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue());
9688  Result = Result.shl(Right);
9689 
9690  // Print the bit representation of the signed integer as an unsigned
9691  // hexadecimal number.
9692  SmallString<40> HexResult;
9693  Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true);
9694 
9695  // If we are only missing a sign bit, this is less likely to result in actual
9696  // bugs -- if the result is cast back to an unsigned type, it will have the
9697  // expected value. Thus we place this behind a different warning that can be
9698  // turned off separately if needed.
9699  if (LeftBits == ResultBits - 1) {
9700  S.Diag(Loc, diag::warn_shift_result_sets_sign_bit)
9701  << HexResult << LHSType
9702  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9703  return;
9704  }
9705 
9706  S.Diag(Loc, diag::warn_shift_result_gt_typewidth)
9707  << HexResult.str() << Result.getMinSignedBits() << LHSType
9708  << Left.getBitWidth() << LHS.get()->getSourceRange()
9709  << RHS.get()->getSourceRange();
9710 }
9711 
9712 /// Return the resulting type when a vector is shifted
9713 /// by a scalar or vector shift amount.
9715  SourceLocation Loc, bool IsCompAssign) {
9716  // OpenCL v1.1 s6.3.j says RHS can be a vector only if LHS is a vector.
9717  if ((S.LangOpts.OpenCL || S.LangOpts.ZVector) &&
9718  !LHS.get()->getType()->isVectorType()) {
9719  S.Diag(Loc, diag::err_shift_rhs_only_vector)
9720  << RHS.get()->getType() << LHS.get()->getType()
9721  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9722  return QualType();
9723  }
9724 
9725  if (!IsCompAssign) {
9726  LHS = S.UsualUnaryConversions(LHS.get());
9727  if (LHS.isInvalid()) return QualType();
9728  }
9729 
9730  RHS = S.UsualUnaryConversions(RHS.get());
9731  if (RHS.isInvalid()) return QualType();
9732 
9733  QualType LHSType = LHS.get()->getType();
9734  // Note that LHS might be a scalar because the routine calls not only in
9735  // OpenCL case.
9736  const VectorType *LHSVecTy = LHSType->getAs<VectorType>();
9737  QualType LHSEleType = LHSVecTy ? LHSVecTy->getElementType() : LHSType;
9738 
9739  // Note that RHS might not be a vector.
9740  QualType RHSType = RHS.get()->getType();
9741  const VectorType *RHSVecTy = RHSType->getAs<VectorType>();
9742  QualType RHSEleType = RHSVecTy ? RHSVecTy->getElementType() : RHSType;
9743 
9744  // The operands need to be integers.
9745  if (!LHSEleType->isIntegerType()) {
9746  S.Diag(Loc, diag::err_typecheck_expect_int)
9747  << LHS.get()->getType() << LHS.get()->getSourceRange();
9748  return QualType();
9749  }
9750 
9751  if (!RHSEleType->isIntegerType()) {
9752  S.Diag(Loc, diag::err_typecheck_expect_int)
9753  << RHS.get()->getType() << RHS.get()->getSourceRange();
9754  return QualType();
9755  }
9756 
9757  if (!LHSVecTy) {
9758  assert(RHSVecTy);
9759  if (IsCompAssign)
9760  return RHSType;
9761  if (LHSEleType != RHSEleType) {
9762  LHS = S.ImpCastExprToType(LHS.get(),RHSEleType, CK_IntegralCast);
9763  LHSEleType = RHSEleType;
9764  }
9765  QualType VecTy =
9766  S.Context.getExtVectorType(LHSEleType, RHSVecTy->getNumElements());
9767  LHS = S.ImpCastExprToType(LHS.get(), VecTy, CK_VectorSplat);
9768  LHSType = VecTy;
9769  } else if (RHSVecTy) {
9770  // OpenCL v1.1 s6.3.j says that for vector types, the operators
9771  // are applied component-wise. So if RHS is a vector, then ensure
9772  // that the number of elements is the same as LHS...
9773  if (RHSVecTy->getNumElements() != LHSVecTy->getNumElements()) {
9774  S.Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
9775  << LHS.get()->getType() << RHS.get()->getType()
9776  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9777  return QualType();
9778  }
9779  if (!S.LangOpts.OpenCL && !S.LangOpts.ZVector) {
9780  const BuiltinType *LHSBT = LHSEleType->getAs<clang::BuiltinType>();
9781  const BuiltinType *RHSBT = RHSEleType->getAs<clang::BuiltinType>();
9782  if (LHSBT != RHSBT &&
9783  S.Context.getTypeSize(LHSBT) != S.Context.getTypeSize(RHSBT)) {
9784  S.Diag(Loc, diag::warn_typecheck_vector_element_sizes_not_equal)
9785  << LHS.get()->getType() << RHS.get()->getType()
9786  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9787  }
9788  }
9789  } else {
9790  // ...else expand RHS to match the number of elements in LHS.
9791  QualType VecTy =
9792  S.Context.getExtVectorType(RHSEleType, LHSVecTy->getNumElements());
9793  RHS = S.ImpCastExprToType(RHS.get(), VecTy, CK_VectorSplat);
9794  }
9795 
9796  return LHSType;
9797 }
9798 
9799 // C99 6.5.7
9802  bool IsCompAssign) {
9803  checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
9804 
9805  // Vector shifts promote their scalar inputs to vector type.
9806  if (LHS.get()->getType()->isVectorType() ||
9807  RHS.get()->getType()->isVectorType()) {
9808  if (LangOpts.ZVector) {
9809  // The shift operators for the z vector extensions work basically
9810  // like general shifts, except that neither the LHS nor the RHS is
9811  // allowed to be a "vector bool".
9812  if (auto LHSVecType = LHS.get()->getType()->getAs<VectorType>())
9813  if (LHSVecType->getVectorKind() == VectorType::AltiVecBool)
9814  return InvalidOperands(Loc, LHS, RHS);
9815  if (auto RHSVecType = RHS.get()->getType()->getAs<VectorType>())
9816  if (RHSVecType->getVectorKind() == VectorType::AltiVecBool)
9817  return InvalidOperands(Loc, LHS, RHS);
9818  }
9819  return checkVectorShift(*this, LHS, RHS, Loc, IsCompAssign);
9820  }
9821 
9822  // Shifts don't perform usual arithmetic conversions, they just do integer
9823  // promotions on each operand. C99 6.5.7p3
9824 
9825  // For the LHS, do usual unary conversions, but then reset them away
9826  // if this is a compound assignment.
9827  ExprResult OldLHS = LHS;
9828  LHS = UsualUnaryConversions(LHS.get());
9829  if (LHS.isInvalid())
9830  return QualType();
9831  QualType LHSType = LHS.get()->getType();
9832  if (IsCompAssign) LHS = OldLHS;
9833 
9834  // The RHS is simpler.
9835  RHS = UsualUnaryConversions(RHS.get());
9836  if (RHS.isInvalid())
9837  return QualType();
9838  QualType RHSType = RHS.get()->getType();
9839 
9840  // C99 6.5.7p2: Each of the operands shall have integer type.
9841  if (!LHSType->hasIntegerRepresentation() ||
9842  !RHSType->hasIntegerRepresentation())
9843  return InvalidOperands(Loc, LHS, RHS);
9844 
9845  // C++0x: Don't allow scoped enums. FIXME: Use something better than
9846  // hasIntegerRepresentation() above instead of this.
9847  if (isScopedEnumerationType(LHSType) ||
9848  isScopedEnumerationType(RHSType)) {
9849  return InvalidOperands(Loc, LHS, RHS);
9850  }
9851  // Sanity-check shift operands
9852  DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType);
9853 
9854  // "The type of the result is that of the promoted left operand."
9855  return LHSType;
9856 }
9857 
9858 /// If two different enums are compared, raise a warning.
9859 static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS,
9860  Expr *RHS) {
9861  QualType LHSStrippedType = LHS->IgnoreParenImpCasts()->getType();
9862  QualType RHSStrippedType = RHS->IgnoreParenImpCasts()->getType();
9863 
9864  const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>();
9865  if (!LHSEnumType)
9866  return;
9867  const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>();
9868  if (!RHSEnumType)
9869  return;
9870 
9871  // Ignore anonymous enums.
9872  if (!LHSEnumType->getDecl()->getIdentifier() &&
9873  !LHSEnumType->getDecl()->getTypedefNameForAnonDecl())
9874  return;
9875  if (!RHSEnumType->getDecl()->getIdentifier() &&
9876  !RHSEnumType->getDecl()->getTypedefNameForAnonDecl())
9877  return;
9878 
9879  if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType))
9880  return;
9881 
9882  S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types)
9883  << LHSStrippedType << RHSStrippedType
9884  << LHS->getSourceRange() << RHS->getSourceRange();
9885 }
9886 
9887 /// Diagnose bad pointer comparisons.
9889  ExprResult &LHS, ExprResult &RHS,
9890  bool IsError) {
9891  S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
9892  : diag::ext_typecheck_comparison_of_distinct_pointers)
9893  << LHS.get()->getType() << RHS.get()->getType()
9894  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9895 }
9896 
9897 /// Returns false if the pointers are converted to a composite type,
9898 /// true otherwise.
9900  ExprResult &LHS, ExprResult &RHS) {
9901  // C++ [expr.rel]p2:
9902  // [...] Pointer conversions (4.10) and qualification
9903  // conversions (4.4) are performed on pointer operands (or on
9904  // a pointer operand and a null pointer constant) to bring
9905  // them to their composite pointer type. [...]
9906  //
9907  // C++ [expr.eq]p1 uses the same notion for (in)equality
9908  // comparisons of pointers.
9909 
9910  QualType LHSType = LHS.get()->getType();
9911  QualType RHSType = RHS.get()->getType();
9912  assert(LHSType->isPointerType() || RHSType->isPointerType() ||
9913  LHSType->isMemberPointerType() || RHSType->isMemberPointerType());
9914 
9915  QualType T = S.FindCompositePointerType(Loc, LHS, RHS);
9916  if (T.isNull()) {
9917  if ((LHSType->isPointerType() || LHSType->isMemberPointerType()) &&
9918  (RHSType->isPointerType() || RHSType->isMemberPointerType()))
9919  diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true);
9920  else
9921  S.InvalidOperands(Loc, LHS, RHS);
9922  return true;
9923  }
9924 
9925  LHS = S.ImpCastExprToType(LHS.get(), T, CK_BitCast);
9926  RHS = S.ImpCastExprToType(RHS.get(), T, CK_BitCast);
9927  return false;
9928 }
9929 
9931  ExprResult &LHS,
9932  ExprResult &RHS,
9933  bool IsError) {
9934  S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
9935  : diag::ext_typecheck_comparison_of_fptr_to_void)
9936  << LHS.get()->getType() << RHS.get()->getType()
9937  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
9938 }
9939 
9941  switch (E.get()->IgnoreParenImpCasts()->getStmtClass()) {
9942  case Stmt::ObjCArrayLiteralClass:
9943  case Stmt::ObjCDictionaryLiteralClass:
9944  case Stmt::ObjCStringLiteralClass:
9945  case Stmt::ObjCBoxedExprClass:
9946  return true;
9947  default:
9948  // Note that ObjCBoolLiteral is NOT an object literal!
9949  return false;
9950  }
9951 }
9952 
9953 static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
9954  const ObjCObjectPointerType *Type =
9955  LHS->getType()->getAs<ObjCObjectPointerType>();
9956 
9957  // If this is not actually an Objective-C object, bail out.
9958  if (!Type)
9959  return false;
9960 
9961  // Get the LHS object's interface type.
9962  QualType InterfaceType = Type->getPointeeType();
9963 
9964  // If the RHS isn't an Objective-C object, bail out.
9965  if (!RHS->getType()->isObjCObjectPointerType())
9966  return false;
9967 
9968  // Try to find the -isEqual: method.
9969  Selector IsEqualSel = S.NSAPIObj->getIsEqualSelector();
9970  ObjCMethodDecl *Method = S.LookupMethodInObjectType(IsEqualSel,
9971  InterfaceType,
9972  /*IsInstance=*/true);
9973  if (!Method) {
9974  if (Type->isObjCIdType()) {
9975  // For 'id', just check the global pool.
9976  Method = S.LookupInstanceMethodInGlobalPool(IsEqualSel, SourceRange(),
9977  /*receiverId=*/true);
9978  } else {
9979  // Check protocols.
9980  Method = S.LookupMethodInQualifiedType(IsEqualSel, Type,
9981  /*IsInstance=*/true);
9982  }
9983  }
9984 
9985  if (!Method)
9986  return false;
9987 
9988  QualType T = Method->parameters()[0]->getType();
9989  if (!T->isObjCObjectPointerType())
9990  return false;
9991 
9992  QualType R = Method->getReturnType();
9993  if (!R->isScalarType())
9994  return false;
9995 
9996  return true;
9997 }
9998 
10000  FromE = FromE->IgnoreParenImpCasts();
10001  switch (FromE->getStmtClass()) {
10002  default:
10003  break;
10004  case Stmt::ObjCStringLiteralClass:
10005  // "string literal"
10006  return LK_String;
10007  case Stmt::ObjCArrayLiteralClass:
10008  // "array literal"
10009  return LK_Array;
10010  case Stmt::ObjCDictionaryLiteralClass:
10011  // "dictionary literal"
10012  return LK_Dictionary;
10013  case Stmt::BlockExprClass:
10014  return LK_Block;
10015  case Stmt::ObjCBoxedExprClass: {
10016  Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
10017  switch (Inner->getStmtClass()) {
10018  case Stmt::IntegerLiteralClass:
10019  case Stmt::FloatingLiteralClass:
10020  case Stmt::CharacterLiteralClass:
10021  case Stmt::ObjCBoolLiteralExprClass:
10022  case Stmt::CXXBoolLiteralExprClass:
10023  // "numeric literal"
10024  return LK_Numeric;
10025  case Stmt::ImplicitCastExprClass: {
10026  CastKind CK = cast<CastExpr>(Inner)->getCastKind();
10027  // Boolean literals can be represented by implicit casts.
10028  if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast)
10029  return LK_Numeric;
10030  break;
10031  }
10032  default:
10033  break;
10034  }
10035  return LK_Boxed;
10036  }
10037  }
10038  return LK_None;
10039 }
10040 
10042  ExprResult &LHS, ExprResult &RHS,
10044  Expr *Literal;
10045  Expr *Other;
10046  if (isObjCObjectLiteral(LHS)) {
10047  Literal = LHS.get();
10048  Other = RHS.get();
10049  } else {
10050  Literal = RHS.get();
10051  Other = LHS.get();
10052  }
10053 
10054  // Don't warn on comparisons against nil.
10055  Other = Other->IgnoreParenCasts();
10056  if (Other->isNullPointerConstant(S.getASTContext(),
10058  return;
10059 
10060  // This should be kept in sync with warn_objc_literal_comparison.
10061  // LK_String should always be after the other literals, since it has its own
10062  // warning flag.
10063  Sema::ObjCLiteralKind LiteralKind = S.CheckLiteralKind(Literal);
10064  assert(LiteralKind != Sema::LK_Block);
10065  if (LiteralKind == Sema::LK_None) {
10066  llvm_unreachable("Unknown Objective-C object literal kind");
10067  }
10068 
10069  if (LiteralKind == Sema::LK_String)
10070  S.Diag(Loc, diag::warn_objc_string_literal_comparison)
10071  << Literal->getSourceRange();
10072  else
10073  S.Diag(Loc, diag::warn_objc_literal_comparison)
10074  << LiteralKind << Literal->getSourceRange();
10075 
10076  if (BinaryOperator::isEqualityOp(Opc) &&
10077  hasIsEqualMethod(S, LHS.get(), RHS.get())) {
10078  SourceLocation Start = LHS.get()->getBeginLoc();
10079  SourceLocation End = S.getLocForEndOfToken(RHS.get()->getEndLoc());
10080  CharSourceRange OpRange =
10082 
10083  S.Diag(Loc, diag::note_objc_literal_comparison_isequal)
10084  << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![")
10085  << FixItHint::CreateReplacement(OpRange, " isEqual:")
10086  << FixItHint::CreateInsertion(End, "]");
10087  }
10088 }
10089 
10090 /// Warns on !x < y, !x & y where !(x < y), !(x & y) was probably intended.
10092  ExprResult &RHS, SourceLocation Loc,
10093  BinaryOperatorKind Opc) {
10094  // Check that left hand side is !something.
10095  UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get()->IgnoreImpCasts());
10096  if (!UO || UO->getOpcode() != UO_LNot) return;
10097 
10098  // Only check if the right hand side is non-bool arithmetic type.
10099  if (RHS.get()->isKnownToHaveBooleanValue()) return;
10100 
10101  // Make sure that the something in !something is not bool.
10102  Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
10103  if (SubExpr->isKnownToHaveBooleanValue()) return;
10104 
10105  // Emit warning.
10106  bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
10107  S.Diag(UO->getOperatorLoc(), diag::warn_logical_not_on_lhs_of_check)
10108  << Loc << IsBitwiseOp;
10109 
10110  // First note suggest !(x < y)
10111  SourceLocation FirstOpen = SubExpr->getBeginLoc();
10112  SourceLocation FirstClose = RHS.get()->getEndLoc();
10113  FirstClose = S.getLocForEndOfToken(FirstClose);
10114  if (FirstClose.isInvalid())
10115  FirstOpen = SourceLocation();
10116  S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix)
10117  << IsBitwiseOp
10118  << FixItHint::CreateInsertion(FirstOpen, "(")
10119  << FixItHint::CreateInsertion(FirstClose, ")");
10120 
10121  // Second note suggests (!x) < y
10122  SourceLocation SecondOpen = LHS.get()->getBeginLoc();
10123  SourceLocation SecondClose = LHS.get()->getEndLoc();
10124  SecondClose = S.getLocForEndOfToken(SecondClose);
10125  if (SecondClose.isInvalid())
10126  SecondOpen = SourceLocation();
10127  S.Diag(UO->getOperatorLoc(), diag::note_logical_not_silence_with_parens)
10128  << FixItHint::CreateInsertion(SecondOpen, "(")
10129  << FixItHint::CreateInsertion(SecondClose, ")");
10130 }
10131 
10132 // Get the decl for a simple expression: a reference to a variable,
10133 // an implicit C++ field reference, or an implicit ObjC ivar reference.
10135  if (DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E))
10136  return DR->getDecl();
10137  if (ObjCIvarRefExpr *Ivar = dyn_cast<ObjCIvarRefExpr>(E)) {
10138  if (Ivar->isFreeIvar())
10139  return Ivar->getDecl();
10140  }
10141  if (MemberExpr *Mem = dyn_cast<MemberExpr>(E)) {
10142  if (Mem->isImplicitAccess())
10143  return Mem->getMemberDecl();
10144  }
10145  return nullptr;
10146 }
10147 
10148 /// Diagnose some forms of syntactically-obvious tautological comparison.
10150  Expr *LHS, Expr *RHS,
10151  BinaryOperatorKind Opc) {
10152  Expr *LHSStripped = LHS->IgnoreParenImpCasts();
10153  Expr *RHSStripped = RHS->IgnoreParenImpCasts();
10154 
10155  QualType LHSType = LHS->getType();
10156  QualType RHSType = RHS->getType();
10157  if (LHSType->hasFloatingRepresentation() ||
10158  (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)) ||
10159  LHS->getBeginLoc().isMacroID() || RHS->getBeginLoc().isMacroID() ||
10161  return;
10162 
10163  // Comparisons between two array types are ill-formed for operator<=>, so
10164  // we shouldn't emit any additional warnings about it.
10165  if (Opc == BO_Cmp && LHSType->isArrayType() && RHSType->isArrayType())
10166  return;
10167 
10168  // For non-floating point types, check for self-comparisons of the form
10169  // x == x, x != x, x < x, etc. These always evaluate to a constant, and
10170  // often indicate logic errors in the program.
10171  //
10172  // NOTE: Don't warn about comparison expressions resulting from macro
10173  // expansion. Also don't warn about comparisons which are only self
10174  // comparisons within a template instantiation. The warnings should catch
10175  // obvious cases in the definition of the template anyways. The idea is to
10176  // warn when the typed comparison operator will always evaluate to the same
10177  // result.
10178  ValueDecl *DL = getCompareDecl(LHSStripped);
10179  ValueDecl *DR = getCompareDecl(RHSStripped);
10180  if (DL && DR && declaresSameEntity(DL, DR)) {
10181  StringRef Result;
10182  switch (Opc) {
10183  case BO_EQ: case BO_LE: case BO_GE:
10184  Result = "true";
10185  break;
10186  case BO_NE: case BO_LT: case BO_GT:
10187  Result = "false";
10188  break;
10189  case BO_Cmp:
10190  Result = "'std::strong_ordering::equal'";
10191  break;
10192  default:
10193  break;
10194  }
10195  S.DiagRuntimeBehavior(Loc, nullptr,
10196  S.PDiag(diag::warn_comparison_always)
10197  << 0 /*self-comparison*/ << !Result.empty()
10198  << Result);
10199  } else if (DL && DR &&
10200  DL->getType()->isArrayType() && DR->getType()->isArrayType() &&
10201  !DL->isWeak() && !DR->isWeak()) {
10202  // What is it always going to evaluate to?
10203  StringRef Result;
10204  switch(Opc) {
10205  case BO_EQ: // e.g. array1 == array2
10206  Result = "false";
10207  break;
10208  case BO_NE: // e.g. array1 != array2
10209  Result = "true";
10210  break;
10211  default: // e.g. array1 <= array2
10212  // The best we can say is 'a constant'
10213  break;
10214  }
10215  S.DiagRuntimeBehavior(Loc, nullptr,
10216  S.PDiag(diag::warn_comparison_always)
10217  << 1 /*array comparison*/
10218  << !Result.empty() << Result);
10219  }
10220 
10221  if (isa<CastExpr>(LHSStripped))
10222  LHSStripped = LHSStripped->IgnoreParenCasts();
10223  if (isa<CastExpr>(RHSStripped))
10224  RHSStripped = RHSStripped->IgnoreParenCasts();
10225 
10226  // Warn about comparisons against a string constant (unless the other
10227  // operand is null); the user probably wants strcmp.
10228  Expr *LiteralString = nullptr;
10229  Expr *LiteralStringStripped = nullptr;
10230  if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
10231  !RHSStripped->isNullPointerConstant(S.Context,
10233  LiteralString = LHS;
10234  LiteralStringStripped = LHSStripped;
10235  } else if ((isa<StringLiteral>(RHSStripped) ||
10236  isa<ObjCEncodeExpr>(RHSStripped)) &&
10237  !LHSStripped->isNullPointerConstant(S.Context,
10239  LiteralString = RHS;
10240  LiteralStringStripped = RHSStripped;
10241  }
10242 
10243  if (LiteralString) {
10244  S.DiagRuntimeBehavior(Loc, nullptr,
10245  S.PDiag(diag::warn_stringcompare)
10246  << isa<ObjCEncodeExpr>(LiteralStringStripped)
10247  << LiteralString->getSourceRange());
10248  }
10249 }
10250 
10252  switch (CK) {
10253  default: {
10254 #ifndef NDEBUG
10255  llvm::errs() << "unhandled cast kind: " << CastExpr::getCastKindName(CK)
10256  << "\n";
10257 #endif
10258  llvm_unreachable("unhandled cast kind");
10259  }
10260  case CK_UserDefinedConversion:
10261  return ICK_Identity;
10262  case CK_LValueToRValue:
10263  return ICK_Lvalue_To_Rvalue;
10264  case CK_ArrayToPointerDecay:
10265  return ICK_Array_To_Pointer;
10266  case CK_FunctionToPointerDecay:
10267  return ICK_Function_To_Pointer;
10268  case CK_IntegralCast:
10269  return ICK_Integral_Conversion;
10270  case CK_FloatingCast:
10271  return ICK_Floating_Conversion;
10272  case CK_IntegralToFloating:
10273  case CK_FloatingToIntegral:
10274  return ICK_Floating_Integral;
10275  case CK_IntegralComplexCast:
10276  case CK_FloatingComplexCast:
10277  case CK_FloatingComplexToIntegralComplex:
10278  case CK_IntegralComplexToFloatingComplex:
10279  return ICK_Complex_Conversion;
10280  case CK_FloatingComplexToReal:
10281  case CK_FloatingRealToComplex:
10282  case CK_IntegralComplexToReal:
10283  case CK_IntegralRealToComplex:
10284  return ICK_Complex_Real;
10285  }
10286 }
10287 
10289  QualType FromType,
10290  SourceLocation Loc) {
10291  // Check for a narrowing implicit conversion.
10294  SCS.setToType(0, FromType);
10295  SCS.setToType(1, ToType);
10296  if (const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
10297  SCS.Second = castKindToImplicitConversionKind(ICE->getCastKind());
10298 
10299  APValue PreNarrowingValue;
10300  QualType PreNarrowingType;
10301  switch (SCS.getNarrowingKind(S.Context, E, PreNarrowingValue,
10302  PreNarrowingType,
10303  /*IgnoreFloatToIntegralConversion*/ true)) {
10305  // Implicit conversion to a narrower type, but the expression is
10306  // value-dependent so we can't tell whether it's actually narrowing.
10307  case NK_Not_Narrowing:
10308  return false;
10309 
10310  case NK_Constant_Narrowing:
10311  // Implicit conversion to a narrower type, and the value is not a constant
10312  // expression.
10313  S.Diag(E->getBeginLoc(), diag::err_spaceship_argument_narrowing)
10314  << /*Constant*/ 1
10315  << PreNarrowingValue.getAsString(S.Context, PreNarrowingType) << ToType;
10316  return true;
10317 
10318  case NK_Variable_Narrowing:
10319  // Implicit conversion to a narrower type, and the value is not a constant
10320  // expression.
10321  case NK_Type_Narrowing:
10322  S.Diag(E->getBeginLoc(), diag::err_spaceship_argument_narrowing)
10323  << /*Constant*/ 0 << FromType << ToType;
10324  // TODO: It's not a constant expression, but what if the user intended it
10325  // to be? Can we produce notes to help them figure out why it isn't?
10326  return true;
10327  }
10328  llvm_unreachable("unhandled case in switch");
10329 }
10330 
10332  ExprResult &LHS,
10333  ExprResult &RHS,
10334  SourceLocation Loc) {
10335  using CCT = ComparisonCategoryType;
10336 
10337  QualType LHSType = LHS.get()->getType();
10338  QualType RHSType = RHS.get()->getType();
10339  // Dig out the original argument type and expression before implicit casts
10340  // were applied. These are the types/expressions we need to check the
10341  // [expr.spaceship] requirements against.
10342  ExprResult LHSStripped = LHS.get()->IgnoreParenImpCasts();
10343  ExprResult RHSStripped = RHS.get()->IgnoreParenImpCasts();
10344  QualType LHSStrippedType = LHSStripped.get()->getType();
10345  QualType RHSStrippedType = RHSStripped.get()->getType();
10346 
10347  // C++2a [expr.spaceship]p3: If one of the operands is of type bool and the
10348  // other is not, the program is ill-formed.
10349  if (LHSStrippedType->isBooleanType() != RHSStrippedType->isBooleanType()) {
10350  S.InvalidOperands(Loc, LHSStripped, RHSStripped);
10351  return QualType();
10352  }
10353 
10354  int NumEnumArgs = (int)LHSStrippedType->isEnumeralType() +
10355  RHSStrippedType->isEnumeralType();
10356  if (NumEnumArgs == 1) {
10357  bool LHSIsEnum = LHSStrippedType->isEnumeralType();
10358  QualType OtherTy = LHSIsEnum ? RHSStrippedType : LHSStrippedType;
10359  if (OtherTy->hasFloatingRepresentation()) {
10360  S.InvalidOperands(Loc, LHSStripped, RHSStripped);
10361  return QualType();
10362  }
10363  }
10364  if (NumEnumArgs == 2) {
10365  // C++2a [expr.spaceship]p5: If both operands have the same enumeration
10366  // type E, the operator yields the result of converting the operands
10367  // to the underlying type of E and applying <=> to the converted operands.
10368  if (!S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) {
10369  S.InvalidOperands(Loc, LHS, RHS);
10370  return QualType();
10371  }
10372  QualType IntType =
10373  LHSStrippedType->getAs<EnumType>()->getDecl()->getIntegerType();
10374  assert(IntType->isArithmeticType());
10375 
10376  // We can't use `CK_IntegralCast` when the underlying type is 'bool', so we
10377  // promote the boolean type, and all other promotable integer types, to
10378  // avoid this.
10379  if (IntType->isPromotableIntegerType())
10380  IntType = S.Context.getPromotedIntegerType(IntType);
10381 
10382  LHS = S.ImpCastExprToType(LHS.get(), IntType, CK_IntegralCast);
10383  RHS = S.ImpCastExprToType(RHS.get(), IntType, CK_IntegralCast);
10384  LHSType = RHSType = IntType;
10385  }
10386 
10387  // C++2a [expr.spaceship]p4: If both operands have arithmetic types, the
10388  // usual arithmetic conversions are applied to the operands.
10390  if (LHS.isInvalid() || RHS.isInvalid())
10391  return QualType();
10392  if (Type.isNull())
10393  return S.InvalidOperands(Loc, LHS, RHS);
10394  assert(Type->isArithmeticType() || Type->isEnumeralType());
10395 
10396  bool HasNarrowing = checkThreeWayNarrowingConversion(
10397  S, Type, LHS.get(), LHSType, LHS.get()->getBeginLoc());
10398  HasNarrowing |= checkThreeWayNarrowingConversion(S, Type, RHS.get(), RHSType,
10399  RHS.get()->getBeginLoc());
10400  if (HasNarrowing)
10401  return QualType();
10402 
10403  assert(!Type.isNull() && "composite type for <=> has not been set");
10404 
10405  auto TypeKind = [&]() {
10406  if (const ComplexType *CT = Type->getAs<ComplexType>()) {
10407  if (CT->getElementType()->hasFloatingRepresentation())
10408  return CCT::WeakEquality;
10409  return CCT::StrongEquality;
10410  }
10411  if (Type->isIntegralOrEnumerationType())
10412  return CCT::StrongOrdering;
10413  if (Type->hasFloatingRepresentation())
10414  return CCT::PartialOrdering;
10415  llvm_unreachable("other types are unimplemented");
10416  }();
10417 
10418  return S.CheckComparisonCategoryType(TypeKind, Loc);
10419 }
10420 
10422  ExprResult &RHS,
10423  SourceLocation Loc,
10424  BinaryOperatorKind Opc) {
10425  if (Opc == BO_Cmp)
10426  return checkArithmeticOrEnumeralThreeWayCompare(S, LHS, RHS, Loc);
10427 
10428  // C99 6.5.8p3 / C99 6.5.9p4
10430  if (LHS.isInvalid() || RHS.isInvalid())
10431  return QualType();
10432  if (Type.isNull())
10433  return S.InvalidOperands(Loc, LHS, RHS);
10434  assert(Type->isArithmeticType() || Type->isEnumeralType());
10435 
10436  checkEnumComparison(S, Loc, LHS.get(), RHS.get());
10437 
10439  return S.InvalidOperands(Loc, LHS, RHS);
10440 
10441  // Check for comparisons of floating point operands using != and ==.
10443  S.CheckFloatComparison(Loc, LHS.get(), RHS.get());
10444 
10445  // The result of comparisons is 'bool' in C++, 'int' in C.
10446  return S.Context.getLogicalOperationType();
10447 }
10448 
10449 // C99 6.5.8, C++ [expr.rel]
10451  SourceLocation Loc,
10452  BinaryOperatorKind Opc) {
10453  bool IsRelational = BinaryOperator::isRelationalOp(Opc);
10454  bool IsThreeWay = Opc == BO_Cmp;
10455  auto IsAnyPointerType = [](ExprResult E) {
10456  QualType Ty = E.get()->getType();
10457  return Ty->isPointerType() || Ty->isMemberPointerType();
10458  };
10459 
10460  // C++2a [expr.spaceship]p6: If at least one of the operands is of pointer
10461  // type, array-to-pointer, ..., conversions are performed on both operands to
10462  // bring them to their composite type.
10463  // Otherwise, all comparisons expect an rvalue, so convert to rvalue before
10464  // any type-related checks.
10465  if (!IsThreeWay || IsAnyPointerType(LHS) || IsAnyPointerType(RHS)) {
10466  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
10467  if (LHS.isInvalid())
10468  return QualType();
10469  RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
10470  if (RHS.isInvalid())
10471  return QualType();
10472  } else {
10473  LHS = DefaultLvalueConversion(LHS.get());
10474  if (LHS.isInvalid())
10475  return QualType();
10476  RHS = DefaultLvalueConversion(RHS.get());
10477  if (RHS.isInvalid())
10478  return QualType();
10479  }
10480 
10481  checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/true);
10482 
10483  // Handle vector comparisons separately.
10484  if (LHS.get()->getType()->isVectorType() ||
10485  RHS.get()->getType()->isVectorType())
10486  return CheckVectorCompareOperands(LHS, RHS, Loc, Opc);
10487 
10488  diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);
10489  diagnoseTautologicalComparison(*this, Loc, LHS.get(), RHS.get(), Opc);
10490 
10491  QualType LHSType = LHS.get()->getType();
10492  QualType RHSType = RHS.get()->getType();
10493  if ((LHSType->isArithmeticType() || LHSType->isEnumeralType()) &&
10494  (RHSType->isArithmeticType() || RHSType->isEnumeralType()))
10495  return checkArithmeticOrEnumeralCompare(*this, LHS, RHS, Loc, Opc);
10496 
10497  const Expr::NullPointerConstantKind LHSNullKind =
10498  LHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
10499  const Expr::NullPointerConstantKind RHSNullKind =
10500  RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
10501  bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull;
10502  bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull;
10503 
10504  auto computeResultTy = [&]() {
10505  if (Opc != BO_Cmp)
10506  return Context.getLogicalOperationType();
10507  assert(getLangOpts().CPlusPlus);
10508  assert(Context.hasSameType(LHS.get()->getType(), RHS.get()->getType()));
10509 
10510  QualType CompositeTy = LHS.get()->getType();
10511  assert(!CompositeTy->isReferenceType());
10512 
10513  auto buildResultTy = [&](ComparisonCategoryType Kind) {
10514  return CheckComparisonCategoryType(Kind, Loc);
10515  };
10516 
10517  // C++2a [expr.spaceship]p7: If the composite pointer type is a function
10518  // pointer type, a pointer-to-member type, or std::nullptr_t, the
10519  // result is of type std::strong_equality
10520  if (CompositeTy->isFunctionPointerType() ||
10521  CompositeTy->isMemberPointerType() || CompositeTy->isNullPtrType())
10522  // FIXME: consider making the function pointer case produce
10523  // strong_ordering not strong_equality, per P0946R0-Jax18 discussion
10524  // and direction polls
10525  return buildResultTy(ComparisonCategoryType::StrongEquality);
10526 
10527  // C++2a [expr.spaceship]p8: If the composite pointer type is an object
10528  // pointer type, p <=> q is of type std::strong_ordering.
10529  if (CompositeTy->isPointerType()) {
10530  // P0946R0: Comparisons between a null pointer constant and an object
10531  // pointer result in std::strong_equality
10532  if (LHSIsNull != RHSIsNull)
10533  return buildResultTy(ComparisonCategoryType::StrongEquality);
10534  return buildResultTy(ComparisonCategoryType::StrongOrdering);
10535  }
10536  // C++2a [expr.spaceship]p9: Otherwise, the program is ill-formed.
10537  // TODO: Extend support for operator<=> to ObjC types.
10538  return InvalidOperands(Loc, LHS, RHS);
10539  };
10540 
10541 
10542  if (!IsRelational && LHSIsNull != RHSIsNull) {
10543  bool IsEquality = Opc == BO_EQ;
10544  if (RHSIsNull)
10545  DiagnoseAlwaysNonNullPointer(LHS.get(), RHSNullKind, IsEquality,
10546  RHS.get()->getSourceRange());
10547  else
10548  DiagnoseAlwaysNonNullPointer(RHS.get(), LHSNullKind, IsEquality,
10549  LHS.get()->getSourceRange());
10550  }
10551 
10552  if ((LHSType->isIntegerType() && !LHSIsNull) ||
10553  (RHSType->isIntegerType() && !RHSIsNull)) {
10554  // Skip normal pointer conversion checks in this case; we have better
10555  // diagnostics for this below.
10556  } else if (getLangOpts().CPlusPlus) {
10557  // Equality comparison of a function pointer to a void pointer is invalid,
10558  // but we allow it as an extension.
10559  // FIXME: If we really want to allow this, should it be part of composite
10560  // pointer type computation so it works in conditionals too?
10561  if (!IsRelational &&
10562  ((LHSType->isFunctionPointerType() && RHSType->isVoidPointerType()) ||
10563  (RHSType->isFunctionPointerType() && LHSType->isVoidPointerType()))) {
10564  // This is a gcc extension compatibility comparison.
10565  // In a SFINAE context, we treat this as a hard error to maintain
10566  // conformance with the C++ standard.
10568  *this, Loc, LHS, RHS, /*isError*/ (bool)isSFINAEContext());
10569 
10570  if (isSFINAEContext())
10571  return QualType();
10572 
10573  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
10574  return computeResultTy();
10575  }
10576 
10577  // C++ [expr.eq]p2:
10578  // If at least one operand is a pointer [...] bring them to their
10579  // composite pointer type.
10580  // C++ [expr.spaceship]p6
10581  // If at least one of the operands is of pointer type, [...] bring them
10582  // to their composite pointer type.
10583  // C++ [expr.rel]p2:
10584  // If both operands are pointers, [...] bring them to their composite
10585  // pointer type.
10586  if ((int)LHSType->isPointerType() + (int)RHSType->isPointerType() >=
10587  (IsRelational ? 2 : 1) &&
10588  (!LangOpts.ObjCAutoRefCount || !(LHSType->isObjCObjectPointerType() ||
10589  RHSType->isObjCObjectPointerType()))) {
10590  if (convertPointersToCompositeType(*this, Loc, LHS, RHS))
10591  return QualType();
10592  return computeResultTy();
10593  }
10594  } else if (LHSType->isPointerType() &&
10595  RHSType->isPointerType()) { // C99 6.5.8p2
10596  // All of the following pointer-related warnings are GCC extensions, except
10597  // when handling null pointer constants.
10598  QualType LCanPointeeTy =
10599  LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
10600  QualType RCanPointeeTy =
10601  RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
10602 
10603  // C99 6.5.9p2 and C99 6.5.8p2
10604  if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
10605  RCanPointeeTy.getUnqualifiedType())) {
10606  // Valid unless a relational comparison of function pointers
10607  if (IsRelational && LCanPointeeTy->isFunctionType()) {
10608  Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers)
10609  << LHSType << RHSType << LHS.get()->getSourceRange()
10610  << RHS.get()->getSourceRange();
10611  }
10612  } else if (!IsRelational &&
10613  (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
10614  // Valid unless comparison between non-null pointer and function pointer
10615  if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
10616  && !LHSIsNull && !RHSIsNull)
10617  diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS,
10618  /*isError*/false);
10619  } else {
10620  // Invalid
10621  diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false);
10622  }
10623  if (LCanPointeeTy != RCanPointeeTy) {
10624  // Treat NULL constant as a special case in OpenCL.
10625  if (getLangOpts().OpenCL && !LHSIsNull && !RHSIsNull) {
10626  const PointerType *LHSPtr = LHSType->getAs<PointerType>();
10627  if (!LHSPtr->isAddressSpaceOverlapping(*RHSType->getAs<PointerType>())) {
10628  Diag(Loc,
10629  diag::err_typecheck_op_on_nonoverlapping_address_space_pointers)
10630  << LHSType << RHSType << 0 /* comparison */
10631  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
10632  }
10633  }
10634  LangAS AddrSpaceL = LCanPointeeTy.getAddressSpace();
10635  LangAS AddrSpaceR = RCanPointeeTy.getAddressSpace();
10636  CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
10637  : CK_BitCast;
10638  if (LHSIsNull && !RHSIsNull)
10639  LHS = ImpCastExprToType(LHS.get(), RHSType, Kind);
10640  else
10641  RHS = ImpCastExprToType(RHS.get(), LHSType, Kind);
10642  }
10643  return computeResultTy();
10644  }
10645 
10646  if (getLangOpts().CPlusPlus) {
10647  // C++ [expr.eq]p4:
10648  // Two operands of type std::nullptr_t or one operand of type
10649  // std::nullptr_t and the other a null pointer constant compare equal.
10650  if (!IsRelational && LHSIsNull && RHSIsNull) {
10651  if (LHSType->isNullPtrType()) {
10652  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
10653  return computeResultTy();
10654  }
10655  if (RHSType->isNullPtrType()) {
10656  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
10657  return computeResultTy();
10658  }
10659  }
10660 
10661  // Comparison of Objective-C pointers and block pointers against nullptr_t.
10662  // These aren't covered by the composite pointer type rules.
10663  if (!IsRelational && RHSType->isNullPtrType() &&
10664  (LHSType->isObjCObjectPointerType() || LHSType->isBlockPointerType())) {
10665  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
10666  return computeResultTy();
10667  }
10668  if (!IsRelational && LHSType->isNullPtrType() &&
10669  (RHSType->isObjCObjectPointerType() || RHSType->isBlockPointerType())) {
10670  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
10671  return computeResultTy();
10672  }
10673 
10674  if (IsRelational &&
10675  ((LHSType->isNullPtrType() && RHSType->isPointerType()) ||
10676  (RHSType->isNullPtrType() && LHSType->isPointerType()))) {
10677  // HACK: Relational comparison of nullptr_t against a pointer type is
10678  // invalid per DR583, but we allow it within std::less<> and friends,
10679  // since otherwise common uses of it break.
10680  // FIXME: Consider removing this hack once LWG fixes std::less<> and
10681  // friends to have std::nullptr_t overload candidates.
10682  DeclContext *DC = CurContext;
10683  if (isa<FunctionDecl>(DC))
10684  DC = DC->getParent();
10685  if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
10686  if (CTSD->isInStdNamespace() &&
10687  llvm::StringSwitch<bool>(CTSD->getName())
10688  .Cases("less", "less_equal", "greater", "greater_equal", true)
10689  .Default(false)) {
10690  if (RHSType->isNullPtrType())
10691  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
10692  else
10693  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
10694  return computeResultTy();
10695  }
10696  }
10697  }
10698 
10699  // C++ [expr.eq]p2:
10700  // If at least one operand is a pointer to member, [...] bring them to
10701  // their composite pointer type.
10702  if (!IsRelational &&
10703  (LHSType->isMemberPointerType() || RHSType->isMemberPointerType())) {
10704  if (convertPointersToCompositeType(*this, Loc, LHS, RHS))
10705  return QualType();
10706  else
10707  return computeResultTy();
10708  }
10709  }
10710 
10711  // Handle block pointer types.
10712  if (!IsRelational && LHSType->isBlockPointerType() &&
10713  RHSType->isBlockPointerType()) {
10714  QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType();
10715  QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType();
10716 
10717  if (!LHSIsNull && !RHSIsNull &&
10718  !Context.typesAreCompatible(lpointee, rpointee)) {
10719  Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
10720  << LHSType << RHSType << LHS.get()->getSourceRange()
10721  << RHS.get()->getSourceRange();
10722  }
10723  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
10724  return computeResultTy();
10725  }
10726 
10727  // Allow block pointers to be compared with null pointer constants.
10728  if (!IsRelational
10729  && ((LHSType->isBlockPointerType() && RHSType->isPointerType())
10730  || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
10731  if (!LHSIsNull && !RHSIsNull) {
10732  if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>()
10733  ->getPointeeType()->isVoidType())
10734  || (LHSType->isPointerType() && LHSType->castAs<PointerType>()
10735  ->getPointeeType()->isVoidType())))
10736  Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
10737  << LHSType << RHSType << LHS.get()->getSourceRange()
10738  << RHS.get()->getSourceRange();
10739  }
10740  if (LHSIsNull && !RHSIsNull)
10741  LHS = ImpCastExprToType(LHS.get(), RHSType,
10742  RHSType->isPointerType() ? CK_BitCast
10743  : CK_AnyPointerToBlockPointerCast);
10744  else
10745  RHS = ImpCastExprToType(RHS.get(), LHSType,
10746  LHSType->isPointerType() ? CK_BitCast
10747  : CK_AnyPointerToBlockPointerCast);
10748  return computeResultTy();
10749  }
10750 
10751  if (LHSType->isObjCObjectPointerType() ||
10752  RHSType->isObjCObjectPointerType()) {
10753  const PointerType *LPT = LHSType->getAs<PointerType>();
10754  const PointerType *RPT = RHSType->getAs<PointerType>();
10755  if (LPT || RPT) {
10756  bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false;
10757  bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false;
10758 
10759  if (!LPtrToVoid && !RPtrToVoid &&
10760  !Context.typesAreCompatible(LHSType, RHSType)) {
10761  diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
10762  /*isError*/false);
10763  }
10764  if (LHSIsNull && !RHSIsNull) {
10765  Expr *E = LHS.get();
10766  if (getLangOpts().ObjCAutoRefCount)
10767  CheckObjCConversion(SourceRange(), RHSType, E,
10768  CCK_ImplicitConversion);
10769  LHS = ImpCastExprToType(E, RHSType,
10770  RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
10771  }
10772  else {
10773  Expr *E = RHS.get();
10774  if (getLangOpts().ObjCAutoRefCount)
10775  CheckObjCConversion(SourceRange(), LHSType, E, CCK_ImplicitConversion,
10776  /*Diagnose=*/true,
10777  /*DiagnoseCFAudited=*/false, Opc);
10778  RHS = ImpCastExprToType(E, LHSType,
10779  LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
10780  }
10781  return computeResultTy();
10782  }
10783  if (LHSType->isObjCObjectPointerType() &&
10784  RHSType->isObjCObjectPointerType()) {
10785  if (!Context.areComparableObjCPointerTypes(LHSType, RHSType))
10786  diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
10787  /*isError*/false);
10788  if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS))
10789  diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc);
10790 
10791  if (LHSIsNull && !RHSIsNull)
10792  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
10793  else
10794  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
10795  return computeResultTy();
10796  }
10797 
10798  if (!IsRelational && LHSType->isBlockPointerType() &&
10799  RHSType->isBlockCompatibleObjCPointerType(Context)) {
10800  LHS = ImpCastExprToType(LHS.get(), RHSType,
10801  CK_BlockPointerToObjCPointerCast);
10802  return computeResultTy();
10803  } else if (!IsRelational &&
10804  LHSType->isBlockCompatibleObjCPointerType(Context) &&
10805  RHSType->isBlockPointerType()) {
10806  RHS = ImpCastExprToType(RHS.get(), LHSType,
10807  CK_BlockPointerToObjCPointerCast);
10808  return computeResultTy();
10809  }
10810  }
10811  if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) ||
10812  (LHSType->isIntegerType() && RHSType->isAnyPointerType())) {
10813  unsigned DiagID = 0;
10814  bool isError = false;
10815  if (LangOpts.DebuggerSupport) {
10816  // Under a debugger, allow the comparison of pointers to integers,
10817  // since users tend to want to compare addresses.
10818  } else if ((LHSIsNull && LHSType->isIntegerType()) ||
10819  (RHSIsNull && RHSType->isIntegerType())) {
10820  if (IsRelational) {
10821  isError = getLangOpts().CPlusPlus;
10822  DiagID =
10823  isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
10824  : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
10825  }
10826  } else if (getLangOpts().CPlusPlus) {
10827  DiagID = diag::err_typecheck_comparison_of_pointer_integer;
10828  isError = true;
10829  } else if (IsRelational)
10830  DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
10831  else
10832  DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
10833 
10834  if (DiagID) {
10835  Diag(Loc, DiagID)
10836  << LHSType << RHSType << LHS.get()->getSourceRange()
10837  << RHS.get()->getSourceRange();
10838  if (isError)
10839  return QualType();
10840  }
10841 
10842  if (LHSType->isIntegerType())
10843  LHS = ImpCastExprToType(LHS.get(), RHSType,
10844  LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
10845  else
10846  RHS = ImpCastExprToType(RHS.get(), LHSType,
10847  RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
10848  return computeResultTy();
10849  }
10850 
10851  // Handle block pointers.
10852  if (!IsRelational && RHSIsNull
10853  && LHSType->isBlockPointerType() && RHSType->isIntegerType()) {
10854  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
10855  return computeResultTy();
10856  }
10857  if (!IsRelational && LHSIsNull
10858  && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
10859  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
10860  return computeResultTy();
10861  }
10862 
10863  if (getLangOpts().OpenCLVersion >= 200 || getLangOpts().OpenCLCPlusPlus) {
10864  if (LHSType->isClkEventT() && RHSType->isClkEventT()) {
10865  return computeResultTy();
10866  }
10867 
10868  if (LHSType->isQueueT() && RHSType->isQueueT()) {
10869  return computeResultTy();
10870  }
10871 
10872  if (LHSIsNull && RHSType->isQueueT()) {
10873  LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
10874  return computeResultTy();
10875  }
10876 
10877  if (LHSType->isQueueT() && RHSIsNull) {
10878  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
10879  return computeResultTy();
10880  }
10881  }
10882 
10883  return InvalidOperands(Loc, LHS, RHS);
10884 }
10885 
10886 // Return a signed ext_vector_type that is of identical size and number of
10887 // elements. For floating point vectors, return an integer type of identical
10888 // size and number of elements. In the non ext_vector_type case, search from
10889 // the largest type to the smallest type to avoid cases where long long == long,
10890 // where long gets picked over long long.
10892  const VectorType *VTy = V->getAs<VectorType>();
10893  unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
10894 
10895  if (isa<ExtVectorType>(VTy)) {
10896  if (TypeSize == Context.getTypeSize(Context.CharTy))
10897  return Context.getExtVectorType(Context.CharTy, VTy->getNumElements());
10898  else if (TypeSize == Context.getTypeSize(Context.ShortTy))
10899  return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements());
10900  else if (TypeSize == Context.getTypeSize(Context.IntTy))
10901  return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
10902  else if (TypeSize == Context.getTypeSize(Context.LongTy))
10903  return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
10904  assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
10905  "Unhandled vector element size in vector compare");
10906  return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
10907  }
10908 
10909  if (TypeSize == Context.getTypeSize(Context.LongLongTy))
10910  return Context.getVectorType(Context.LongLongTy, VTy->getNumElements(),
10912  else if (TypeSize == Context.getTypeSize(Context.LongTy))
10913  return Context.getVectorType(Context.LongTy, VTy->getNumElements(),
10915  else if (TypeSize == Context.getTypeSize(Context.IntTy))
10916  return Context.getVectorType(Context.IntTy, VTy->getNumElements(),
10918  else if (TypeSize == Context.getTypeSize(Context.ShortTy))
10919  return Context.getVectorType(Context.ShortTy, VTy->getNumElements(),
10921  assert(TypeSize == Context.getTypeSize(Context.CharTy) &&
10922  "Unhandled vector element size in vector compare");
10923  return Context.getVectorType(Context.CharTy, VTy->getNumElements(),
10925 }
10926 
10927 /// CheckVectorCompareOperands - vector comparisons are a clang extension that
10928 /// operates on extended vector types. Instead of producing an IntTy result,
10929 /// like a scalar comparison, a vector comparison produces a vector of integer
10930 /// types.
10932  SourceLocation Loc,
10933  BinaryOperatorKind Opc) {
10934  // Check to make sure we're operating on vectors of the same type and width,
10935  // Allowing one side to be a scalar of element type.
10936  QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false,
10937  /*AllowBothBool*/true,
10938  /*AllowBoolConversions*/getLangOpts().ZVector);
10939  if (vType.isNull())
10940  return vType;
10941 
10942  QualType LHSType = LHS.get()->getType();
10943 
10944  // If AltiVec, the comparison results in a numeric type, i.e.
10945  // bool for C++, int for C
10946  if (getLangOpts().AltiVec &&
10948  return Context.getLogicalOperationType();
10949 
10950  // For non-floating point types, check for self-comparisons of the form
10951  // x == x, x != x, x < x, etc. These always evaluate to a constant, and
10952  // often indicate logic errors in the program.
10953  diagnoseTautologicalComparison(*this, Loc, LHS.get(), RHS.get(), Opc);
10954 
10955  // Check for comparisons of floating point operands using != and ==.
10956  if (BinaryOperator::isEqualityOp(Opc) &&
10957  LHSType->hasFloatingRepresentation()) {
10958  assert(RHS.get()->getType()->hasFloatingRepresentation());
10959  CheckFloatComparison(Loc, LHS.get(), RHS.get());
10960  }
10961 
10962  // Return a signed type for the vector.
10963  return GetSignedVectorType(vType);
10964 }
10965 
10967  SourceLocation Loc) {
10968  // Ensure that either both operands are of the same vector type, or
10969  // one operand is of a vector type and the other is of its element type.
10970  QualType vType = CheckVectorOperands(LHS, RHS, Loc, false,
10971  /*AllowBothBool*/true,
10972  /*AllowBoolConversions*/false);
10973  if (vType.isNull())
10974  return InvalidOperands(Loc, LHS, RHS);
10975  if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion < 120 &&
10976  !getLangOpts().OpenCLCPlusPlus && vType->hasFloatingRepresentation())
10977  return InvalidOperands(Loc, LHS, RHS);
10978  // FIXME: The check for C++ here is for GCC compatibility. GCC rejects the
10979  // usage of the logical operators && and || with vectors in C. This
10980  // check could be notionally dropped.
10981  if (!getLangOpts().CPlusPlus &&
10982  !(isa<ExtVectorType>(vType->getAs<VectorType>())))
10983  return InvalidLogicalVectorOperands(Loc, LHS, RHS);
10984 
10985  return GetSignedVectorType(LHS.get()->getType());
10986 }
10987 
10989  SourceLocation Loc,
10990  BinaryOperatorKind Opc) {
10991  checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
10992 
10993  bool IsCompAssign =
10994  Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign;
10995 
10996  if (LHS.get()->getType()->isVectorType() ||
10997  RHS.get()->getType()->isVectorType()) {
10998  if (LHS.get()->getType()->hasIntegerRepresentation() &&
10999  RHS.get()->getType()->hasIntegerRepresentation())
11000  return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
11001  /*AllowBothBool*/true,
11002  /*AllowBoolConversions*/getLangOpts().ZVector);
11003  return InvalidOperands(Loc, LHS, RHS);
11004  }
11005 
11006  if (Opc == BO_And)
11007  diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);
11008 
11009  ExprResult LHSResult = LHS, RHSResult = RHS;
11010  QualType compType = UsualArithmeticConversions(LHSResult, RHSResult,
11011  IsCompAssign);
11012  if (LHSResult.isInvalid() || RHSResult.isInvalid())
11013  return QualType();
11014  LHS = LHSResult.get();
11015  RHS = RHSResult.get();
11016 
11017  if (!compType.isNull() && compType->isIntegralOrUnscopedEnumerationType())
11018  return compType;
11019  return InvalidOperands(Loc, LHS, RHS);
11020 }
11021 
11022 // C99 6.5.[13,14]
11024  SourceLocation Loc,
11025  BinaryOperatorKind Opc) {
11026  // Check vector operands differently.
11027  if (LHS.get()->getType()->isVectorType() || RHS.get()->getType()->isVectorType())
11028  return CheckVectorLogicalOperands(LHS, RHS, Loc);
11029 
11030  // Diagnose cases where the user write a logical and/or but probably meant a
11031  // bitwise one. We do this when the LHS is a non-bool integer and the RHS
11032  // is a constant.
11033  if (LHS.get()->getType()->isIntegerType() &&
11034  !LHS.get()->getType()->isBooleanType() &&
11035  RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() &&
11036  // Don't warn in macros or template instantiations.
11037  !Loc.isMacroID() && !inTemplateInstantiation()) {
11038  // If the RHS can be constant folded, and if it constant folds to something
11039  // that isn't 0 or 1 (which indicate a potential logical operation that
11040  // happened to fold to true/false) then warn.
11041  // Parens on the RHS are ignored.
11042  Expr::EvalResult EVResult;
11043  if (RHS.get()->EvaluateAsInt(EVResult, Context)) {
11044  llvm::APSInt Result = EVResult.Val.getInt();
11045  if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType() &&
11046  !RHS.get()->getExprLoc().isMacroID()) ||
11047  (Result != 0 && Result != 1)) {
11048  Diag(Loc, diag::warn_logical_instead_of_bitwise)
11049  << RHS.get()->getSourceRange()
11050  << (Opc == BO_LAnd ? "&&" : "||");
11051  // Suggest replacing the logical operator with the bitwise version
11052  Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator)
11053  << (Opc == BO_LAnd ? "&" : "|")
11055  Loc, getLocForEndOfToken(Loc)),
11056  Opc == BO_LAnd ? "&" : "|");
11057  if (Opc == BO_LAnd)
11058  // Suggest replacing "Foo() && kNonZero" with "Foo()"
11059  Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant)
11061  SourceRange(getLocForEndOfToken(LHS.get()->getEndLoc()),
11062  RHS.get()->getEndLoc()));
11063  }
11064  }
11065  }
11066 
11067  if (!Context.getLangOpts().CPlusPlus) {
11068  // OpenCL v1.1 s6.3.g: The logical operators and (&&), or (||) do
11069  // not operate on the built-in scalar and vector float types.
11070  if (Context.getLangOpts().OpenCL &&
11071  Context.getLangOpts().OpenCLVersion < 120) {
11072  if (LHS.get()->getType()->isFloatingType() ||
11073  RHS.get()->getType()->isFloatingType())
11074  return InvalidOperands(Loc, LHS, RHS);
11075  }
11076 
11077  LHS = UsualUnaryConversions(LHS.get());
11078  if (LHS.isInvalid())
11079  return QualType();
11080 
11081  RHS = UsualUnaryConversions(RHS.get());
11082  if (RHS.isInvalid())
11083  return QualType();
11084 
11085  if (!LHS.get()->getType()->isScalarType() ||
11086  !RHS.get()->getType()->isScalarType())
11087  return InvalidOperands(Loc, LHS, RHS);
11088 
11089  return Context.IntTy;
11090  }
11091 
11092  // The following is safe because we only use this method for
11093  // non-overloadable operands.
11094 
11095  // C++ [expr.log.and]p1
11096  // C++ [expr.log.or]p1
11097  // The operands are both contextually converted to type bool.
11098  ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get());
11099  if (LHSRes.isInvalid())
11100  return InvalidOperands(Loc, LHS, RHS);
11101  LHS = LHSRes;
11102 
11103  ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get());
11104  if (RHSRes.isInvalid())
11105  return InvalidOperands(Loc, LHS, RHS);
11106  RHS = RHSRes;
11107 
11108  // C++ [expr.log.and]p2
11109  // C++ [expr.log.or]p2
11110  // The result is a bool.
11111  return Context.BoolTy;
11112 }
11113 
11114 static bool IsReadonlyMessage(Expr *E, Sema &S) {
11115  const MemberExpr *ME = dyn_cast<MemberExpr>(E);
11116  if (!ME) return false;
11117  if (!isa<FieldDecl>(ME->getMemberDecl())) return false;
11118  ObjCMessageExpr *Base = dyn_cast<ObjCMessageExpr>(
11120  if (!Base) return false;
11121  return Base->getMethodDecl() != nullptr;
11122 }
11123 
11124 /// Is the given expression (which must be 'const') a reference to a
11125 /// variable which was originally non-const, but which has become
11126 /// 'const' due to being captured within a block?
11129  assert(E->isLValue() && E->getType().isConstQualified());
11130  E = E->IgnoreParens();
11131 
11132  // Must be a reference to a declaration from an enclosing scope.
11133  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
11134  if (!DRE) return NCCK_None;
11135  if (!DRE->refersToEnclosingVariableOrCapture()) return NCCK_None;
11136 
11137  // The declaration must be a variable which is not declared 'const'.
11138  VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
11139  if (!var) return NCCK_None;
11140  if (var->getType().isConstQualified()) return NCCK_None;
11141  assert(var->hasLocalStorage() && "capture added 'const' to non-local?");
11142 
11143  // Decide whether the first capture was for a block or a lambda.
11144  DeclContext *DC = S.CurContext, *Prev = nullptr;
11145  // Decide whether the first capture was for a block or a lambda.
11146  while (DC) {
11147  // For init-capture, it is possible that the variable belongs to the
11148  // template pattern of the current context.
11149  if (auto *FD = dyn_cast<FunctionDecl>(DC))
11150  if (var->isInitCapture() &&
11151  FD->getTemplateInstantiationPattern() == var->getDeclContext())
11152  break;
11153  if (DC == var->getDeclContext())
11154  break;
11155  Prev = DC;
11156  DC = DC->getParent();
11157  }
11158  // Unless we have an init-capture, we've gone one step too far.
11159  if (!var->isInitCapture())
11160  DC = Prev;
11161  return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda);
11162 }
11163 
11164 static bool IsTypeModifiable(QualType Ty, bool IsDereference) {
11165  Ty = Ty.getNonReferenceType();
11166  if (IsDereference && Ty->isPointerType())
11167  Ty = Ty->getPointeeType();
11168  return !Ty.isConstQualified();
11169 }
11170 
11171 // Update err_typecheck_assign_const and note_typecheck_assign_const
11172 // when this enum is changed.
11173 enum {
11179  ConstUnknown, // Keep as last element
11180 };
11181 
11182 /// Emit the "read-only variable not assignable" error and print notes to give
11183 /// more information about why the variable is not assignable, such as pointing
11184 /// to the declaration of a const variable, showing that a method is const, or
11185 /// that the function is returning a const reference.
11186 static void DiagnoseConstAssignment(Sema &S, const Expr *E,
11187  SourceLocation Loc) {
11188  SourceRange ExprRange = E->getSourceRange();
11189 
11190  // Only emit one error on the first const found. All other consts will emit
11191  // a note to the error.
11192  bool DiagnosticEmitted = false;
11193 
11194  // Track if the current expression is the result of a dereference, and if the
11195  // next checked expression is the result of a dereference.
11196  bool IsDereference = false;
11197  bool NextIsDereference = false;
11198 
11199  // Loop to process MemberExpr chains.
11200  while (true) {
11201  IsDereference = NextIsDereference;
11202 
11203  E = E->IgnoreImplicit()->IgnoreParenImpCasts();
11204  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
11205  NextIsDereference = ME->isArrow();
11206  const ValueDecl *VD = ME->getMemberDecl();
11207  if (const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
11208  // Mutable fields can be modified even if the class is const.
11209  if (Field->isMutable()) {
11210  assert(DiagnosticEmitted && "Expected diagnostic not emitted.");
11211  break;
11212  }
11213 
11214  if (!IsTypeModifiable(Field->getType(), IsDereference)) {
11215  if (!DiagnosticEmitted) {
11216  S.Diag(Loc, diag::err_typecheck_assign_const)
11217  << ExprRange << ConstMember << false /*static*/ << Field
11218  << Field->getType();
11219  DiagnosticEmitted = true;
11220  }
11221  S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
11222  << ConstMember << false /*static*/ << Field << Field->getType()
11223  << Field->getSourceRange();
11224  }
11225  E = ME->getBase();
11226  continue;
11227  } else if (const VarDecl *VDecl = dyn_cast<VarDecl>(VD)) {
11228  if (VDecl->getType().isConstQualified()) {
11229  if (!DiagnosticEmitted) {
11230  S.Diag(Loc, diag::err_typecheck_assign_const)
11231  << ExprRange << ConstMember << true /*static*/ << VDecl
11232  << VDecl->getType();
11233  DiagnosticEmitted = true;
11234  }
11235  S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
11236  << ConstMember << true /*static*/ << VDecl << VDecl->getType()
11237  << VDecl->getSourceRange();
11238  }
11239  // Static fields do not inherit constness from parents.
11240  break;
11241  }
11242  break; // End MemberExpr
11243  } else if (const ArraySubscriptExpr *ASE =
11244  dyn_cast<ArraySubscriptExpr>(E)) {
11245  E = ASE->getBase()->IgnoreParenImpCasts();
11246  continue;
11247  } else if (const ExtVectorElementExpr *EVE =
11248  dyn_cast<ExtVectorElementExpr>(E)) {
11249  E = EVE->getBase()->IgnoreParenImpCasts();
11250  continue;
11251  }
11252  break;
11253  }
11254 
11255  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
11256  // Function calls
11257  const FunctionDecl *FD = CE->getDirectCallee();
11258  if (FD && !IsTypeModifiable(FD->getReturnType(), IsDereference)) {
11259  if (!DiagnosticEmitted) {
11260  S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
11261  << ConstFunction << FD;
11262  DiagnosticEmitted = true;
11263  }
11265  diag::note_typecheck_assign_const)
11266  << ConstFunction << FD << FD->getReturnType()
11267  << FD->getReturnTypeSourceRange();
11268  }
11269  } else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
11270  // Point to variable declaration.
11271  if (const ValueDecl *VD = DRE->getDecl()) {
11272  if (!IsTypeModifiable(VD->getType(), IsDereference)) {
11273  if (!DiagnosticEmitted) {
11274  S.Diag(Loc, diag::err_typecheck_assign_const)
11275  << ExprRange << ConstVariable << VD << VD->getType();
11276  DiagnosticEmitted = true;
11277  }
11278  S.Diag(VD->getLocation(), diag::note_typecheck_assign_const)
11279  << ConstVariable << VD << VD->getType() << VD->getSourceRange();
11280  }
11281  }
11282  } else if (isa<CXXThisExpr>(E)) {
11283  if (const DeclContext *DC = S.getFunctionLevelDeclContext()) {
11284  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
11285  if (MD->isConst()) {
11286  if (!DiagnosticEmitted) {
11287  S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
11288  << ConstMethod << MD;
11289  DiagnosticEmitted = true;
11290  }
11291  S.Diag(MD->getLocation(), diag::note_typecheck_assign_const)
11292  << ConstMethod << MD << MD->getSourceRange();
11293  }
11294  }
11295  }
11296  }
11297 
11298  if (DiagnosticEmitted)
11299  return;
11300 
11301  // Can't determine a more specific message, so display the generic error.
11302  S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange << ConstUnknown;
11303 }
11304 
11309 };
11310 
11311 static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD,
11312  const RecordType *Ty,
11313  SourceLocation Loc, SourceRange Range,
11314  OriginalExprKind OEK,
11315  bool &DiagnosticEmitted) {
11316  std::vector<const RecordType *> RecordTypeList;
11317  RecordTypeList.push_back(Ty);
11318  unsigned NextToCheckIndex = 0;
11319  // We walk the record hierarchy breadth-first to ensure that we print
11320  // diagnostics in field nesting order.
11321  while (RecordTypeList.size() > NextToCheckIndex) {
11322  bool IsNested = NextToCheckIndex > 0;
11323  for (const FieldDecl *Field :
11324  RecordTypeList[NextToCheckIndex]->getDecl()->fields()) {
11325  // First, check every field for constness.
11326  QualType FieldTy = Field->getType();
11327  if (FieldTy.isConstQualified()) {
11328  if (!DiagnosticEmitted) {
11329  S.Diag(Loc, diag::err_typecheck_assign_const)
11330  << Range << NestedConstMember << OEK << VD
11331  << IsNested << Field;
11332  DiagnosticEmitted = true;
11333  }
11334  S.Diag(Field->getLocation(), diag::note_typecheck_assign_const)
11335  << NestedConstMember << IsNested << Field
11336  << FieldTy << Field->getSourceRange();
11337  }
11338 
11339  // Then we append it to the list to check next in order.
11340  FieldTy = FieldTy.getCanonicalType();
11341  if (const auto *FieldRecTy = FieldTy->getAs<RecordType>()) {
11342  if (llvm::find(RecordTypeList, FieldRecTy) == RecordTypeList.end())
11343  RecordTypeList.push_back(FieldRecTy);
11344  }
11345  }
11346  ++NextToCheckIndex;
11347  }
11348 }
11349 
11350 /// Emit an error for the case where a record we are trying to assign to has a
11351 /// const-qualified field somewhere in its hierarchy.
11352 static void DiagnoseRecursiveConstFields(Sema &S, const Expr *E,
11353  SourceLocation Loc) {
11354  QualType Ty = E->getType();
11355  assert(Ty->isRecordType() && "lvalue was not record?");
11356  SourceRange Range = E->getSourceRange();
11357  const RecordType *RTy = Ty.getCanonicalType()->getAs<RecordType>();
11358  bool DiagEmitted = false;
11359 
11360  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
11361  DiagnoseRecursiveConstFields(S, ME->getMemberDecl(), RTy, Loc,
11362  Range, OEK_Member, DiagEmitted);
11363  else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
11364  DiagnoseRecursiveConstFields(S, DRE->getDecl(), RTy, Loc,
11365  Range, OEK_Variable, DiagEmitted);
11366  else
11367  DiagnoseRecursiveConstFields(S, nullptr, RTy, Loc,
11368  Range, OEK_LValue, DiagEmitted);
11369  if (!DiagEmitted)
11370  DiagnoseConstAssignment(S, E, Loc);
11371 }
11372 
11373 /// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not,
11374 /// emit an error and return true. If so, return false.
11376  assert(!E->hasPlaceholderType(BuiltinType::PseudoObject));
11377 
11379 
11380  SourceLocation OrigLoc = Loc;
11382  &Loc);
11383  if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
11385  if (IsLV == Expr::MLV_Valid)
11386  return false;
11387 
11388  unsigned DiagID = 0;
11389  bool NeedType = false;
11390  switch (IsLV) { // C99 6.5.16p2
11392  // Use a specialized diagnostic when we're assigning to an object
11393  // from an enclosing function or block.
11395  if (NCCK == NCCK_Block)
11396  DiagID = diag::err_block_decl_ref_not_modifiable_lvalue;
11397  else
11398  DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue;
11399  break;
11400  }
11401 
11402  // In ARC, use some specialized diagnostics for occasions where we
11403  // infer 'const'. These are always pseudo-strong variables.
11404  if (S.getLangOpts().ObjCAutoRefCount) {
11405  DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts());
11406  if (declRef && isa<VarDecl>(declRef->getDecl())) {
11407  VarDecl *var = cast<VarDecl>(declRef->getDecl());
11408 
11409  // Use the normal diagnostic if it's pseudo-__strong but the
11410  // user actually wrote 'const'.
11411  if (var->isARCPseudoStrong() &&
11412  (!var->getTypeSourceInfo() ||
11413  !var->getTypeSourceInfo()->getType().isConstQualified())) {
11414  // There are three pseudo-strong cases:
11415  // - self
11416  ObjCMethodDecl *method = S.getCurMethodDecl();
11417  if (method && var == method->getSelfDecl()) {
11418  DiagID = method->isClassMethod()
11419  ? diag::err_typecheck_arc_assign_self_class_method
11420  : diag::err_typecheck_arc_assign_self;
11421 
11422  // - Objective-C externally_retained attribute.
11423  } else if (var->hasAttr<ObjCExternallyRetainedAttr>() ||
11424  isa<ParmVarDecl>(var)) {
11425  DiagID = diag::err_typecheck_arc_assign_externally_retained;
11426 
11427  // - fast enumeration variables
11428  } else {
11429  DiagID = diag::err_typecheck_arr_assign_enumeration;
11430  }
11431 
11432  SourceRange Assign;
11433  if (Loc != OrigLoc)
11434  Assign = SourceRange(OrigLoc, OrigLoc);
11435  S.Diag(Loc, DiagID) << E->getSourceRange() << Assign;
11436  // We need to preserve the AST regardless, so migration tool
11437  // can do its job.
11438  return false;
11439  }
11440  }
11441  }
11442 
11443  // If none of the special cases above are triggered, then this is a
11444  // simple const assignment.
11445  if (DiagID == 0) {
11446  DiagnoseConstAssignment(S, E, Loc);
11447  return true;
11448  }
11449 
11450  break;
11452  DiagnoseConstAssignment(S, E, Loc);
11453  return true;
11455  DiagnoseRecursiveConstFields(S, E, Loc);
11456  return true;
11457  case Expr::MLV_ArrayType:
11459  DiagID = diag::err_typecheck_array_not_modifiable_lvalue;
11460  NeedType = true;
11461  break;
11463  DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue;
11464  NeedType = true;
11465  break;
11466  case Expr::MLV_LValueCast:
11467  DiagID = diag::err_typecheck_lvalue_casts_not_supported;
11468  break;
11469  case Expr::MLV_Valid:
11470  llvm_unreachable("did not take early return for MLV_Valid");
11474  DiagID = diag::err_typecheck_expression_not_modifiable_lvalue;
11475  break;
11478  return S.RequireCompleteType(Loc, E->getType(),
11479  diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
11481  DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
11482  break;
11484  llvm_unreachable("readonly properties should be processed differently");
11486  DiagID = diag::err_readonly_message_assignment;
11487  break;
11489  DiagID = diag::err_no_subobject_property_setting;
11490  break;
11491  }
11492 
11493  SourceRange Assign;
11494  if (Loc != OrigLoc)
11495  Assign = SourceRange(OrigLoc, OrigLoc);
11496  if (NeedType)
11497  S.Diag(Loc, DiagID) << E->getType() << E->getSourceRange() << Assign;
11498  else
11499  S.Diag(Loc, DiagID) << E->getSourceRange() << Assign;
11500  return true;
11501 }
11502 
11503 static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
11504  SourceLocation Loc,
11505  Sema &Sema) {
11506  if (Sema.inTemplateInstantiation())
11507  return;
11508  if (Sema.isUnevaluatedContext())
11509  return;
11510  if (Loc.isInvalid() || Loc.isMacroID())
11511  return;
11512  if (LHSExpr->getExprLoc().isMacroID() || RHSExpr->getExprLoc().isMacroID())
11513  return;
11514 
11515  // C / C++ fields
11516  MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
11517  MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
11518  if (ML && MR) {
11519  if (!(isa<CXXThisExpr>(ML->getBase()) && isa<CXXThisExpr>(MR->getBase())))
11520  return;
11521  const ValueDecl *LHSDecl =
11522  cast<ValueDecl>(ML->getMemberDecl()->getCanonicalDecl());
11523  const ValueDecl *RHSDecl =
11524  cast<ValueDecl>(MR->getMemberDecl()->getCanonicalDecl());
11525  if (LHSDecl != RHSDecl)
11526  return;
11527  if (LHSDecl->getType().isVolatileQualified())
11528  return;
11529  if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>())
11530  if (RefTy->getPointeeType().isVolatileQualified())
11531  return;
11532 
11533  Sema.Diag(Loc, diag::warn_identity_field_assign) << 0;
11534  }
11535 
11536  // Objective-C instance variables
11537  ObjCIvarRefExpr *OL = dyn_cast<ObjCIvarRefExpr>(LHSExpr);
11538  ObjCIvarRefExpr *OR = dyn_cast<ObjCIvarRefExpr>(RHSExpr);
11539  if (OL && OR && OL->getDecl() == OR->getDecl()) {
11540  DeclRefExpr *RL = dyn_cast<DeclRefExpr>(OL->getBase()->IgnoreImpCasts());
11541  DeclRefExpr *RR = dyn_cast<DeclRefExpr>(OR->getBase()->IgnoreImpCasts());
11542  if (RL && RR && RL->getDecl() == RR->getDecl())
11543  Sema.Diag(Loc, diag::warn_identity_field_assign) << 1;
11544  }
11545 }
11546 
11547 // C99 6.5.16.1
11549  SourceLocation Loc,
11550  QualType CompoundType) {
11551  assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject));
11552 
11553  // Verify that LHS is a modifiable lvalue, and emit error if not.
11554  if (CheckForModifiableLvalue(LHSExpr, Loc, *this))
11555  return QualType();
11556 
11557  QualType LHSType = LHSExpr->getType();
11558  QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() :
11559  CompoundType;
11560  // OpenCL v1.2 s6.1.1.1 p2:
11561  // The half data type can only be used to declare a pointer to a buffer that
11562  // contains half values
11563  if (getLangOpts().OpenCL && !getOpenCLOptions().isEnabled("cl_khr_fp16") &&
11564  LHSType->isHalfType()) {
11565  Diag(Loc, diag::err_opencl_half_load_store) << 1
11566  << LHSType.getUnqualifiedType();
11567  return QualType();
11568  }
11569 
11570  AssignConvertType ConvTy;
11571  if (CompoundType.isNull()) {
11572  Expr *RHSCheck = RHS.get();
11573 
11574  CheckIdentityFieldAssignment(LHSExpr, RHSCheck, Loc, *this);
11575 
11576  QualType LHSTy(LHSType);
11577  ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
11578  if (RHS.isInvalid())
11579  return QualType();
11580  // Special case of NSObject attributes on c-style pointer types.
11581  if (ConvTy == IncompatiblePointer &&
11582  ((Context.isObjCNSObjectType(LHSType) &&
11583  RHSType->isObjCObjectPointerType()) ||
11584  (Context.isObjCNSObjectType(RHSType) &&
11585  LHSType->isObjCObjectPointerType())))
11586  ConvTy = Compatible;
11587 
11588  if (ConvTy == Compatible &&
11589  LHSType->isObjCObjectType())
11590  Diag(Loc, diag::err_objc_object_assignment)
11591  << LHSType;
11592 
11593  // If the RHS is a unary plus or minus, check to see if they = and + are
11594  // right next to each other. If so, the user may have typo'd "x =+ 4"
11595  // instead of "x += 4".
11596  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
11597  RHSCheck = ICE->getSubExpr();
11598  if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
11599  if ((UO->getOpcode() == UO_Plus || UO->getOpcode() == UO_Minus) &&
11600  Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
11601  // Only if the two operators are exactly adjacent.
11602  Loc.getLocWithOffset(1) == UO->getOperatorLoc() &&
11603  // And there is a space or other character before the subexpr of the
11604  // unary +/-. We don't want to warn on "x=-1".
11605  Loc.getLocWithOffset(2) != UO->getSubExpr()->getBeginLoc() &&
11606  UO->getSubExpr()->getBeginLoc().isFileID()) {
11607  Diag(Loc, diag::warn_not_compound_assign)
11608  << (UO->getOpcode() == UO_Plus ? "+" : "-")
11609  << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
11610  }
11611  }
11612 
11613  if (ConvTy == Compatible) {
11614  if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) {
11615  // Warn about retain cycles where a block captures the LHS, but
11616  // not if the LHS is a simple variable into which the block is
11617  // being stored...unless that variable can be captured by reference!
11618  const Expr *InnerLHS = LHSExpr->IgnoreParenCasts();
11619  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
11620  if (!DRE || DRE->getDecl()->hasAttr<BlocksAttr>())
11621  checkRetainCycles(LHSExpr, RHS.get());
11622  }
11623 
11624  if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong ||
11625  LHSType.isNonWeakInMRRWithObjCWeak(Context)) {
11626  // It is safe to assign a weak reference into a strong variable.
11627  // Although this code can still have problems:
11628  // id x = self.weakProp;
11629  // id y = self.weakProp;
11630  // we do not warn to warn spuriously when 'x' and 'y' are on separate
11631  // paths through the function. This should be revisited if
11632  // -Wrepeated-use-of-weak is made flow-sensitive.
11633  // For ObjCWeak only, we do not warn if the assign is to a non-weak
11634  // variable, which will be valid for the current autorelease scope.
11635  if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
11636  RHS.get()->getBeginLoc()))
11637  getCurFunction()->markSafeWeakUse(RHS.get());
11638 
11639  } else if (getLangOpts().ObjCAutoRefCount || getLangOpts().ObjCWeak) {
11640  checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get());
11641  }
11642  }
11643  } else {
11644  // Compound assignment "x += y"
11645  ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType);
11646  }
11647 
11648  if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
11649  RHS.get(), AA_Assigning))
11650  return QualType();
11651 
11652  CheckForNullPointerDereference(*this, LHSExpr);
11653 
11654  // C99 6.5.16p3: The type of an assignment expression is the type of the
11655  // left operand unless the left operand has qualified type, in which case
11656  // it is the unqualified version of the type of the left operand.
11657  // C99 6.5.16.1p2: In simple assignment, the value of the right operand
11658  // is converted to the type of the assignment expression (above).
11659  // C++ 5.17p1: the type of the assignment expression is that of its left
11660  // operand.
11661  return (getLangOpts().CPlusPlus
11662  ? LHSType : LHSType.getUnqualifiedType());
11663 }
11664 
11665 // Only ignore explicit casts to void.
11666 static bool IgnoreCommaOperand(const Expr *E) {
11667  E = E->IgnoreParens();
11668 
11669  if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
11670  if (CE->getCastKind() == CK_ToVoid) {
11671  return true;
11672  }
11673 
11674  // static_cast<void> on a dependent type will not show up as CK_ToVoid.
11675  if (CE->getCastKind() == CK_Dependent && E->getType()->isVoidType() &&
11676  CE->getSubExpr()->getType()->isDependentType()) {
11677  return true;
11678  }
11679  }
11680 
11681  return false;
11682 }
11683 
11684 // Look for instances where it is likely the comma operator is confused with
11685 // another operator. There is a whitelist of acceptable expressions for the
11686 // left hand side of the comma operator, otherwise emit a warning.
11688  // No warnings in macros
11689  if (Loc.isMacroID())
11690  return;
11691 
11692  // Don't warn in template instantiations.
11693  if (inTemplateInstantiation())
11694  return;
11695 
11696  // Scope isn't fine-grained enough to whitelist the specific cases, so
11697  // instead, skip more than needed, then call back into here with the
11698  // CommaVisitor in SemaStmt.cpp.
11699  // The whitelisted locations are the initialization and increment portions
11700  // of a for loop. The additional checks are on the condition of
11701  // if statements, do/while loops, and for loops.
11702  // Differences in scope flags for C89 mode requires the extra logic.
11703  const unsigned ForIncrementFlags =
11704  getLangOpts().C99 || getLangOpts().CPlusPlus
11707  const unsigned ForInitFlags = Scope::ControlScope | Scope::DeclScope;
11708  const unsigned ScopeFlags = getCurScope()->getFlags();
11709  if ((ScopeFlags & ForIncrementFlags) == ForIncrementFlags ||
11710  (ScopeFlags & ForInitFlags) == ForInitFlags)
11711  return;
11712 
11713  // If there are multiple comma operators used together, get the RHS of the
11714  // of the comma operator as the LHS.
11715  while (const BinaryOperator *BO = dyn_cast<BinaryOperator>(LHS)) {
11716  if (BO->getOpcode() != BO_Comma)
11717  break;
11718  LHS = BO->getRHS();
11719  }
11720 
11721  // Only allow some expressions on LHS to not warn.
11722  if (IgnoreCommaOperand(LHS))
11723  return;
11724 
11725  Diag(Loc, diag::warn_comma_operator);
11726  Diag(LHS->getBeginLoc(), diag::note_cast_to_void)
11727  << LHS->getSourceRange()
11729  LangOpts.CPlusPlus ? "static_cast<void>("
11730  : "(void)(")
11731  << FixItHint::CreateInsertion(PP.getLocForEndOfToken(LHS->getEndLoc()),
11732  ")");
11733 }
11734 
11735 // C99 6.5.17
11737  SourceLocation Loc) {
11738  LHS = S.CheckPlaceholderExpr(LHS.get());
11739  RHS = S.CheckPlaceholderExpr(RHS.get());
11740  if (LHS.isInvalid() || RHS.isInvalid())
11741  return QualType();
11742 
11743  // C's comma performs lvalue conversion (C99 6.3.2.1) on both its
11744  // operands, but not unary promotions.
11745  // C++'s comma does not do any conversions at all (C++ [expr.comma]p1).
11746 
11747  // So we treat the LHS as a ignored value, and in C++ we allow the
11748  // containing site to determine what should be done with the RHS.
11749  LHS = S.IgnoredValueConversions(LHS.get());
11750  if (LHS.isInvalid())
11751  return QualType();
11752 
11753  S.DiagnoseUnusedExprResult(LHS.get());
11754 
11755  if (!S.getLangOpts().CPlusPlus) {
11757  if (RHS.isInvalid())
11758  return QualType();
11759  if (!RHS.get()->getType()->isVoidType())
11760  S.RequireCompleteType(Loc, RHS.get()->getType(),
11761  diag::err_incomplete_type);
11762  }
11763 
11764  if (!S.getDiagnostics().isIgnored(diag::warn_comma_operator, Loc))
11765  S.DiagnoseCommaOperator(LHS.get(), Loc);
11766 
11767  return RHS.get()->getType();
11768 }
11769 
11770 /// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
11771 /// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
11773  ExprValueKind &VK,
11774  ExprObjectKind &OK,
11775  SourceLocation OpLoc,
11776  bool IsInc, bool IsPrefix) {
11777  if (Op->isTypeDependent())
11778  return S.Context.DependentTy;
11779 
11780  QualType ResType = Op->getType();
11781  // Atomic types can be used for increment / decrement where the non-atomic
11782  // versions can, so ignore the _Atomic() specifier for the purpose of
11783  // checking.
11784  if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
11785  ResType = ResAtomicType->getValueType();
11786 
11787  assert(!ResType.isNull() && "no type for increment/decrement expression");
11788 
11789  if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) {
11790  // Decrement of bool is not allowed.
11791  if (!IsInc) {
11792  S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
11793  return QualType();
11794  }
11795  // Increment of bool sets it to true, but is deprecated.
11796  S.Diag(OpLoc, S.getLangOpts().CPlusPlus17 ? diag::ext_increment_bool
11797  : diag::warn_increment_bool)
11798  << Op->getSourceRange();
11799  } else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) {
11800  // Error on enum increments and decrements in C++ mode
11801  S.Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
11802  return QualType();
11803  } else if (ResType->isRealType()) {
11804  // OK!
11805  } else if (ResType->isPointerType()) {
11806  // C99 6.5.2.4p2, 6.5.6p2
11807  if (!checkArithmeticOpPointerOperand(S, OpLoc, Op))
11808  return QualType();
11809  } else if (ResType->isObjCObjectPointerType()) {
11810  // On modern runtimes, ObjC pointer arithmetic is forbidden.
11811  // Otherwise, we just need a complete type.
11812  if (checkArithmeticIncompletePointerType(S, OpLoc, Op) ||
11813  checkArithmeticOnObjCPointer(S, OpLoc, Op))
11814  return QualType();
11815  } else if (ResType->isAnyComplexType()) {
11816  // C99 does not support ++/-- on complex types, we allow as an extension.
11817  S.Diag(OpLoc, diag::ext_integer_increment_complex)
11818  << ResType << Op->getSourceRange();
11819  } else if (ResType->isPlaceholderType()) {
11820  ExprResult PR = S.CheckPlaceholderExpr(Op);
11821  if (PR.isInvalid()) return QualType();
11822  return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc,
11823  IsInc, IsPrefix);
11824  } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) {
11825  // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 )
11826  } else if (S.getLangOpts().ZVector && ResType->isVectorType() &&
11827  (ResType->getAs<VectorType>()->getVectorKind() !=
11829  // The z vector extensions allow ++ and -- for non-bool vectors.
11830  } else if(S.getLangOpts().OpenCL && ResType->isVectorType() &&
11831  ResType->getAs<VectorType>()->getElementType()->isIntegerType()) {
11832  // OpenCL V1.2 6.3 says dec/inc ops operate on integer vector types.
11833  } else {
11834  S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
11835  << ResType << int(IsInc) << Op->getSourceRange();
11836  return QualType();
11837  }
11838  // At this point, we know we have a real, complex or pointer type.
11839  // Now make sure the operand is a modifiable lvalue.
11840  if (CheckForModifiableLvalue(Op, OpLoc, S))
11841  return QualType();
11842  // In C++, a prefix increment is the same type as the operand. Otherwise
11843  // (in C or with postfix), the increment is the unqualified type of the
11844  // operand.
11845  if (IsPrefix && S.getLangOpts().CPlusPlus) {
11846  VK = VK_LValue;
11847  OK = Op->getObjectKind();
11848  return ResType;
11849  } else {
11850  VK = VK_RValue;
11851  return ResType.getUnqualifiedType();
11852  }
11853 }
11854 
11855 
11856 /// getPrimaryDecl - Helper function for CheckAddressOfOperand().
11857 /// This routine allows us to typecheck complex/recursive expressions
11858 /// where the declaration is needed for type checking. We only need to
11859 /// handle cases when the expression references a function designator
11860 /// or is an lvalue. Here are some examples:
11861 /// - &(x) => x
11862 /// - &*****f => f for f a function designator.
11863 /// - &s.xx => s
11864 /// - &s.zz[1].yy -> s, if zz is an array
11865 /// - *(x + 1) -> x, if x is an array
11866 /// - &"123"[2] -> 0
11867 /// - & __real__ x -> x
11869  switch (E->getStmtClass()) {
11870  case Stmt::DeclRefExprClass:
11871  return cast<DeclRefExpr>(E)->getDecl();
11872  case Stmt::MemberExprClass:
11873  // If this is an arrow operator, the address is an offset from
11874  // the base's value, so the object the base refers to is
11875  // irrelevant.
11876  if (cast<MemberExpr>(E)->isArrow())
11877  return nullptr;
11878  // Otherwise, the expression refers to a part of the base
11879  return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
11880  case Stmt::ArraySubscriptExprClass: {
11881  // FIXME: This code shouldn't be necessary! We should catch the implicit
11882  // promotion of register arrays earlier.
11883  Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
11884  if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
11885  if (ICE->getSubExpr()->getType()->isArrayType())
11886  return getPrimaryDecl(ICE->getSubExpr());
11887  }
11888  return nullptr;
11889  }
11890  case Stmt::UnaryOperatorClass: {
11891  UnaryOperator *UO = cast<UnaryOperator>(E);
11892 
11893  switch(UO->getOpcode()) {
11894  case UO_Real:
11895  case UO_Imag:
11896  case UO_Extension:
11897  return getPrimaryDecl(UO->getSubExpr());
11898  default:
11899  return nullptr;
11900  }
11901  }
11902  case Stmt::ParenExprClass:
11903  return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
11904  case Stmt::ImplicitCastExprClass:
11905  // If the result of an implicit cast is an l-value, we care about
11906  // the sub-expression; otherwise, the result here doesn't matter.
11907  return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
11908  default:
11909  return nullptr;
11910  }
11911 }
11912 
11913 namespace {
11914  enum {
11915  AO_Bit_Field = 0,
11916  AO_Vector_Element = 1,
11917  AO_Property_Expansion = 2,
11918  AO_Register_Variable = 3,
11919  AO_No_Error = 4
11920  };
11921 }
11922 /// Diagnose invalid operand for address of operations.
11923 ///
11924 /// \param Type The type of operand which cannot have its address taken.
11926  Expr *E, unsigned Type) {
11927  S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange();
11928 }
11929 
11930 /// CheckAddressOfOperand - The operand of & must be either a function
11931 /// designator or an lvalue designating an object. If it is an lvalue, the
11932 /// object cannot be declared with storage class register or be a bit field.
11933 /// Note: The usual conversions are *not* applied to the operand of the &
11934 /// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
11935 /// In C++, the operand might be an overloaded function name, in which case
11936 /// we allow the '&' but retain the overloaded-function type.
11938  if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){
11939  if (PTy->getKind() == BuiltinType::Overload) {
11940  Expr *E = OrigOp.get()->IgnoreParens();
11941  if (!isa<OverloadExpr>(E)) {
11942  assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
11943  Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
11944  << OrigOp.get()->getSourceRange();
11945  return QualType();
11946  }
11947 
11948  OverloadExpr *Ovl = cast<OverloadExpr>(E);
11949  if (isa<UnresolvedMemberExpr>(Ovl))
11950  if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
11951  Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
11952  << OrigOp.get()->getSourceRange();
11953  return QualType();
11954  }
11955 
11956  return Context.OverloadTy;
11957  }
11958 
11959  if (PTy->getKind() == BuiltinType::UnknownAny)
11960  return Context.UnknownAnyTy;
11961 
11962  if (PTy->getKind() == BuiltinType::BoundMember) {
11963  Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
11964  << OrigOp.get()->getSourceRange();
11965  return QualType();
11966  }
11967 
11968  OrigOp = CheckPlaceholderExpr(OrigOp.get());
11969  if (OrigOp.isInvalid()) return QualType();
11970  }
11971 
11972  if (OrigOp.get()->isTypeDependent())
11973  return Context.DependentTy;
11974 
11975  assert(!OrigOp.get()->getType()->isPlaceholderType());
11976 
11977  // Make sure to ignore parentheses in subsequent checks
11978  Expr *op = OrigOp.get()->IgnoreParens();
11979 
11980  // In OpenCL captures for blocks called as lambda functions
11981  // are located in the private address space. Blocks used in
11982  // enqueue_kernel can be located in a different address space
11983  // depending on a vendor implementation. Thus preventing
11984  // taking an address of the capture to avoid invalid AS casts.
11985  if (LangOpts.OpenCL) {
11986  auto* VarRef = dyn_cast<DeclRefExpr>(op);
11987  if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
11988  Diag(op->getExprLoc(), diag::err_opencl_taking_address_capture);
11989  return QualType();
11990  }
11991  }
11992 
11993  if (getLangOpts().C99) {
11994  // Implement C99-only parts of addressof rules.
11995  if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
11996  if (uOp->getOpcode() == UO_Deref)
11997  // Per C99 6.5.3.2, the address of a deref always returns a valid result
11998  // (assuming the deref expression is valid).
11999  return uOp->getSubExpr()->getType();
12000  }
12001  // Technically, there should be a check for array subscript
12002  // expressions here, but the result of one is always an lvalue anyway.
12003  }
12004  ValueDecl *dcl = getPrimaryDecl(op);
12005 
12006  if (auto *FD = dyn_cast_or_null<FunctionDecl>(dcl))
12007  if (!checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
12008  op->getBeginLoc()))
12009  return QualType();
12010 
12011  Expr::LValueClassification lval = op->ClassifyLValue(Context);
12012  unsigned AddressOfError = AO_No_Error;
12013 
12014  if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
12015  bool sfinae = (bool)isSFINAEContext();
12016  Diag(OpLoc, isSFINAEContext() ? diag::err_typecheck_addrof_temporary
12017  : diag::ext_typecheck_addrof_temporary)
12018  << op->getType() << op->getSourceRange();
12019  if (sfinae)
12020  return QualType();
12021  // Materialize the temporary as an lvalue so that we can take its address.
12022  OrigOp = op =
12023  CreateMaterializeTemporaryExpr(op->getType(), OrigOp.get(), true);
12024  } else if (isa<ObjCSelectorExpr>(op)) {
12025  return Context.getPointerType(op->getType());
12026  } else if (lval == Expr::LV_MemberFunction) {
12027  // If it's an instance method, make a member pointer.
12028  // The expression must have exactly the form &A::foo.
12029 
12030  // If the underlying expression isn't a decl ref, give up.
12031  if (!isa<DeclRefExpr>(op)) {
12032  Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
12033  << OrigOp.get()->getSourceRange();
12034  return QualType();
12035  }
12036  DeclRefExpr *DRE = cast<DeclRefExpr>(op);
12037  CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl());
12038 
12039  // The id-expression was parenthesized.
12040  if (OrigOp.get() != DRE) {
12041  Diag(OpLoc, diag::err_parens_pointer_member_function)
12042  << OrigOp.get()->getSourceRange();
12043 
12044  // The method was named without a qualifier.
12045  } else if (!DRE->getQualifier()) {
12046  if (MD->getParent()->getName().empty())
12047  Diag(OpLoc, diag::err_unqualified_pointer_member_function)
12048  << op->getSourceRange();
12049  else {
12050  SmallString<32> Str;
12051  StringRef Qual = (MD->getParent()->getName() + "::").toStringRef(Str);
12052  Diag(OpLoc, diag::err_unqualified_pointer_member_function)
12053  << op->getSourceRange()
12055  }
12056  }
12057 
12058  // Taking the address of a dtor is illegal per C++ [class.dtor]p2.
12059  if (isa<CXXDestructorDecl>(MD))
12060  Diag(OpLoc, diag::err_typecheck_addrof_dtor) << op->getSourceRange();
12061 
12062  QualType MPTy = Context.getMemberPointerType(
12063  op->getType(), Context.getTypeDeclType(MD->getParent()).getTypePtr());
12064  // Under the MS ABI, lock down the inheritance model now.
12065  if (Context.getTargetInfo().getCXXABI().isMicrosoft())
12066  (void)isCompleteType(OpLoc, MPTy);
12067  return MPTy;
12068  } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
12069  // C99 6.5.3.2p1
12070  // The operand must be either an l-value or a function designator
12071  if (!op->getType()->isFunctionType()) {
12072  // Use a special diagnostic for loads from property references.
12073  if (isa<PseudoObjectExpr>(op)) {
12074  AddressOfError = AO_Property_Expansion;
12075  } else {
12076  Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
12077  << op->getType() << op->getSourceRange();
12078  return QualType();
12079  }
12080  }
12081  } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1
12082  // The operand cannot be a bit-field
12083  AddressOfError = AO_Bit_Field;
12084  } else if (op->getObjectKind() == OK_VectorComponent) {
12085  // The operand cannot be an element of a vector
12086  AddressOfError = AO_Vector_Element;
12087  } else if (dcl) { // C99 6.5.3.2p1
12088  // We have an lvalue with a decl. Make sure the decl is not declared
12089  // with the register storage-class specifier.
12090  if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
12091  // in C++ it is not error to take address of a register
12092  // variable (c++03 7.1.1P3)
12093  if (vd->getStorageClass() == SC_Register &&
12094  !getLangOpts().CPlusPlus) {
12095  AddressOfError = AO_Register_Variable;
12096  }
12097  } else if (isa<MSPropertyDecl>(dcl)) {
12098  AddressOfError = AO_Property_Expansion;
12099  } else if (isa<FunctionTemplateDecl>(dcl)) {
12100  return Context.OverloadTy;
12101  } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
12102  // Okay: we can take the address of a field.
12103  // Could be a pointer to member, though, if there is an explicit
12104  // scope qualifier for the class.
12105  if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
12106  DeclContext *Ctx = dcl->getDeclContext();
12107  if (Ctx && Ctx->isRecord()) {
12108  if (dcl->getType()->isReferenceType()) {
12109  Diag(OpLoc,
12110  diag::err_cannot_form_pointer_to_member_of_reference_type)
12111  << dcl->getDeclName() << dcl->getType();
12112  return QualType();
12113  }
12114 
12115  while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
12116  Ctx = Ctx->getParent();
12117 
12118  QualType MPTy = Context.getMemberPointerType(
12119  op->getType(),
12120  Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
12121  // Under the MS ABI, lock down the inheritance model now.
12122  if (Context.getTargetInfo().getCXXABI().isMicrosoft())
12123  (void)isCompleteType(OpLoc, MPTy);
12124  return MPTy;
12125  }
12126  }
12127  } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl) &&
12128  !isa<BindingDecl>(dcl))
12129  llvm_unreachable("Unknown/unexpected decl type");
12130  }
12131 
12132  if (AddressOfError != AO_No_Error) {
12133  diagnoseAddressOfInvalidType(*this, OpLoc, op, AddressOfError);
12134  return QualType();
12135  }
12136 
12137  if (lval == Expr::LV_IncompleteVoidType) {
12138  // Taking the address of a void variable is technically illegal, but we
12139  // allow it in cases which are otherwise valid.
12140  // Example: "extern void x; void* y = &x;".
12141  Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
12142  }
12143 
12144  // If the operand has type "type", the result has type "pointer to type".
12145  if (op->getType()->isObjCObjectType())
12146  return Context.getObjCObjectPointerType(op->getType());
12147 
12148  CheckAddressOfPackedMember(op);
12149 
12150  return Context.getPointerType(op->getType());
12151 }
12152 
12153 static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
12154  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp);
12155  if (!DRE)
12156  return;
12157  const Decl *D = DRE->getDecl();
12158  if (!D)
12159  return;
12160  const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
12161  if (!Param)
12162  return;
12163  if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
12164  if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>())
12165  return;
12166  if (FunctionScopeInfo *FD = S.getCurFunction())
12167  if (!FD->ModifiedNonNullParams.count(Param))
12168  FD->ModifiedNonNullParams.insert(Param);
12169 }
12170 
12171 /// CheckIndirectionOperand - Type check unary indirection (prefix '*').
12173  SourceLocation OpLoc) {
12174  if (Op->isTypeDependent())
12175  return S.Context.DependentTy;
12176 
12177  ExprResult ConvResult = S.UsualUnaryConversions(Op);
12178  if (ConvResult.isInvalid())
12179  return QualType();
12180  Op = ConvResult.get();
12181  QualType OpTy = Op->getType();
12182  QualType Result;
12183 
12184  if (isa<CXXReinterpretCastExpr>(Op)) {
12185  QualType OpOrigType = Op->IgnoreParenCasts()->getType();
12186  S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true,
12187  Op->getSourceRange());
12188  }
12189 
12190  if (const PointerType *PT = OpTy->getAs<PointerType>())
12191  {
12192  Result = PT->getPointeeType();
12193  }
12194  else if (const ObjCObjectPointerType *OPT =
12195  OpTy->getAs<ObjCObjectPointerType>())
12196  Result = OPT->getPointeeType();
12197  else {
12198  ExprResult PR = S.CheckPlaceholderExpr(Op);
12199  if (PR.isInvalid()) return QualType();
12200  if (PR.get() != Op)
12201  return CheckIndirectionOperand(S, PR.get(), VK, OpLoc);
12202  }
12203 
12204  if (Result.isNull()) {
12205  S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
12206  << OpTy << Op->getSourceRange();
12207  return QualType();
12208  }
12209 
12210  // Note that per both C89 and C99, indirection is always legal, even if Result
12211  // is an incomplete type or void. It would be possible to warn about
12212  // dereferencing a void pointer, but it's completely well-defined, and such a
12213  // warning is unlikely to catch any mistakes. In C++, indirection is not valid
12214  // for pointers to 'void' but is fine for any other pointer type:
12215  //
12216  // C++ [expr.unary.op]p1:
12217  // [...] the expression to which [the unary * operator] is applied shall
12218  // be a pointer to an object type, or a pointer to a function type
12219  if (S.getLangOpts().CPlusPlus && Result->isVoidType())
12220  S.Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer)
12221  << OpTy << Op->getSourceRange();
12222 
12223  // Dereferences are usually l-values...
12224  VK = VK_LValue;
12225 
12226  // ...except that certain expressions are never l-values in C.
12227  if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType())
12228  VK = VK_RValue;
12229 
12230  return Result;
12231 }
12232 
12233 BinaryOperatorKind Sema::ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind) {
12234  BinaryOperatorKind Opc;
12235  switch (Kind) {
12236  default: llvm_unreachable("Unknown binop!");
12237  case tok::periodstar: Opc = BO_PtrMemD; break;
12238  case tok::arrowstar: Opc = BO_PtrMemI; break;
12239  case tok::star: Opc = BO_Mul; break;
12240  case tok::slash: Opc = BO_Div; break;
12241  case tok::percent: Opc = BO_Rem; break;
12242  case tok::plus: Opc = BO_Add; break;
12243  case tok::minus: Opc = BO_Sub; break;
12244  case tok::lessless: Opc = BO_Shl; break;
12245  case tok::greatergreater: Opc = BO_Shr; break;
12246  case tok::lessequal: Opc = BO_LE; break;
12247  case tok::less: Opc = BO_LT; break;
12248  case tok::greaterequal: Opc = BO_GE; break;
12249  case tok::greater: Opc = BO_GT; break;
12250  case tok::exclaimequal: Opc = BO_NE; break;
12251  case tok::equalequal: Opc = BO_EQ; break;
12252  case tok::spaceship: Opc = BO_Cmp; break;
12253  case tok::amp: Opc = BO_And; break;
12254  case tok::caret: Opc = BO_Xor; break;
12255  case tok::pipe: Opc = BO_Or; break;
12256  case tok::ampamp: Opc = BO_LAnd; break;
12257  case tok::pipepipe: Opc = BO_LOr; break;
12258  case tok::equal: Opc = BO_Assign; break;
12259  case tok::starequal: Opc = BO_MulAssign; break;
12260  case tok::slashequal: Opc = BO_DivAssign; break;
12261  case tok::percentequal: Opc = BO_RemAssign; break;
12262  case tok::plusequal: Opc = BO_AddAssign; break;
12263  case tok::minusequal: Opc = BO_SubAssign; break;
12264  case tok::lesslessequal: Opc = BO_ShlAssign; break;
12265  case tok::greatergreaterequal: Opc = BO_ShrAssign; break;
12266  case tok::ampequal: Opc = BO_AndAssign; break;
12267  case tok::caretequal: Opc = BO_XorAssign; break;
12268  case tok::pipeequal: Opc = BO_OrAssign; break;
12269  case tok::comma: Opc = BO_Comma; break;
12270  }
12271  return Opc;
12272 }
12273 
12275  tok::TokenKind Kind) {
12276  UnaryOperatorKind Opc;
12277  switch (Kind) {
12278  default: llvm_unreachable("Unknown unary op!");
12279  case tok::plusplus: Opc = UO_PreInc; break;
12280  case tok::minusminus: Opc = UO_PreDec; break;
12281  case tok::amp: Opc = UO_AddrOf; break;
12282  case tok::star: Opc = UO_Deref; break;
12283  case tok::plus: Opc = UO_Plus; break;
12284  case tok::minus: Opc = UO_Minus; break;
12285  case tok::tilde: Opc = UO_Not; break;
12286  case tok::exclaim: Opc = UO_LNot; break;
12287  case tok::kw___real: Opc = UO_Real; break;
12288  case tok::kw___imag: Opc = UO_Imag; break;
12289  case tok::kw___extension__: Opc = UO_Extension; break;
12290  }
12291  return Opc;
12292 }
12293 
12294 /// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
12295 /// This warning suppressed in the event of macro expansions.
12296 static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
12297  SourceLocation OpLoc, bool IsBuiltin) {
12298  if (S.inTemplateInstantiation())
12299  return;
12300  if (S.isUnevaluatedContext())
12301  return;
12302  if (OpLoc.isInvalid() || OpLoc.isMacroID())
12303  return;
12304  LHSExpr = LHSExpr->IgnoreParenImpCasts();
12305  RHSExpr = RHSExpr->IgnoreParenImpCasts();
12306  const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
12307  const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
12308  if (!LHSDeclRef || !RHSDeclRef ||
12309  LHSDeclRef->getLocation().isMacroID() ||
12310  RHSDeclRef->getLocation().isMacroID())
12311  return;
12312  const ValueDecl *LHSDecl =
12313  cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl());
12314  const ValueDecl *RHSDecl =
12315  cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl());
12316  if (LHSDecl != RHSDecl)
12317  return;
12318  if (LHSDecl->getType().isVolatileQualified())
12319  return;
12320  if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>())
12321  if (RefTy->getPointeeType().isVolatileQualified())
12322  return;
12323 
12324  S.Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
12325  : diag::warn_self_assignment_overloaded)
12326  << LHSDeclRef->getType() << LHSExpr->getSourceRange()
12327  << RHSExpr->getSourceRange();
12328 }
12329 
12330 /// Check if a bitwise-& is performed on an Objective-C pointer. This
12331 /// is usually indicative of introspection within the Objective-C pointer.
12333  SourceLocation OpLoc) {
12334  if (!S.getLangOpts().ObjC)
12335  return;
12336 
12337  const Expr *ObjCPointerExpr = nullptr, *OtherExpr = nullptr;
12338  const Expr *LHS = L.get();
12339  const Expr *RHS = R.get();
12340 
12342  ObjCPointerExpr = LHS;
12343  OtherExpr = RHS;
12344  }
12345  else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
12346  ObjCPointerExpr = RHS;
12347  OtherExpr = LHS;
12348  }
12349 
12350  // This warning is deliberately made very specific to reduce false
12351  // positives with logic that uses '&' for hashing. This logic mainly
12352  // looks for code trying to introspect into tagged pointers, which
12353  // code should generally never do.
12354  if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
12355  unsigned Diag = diag::warn_objc_pointer_masking;
12356  // Determine if we are introspecting the result of performSelectorXXX.
12357  const Expr *Ex = ObjCPointerExpr->IgnoreParenCasts();
12358  // Special case messages to -performSelector and friends, which
12359  // can return non-pointer values boxed in a pointer value.
12360  // Some clients may wish to silence warnings in this subcase.
12361  if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Ex)) {
12362  Selector S = ME->getSelector();
12363  StringRef SelArg0 = S.getNameForSlot(0);
12364  if (SelArg0.startswith("performSelector"))
12365  Diag = diag::warn_objc_pointer_masking_performSelector;
12366  }
12367 
12368  S.Diag(OpLoc, Diag)
12369  << ObjCPointerExpr->getSourceRange();
12370  }
12371 }
12372 
12374  if (!E)
12375  return nullptr;
12376  if (auto *DRE = dyn_cast<DeclRefExpr>(E))
12377  return DRE->getDecl();
12378  if (auto *ME = dyn_cast<MemberExpr>(E))
12379  return ME->getMemberDecl();
12380  if (auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
12381  return IRE->getDecl();
12382  return nullptr;
12383 }
12384 
12385 // This helper function promotes a binary operator's operands (which are of a
12386 // half vector type) to a vector of floats and then truncates the result to
12387 // a vector of either half or short.
12389  BinaryOperatorKind Opc, QualType ResultTy,
12391  bool IsCompAssign, SourceLocation OpLoc,
12392  FPOptions FPFeatures) {
12393  auto &Context = S.getASTContext();
12394  assert((isVector(ResultTy, Context.HalfTy) ||
12395  isVector(ResultTy, Context.ShortTy)) &&
12396  "Result must be a vector of half or short");
12397  assert(isVector(LHS.get()->getType(), Context.HalfTy) &&
12398  isVector(RHS.get()->getType(), Context.HalfTy) &&
12399  "both operands expected to be a half vector");
12400 
12401  RHS = convertVector(RHS.get(), Context.FloatTy, S);
12402  QualType BinOpResTy = RHS.get()->getType();
12403 
12404  // If Opc is a comparison, ResultType is a vector of shorts. In that case,
12405  // change BinOpResTy to a vector of ints.
12406  if (isVector(ResultTy, Context.ShortTy))
12407  BinOpResTy = S.GetSignedVectorType(BinOpResTy);
12408 
12409  if (IsCompAssign)
12410  return new (Context) CompoundAssignOperator(
12411  LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, BinOpResTy, BinOpResTy,
12412  OpLoc, FPFeatures);
12413 
12414  LHS = convertVector(LHS.get(), Context.FloatTy, S);
12415  auto *BO = new (Context) BinaryOperator(LHS.get(), RHS.get(), Opc, BinOpResTy,
12416  VK, OK, OpLoc, FPFeatures);
12417  return convertVector(BO, ResultTy->getAs<VectorType>()->getElementType(), S);
12418 }
12419 
12420 static std::pair<ExprResult, ExprResult>
12422  Expr *RHSExpr) {
12423  ExprResult LHS = LHSExpr, RHS = RHSExpr;
12424  if (!S.getLangOpts().CPlusPlus) {
12425  // C cannot handle TypoExpr nodes on either side of a binop because it
12426  // doesn't handle dependent types properly, so make sure any TypoExprs have
12427  // been dealt with before checking the operands.
12428  LHS = S.CorrectDelayedTyposInExpr(LHS);
12429  RHS = S.CorrectDelayedTyposInExpr(RHS, [Opc, LHS](Expr *E) {
12430  if (Opc != BO_Assign)
12431  return ExprResult(E);
12432  // Avoid correcting the RHS to the same Expr as the LHS.
12433  Decl *D = getDeclFromExpr(E);
12434  return (D && D == getDeclFromExpr(LHS.get())) ? ExprError() : E;
12435  });
12436  }
12437  return std::make_pair(LHS, RHS);
12438 }
12439 
12440 /// Returns true if conversion between vectors of halfs and vectors of floats
12441 /// is needed.
12442 static bool needsConversionOfHalfVec(bool OpRequiresConversion, ASTContext &Ctx,
12443  QualType SrcType) {
12444  return OpRequiresConversion && !Ctx.getLangOpts().NativeHalfType &&
12446  isVector(SrcType, Ctx.HalfTy);
12447 }
12448 
12449 /// CreateBuiltinBinOp - Creates a new built-in binary operation with
12450 /// operator @p Opc at location @c TokLoc. This routine only supports
12451 /// built-in operations; ActOnBinOp handles overloaded operators.
12453  BinaryOperatorKind Opc,
12454  Expr *LHSExpr, Expr *RHSExpr) {
12455  if (getLangOpts().CPlusPlus11 && isa<InitListExpr>(RHSExpr)) {
12456  // The syntax only allows initializer lists on the RHS of assignment,
12457  // so we don't need to worry about accepting invalid code for
12458  // non-assignment operators.
12459  // C++11 5.17p9:
12460  // The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning
12461  // of x = {} is x = T().
12463  RHSExpr->getBeginLoc(), RHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
12464  InitializedEntity Entity =
12466  InitializationSequence InitSeq(*this, Entity, Kind, RHSExpr);
12467  ExprResult Init = InitSeq.Perform(*this, Entity, Kind, RHSExpr);
12468  if (Init.isInvalid())
12469  return Init;
12470  RHSExpr = Init.get();
12471  }
12472 
12473  ExprResult LHS = LHSExpr, RHS = RHSExpr;
12474  QualType ResultTy; // Result type of the binary operator.
12475  // The following two variables are used for compound assignment operators
12476  QualType CompLHSTy; // Type of LHS after promotions for computation
12477  QualType CompResultTy; // Type of computation result
12478  ExprValueKind VK = VK_RValue;
12480  bool ConvertHalfVec = false;
12481 
12482  std::tie(LHS, RHS) = CorrectDelayedTyposInBinOp(*this, Opc, LHSExpr, RHSExpr);
12483  if (!LHS.isUsable() || !RHS.isUsable())
12484  return ExprError();
12485 
12486  if (getLangOpts().OpenCL) {
12487  QualType LHSTy = LHSExpr->getType();
12488  QualType RHSTy = RHSExpr->getType();
12489  // OpenCLC v2.0 s6.13.11.1 allows atomic variables to be initialized by
12490  // the ATOMIC_VAR_INIT macro.
12491  if (LHSTy->isAtomicType() || RHSTy->isAtomicType()) {
12492  SourceRange SR(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
12493  if (BO_Assign == Opc)
12494  Diag(OpLoc, diag::err_opencl_atomic_init) << 0 << SR;
12495  else
12496  ResultTy = InvalidOperands(OpLoc, LHS, RHS);
12497  return ExprError();
12498  }
12499 
12500  // OpenCL special types - image, sampler, pipe, and blocks are to be used
12501  // only with a builtin functions and therefore should be disallowed here.
12502  if (LHSTy->isImageType() || RHSTy->isImageType() ||
12503  LHSTy->isSamplerT() || RHSTy->isSamplerT() ||
12504  LHSTy->isPipeType() || RHSTy->isPipeType() ||
12505  LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) {
12506  ResultTy = InvalidOperands(OpLoc, LHS, RHS);
12507  return ExprError();
12508  }
12509  }
12510 
12511  // Diagnose operations on the unsupported types for OpenMP device compilation.
12512  if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice) {
12513  if (Opc != BO_Assign && Opc != BO_Comma) {
12514  checkOpenMPDeviceExpr(LHSExpr);
12515  checkOpenMPDeviceExpr(RHSExpr);
12516  }
12517  }
12518 
12519  switch (Opc) {
12520  case BO_Assign:
12521  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType());
12522  if (getLangOpts().CPlusPlus &&
12523  LHS.get()->getObjectKind() != OK_ObjCProperty) {
12524  VK = LHS.get()->getValueKind();
12525  OK = LHS.get()->getObjectKind();
12526  }
12527  if (!ResultTy.isNull()) {
12528  DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc, true);
12529  DiagnoseSelfMove(LHS.get(), RHS.get(), OpLoc);
12530 
12531  // Avoid copying a block to the heap if the block is assigned to a local
12532  // auto variable that is declared in the same scope as the block. This
12533  // optimization is unsafe if the local variable is declared in an outer
12534  // scope. For example:
12535  //
12536  // BlockTy b;
12537  // {
12538  // b = ^{...};
12539  // }
12540  // // It is unsafe to invoke the block here if it wasn't copied to the
12541  // // heap.
12542  // b();
12543 
12544  if (auto *BE = dyn_cast<BlockExpr>(RHS.get()->IgnoreParens()))
12545  if (auto *DRE = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParens()))
12546  if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
12547  if (VD->hasLocalStorage() && getCurScope()->isDeclScope(VD))
12548  BE->getBlockDecl()->setCanAvoidCopyToHeap();
12549 
12550  if (LHS.get()->getType().hasNonTrivialToPrimitiveCopyCUnion())
12551  checkNonTrivialCUnion(LHS.get()->getType(), LHS.get()->getExprLoc(),
12552  NTCUC_Assignment, NTCUK_Copy);
12553  }
12554  RecordModifiableNonNullParam(*this, LHS.get());
12555  break;
12556  case BO_PtrMemD:
12557  case BO_PtrMemI:
12558  ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc,
12559  Opc == BO_PtrMemI);
12560  break;
12561  case BO_Mul:
12562  case BO_Div:
12563  ConvertHalfVec = true;
12564  ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false,
12565  Opc == BO_Div);
12566  break;
12567  case BO_Rem:
12568  ResultTy = CheckRemainderOperands(LHS, RHS, OpLoc);
12569  break;
12570  case BO_Add:
12571  ConvertHalfVec = true;
12572  ResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc);
12573  break;
12574  case BO_Sub:
12575  ConvertHalfVec = true;
12576  ResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc);
12577  break;
12578  case BO_Shl:
12579  case BO_Shr:
12580  ResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc);
12581  break;
12582  case BO_LE:
12583  case BO_LT:
12584  case BO_GE:
12585  case BO_GT:
12586  ConvertHalfVec = true;
12587  ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc);
12588  break;
12589  case BO_EQ:
12590  case BO_NE:
12591  ConvertHalfVec = true;
12592  ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc);
12593  break;
12594  case BO_Cmp:
12595  ConvertHalfVec = true;
12596  ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc);
12597  assert(ResultTy.isNull() || ResultTy->getAsCXXRecordDecl());
12598  break;
12599  case BO_And:
12600  checkObjCPointerIntrospection(*this, LHS, RHS, OpLoc);
12601  LLVM_FALLTHROUGH;
12602  case BO_Xor:
12603  case BO_Or:
12604  ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, Opc);
12605  break;
12606  case BO_LAnd:
12607  case BO_LOr:
12608  ConvertHalfVec = true;
12609  ResultTy = CheckLogicalOperands(LHS, RHS, OpLoc, Opc);
12610  break;
12611  case BO_MulAssign:
12612  case BO_DivAssign:
12613  ConvertHalfVec = true;
12614  CompResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, true,
12615  Opc == BO_DivAssign);
12616  CompLHSTy = CompResultTy;
12617  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
12618  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
12619  break;
12620  case BO_RemAssign:
12621  CompResultTy = CheckRemainderOperands(LHS, RHS, OpLoc, true);
12622  CompLHSTy = CompResultTy;
12623  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
12624  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
12625  break;
12626  case BO_AddAssign:
12627  ConvertHalfVec = true;
12628  CompResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc, &CompLHSTy);
12629  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
12630  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
12631  break;
12632  case BO_SubAssign:
12633  ConvertHalfVec = true;
12634  CompResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc, &CompLHSTy);
12635  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
12636  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
12637  break;
12638  case BO_ShlAssign:
12639  case BO_ShrAssign:
12640  CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true);
12641  CompLHSTy = CompResultTy;
12642  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
12643  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
12644  break;
12645  case BO_AndAssign:
12646  case BO_OrAssign: // fallthrough
12647  DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc, true);
12648  LLVM_FALLTHROUGH;
12649  case BO_XorAssign:
12650  CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, Opc);
12651  CompLHSTy = CompResultTy;
12652  if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
12653  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
12654  break;
12655  case BO_Comma:
12656  ResultTy = CheckCommaOperands(*this, LHS, RHS, OpLoc);
12657  if (getLangOpts().CPlusPlus && !RHS.isInvalid()) {
12658  VK = RHS.get()->getValueKind();
12659  OK = RHS.get()->getObjectKind();
12660  }
12661  break;
12662  }
12663  if (ResultTy.isNull() || LHS.isInvalid() || RHS.isInvalid())
12664  return ExprError();
12665 
12666  // Some of the binary operations require promoting operands of half vector to
12667  // float vectors and truncating the result back to half vector. For now, we do
12668  // this only when HalfArgsAndReturn is set (that is, when the target is arm or
12669  // arm64).
12670  assert(isVector(RHS.get()->getType(), Context.HalfTy) ==
12671  isVector(LHS.get()->getType(), Context.HalfTy) &&
12672  "both sides are half vectors or neither sides are");
12673  ConvertHalfVec = needsConversionOfHalfVec(ConvertHalfVec, Context,
12674  LHS.get()->getType());
12675 
12676  // Check for array bounds violations for both sides of the BinaryOperator
12677  CheckArrayAccess(LHS.get());
12678  CheckArrayAccess(RHS.get());
12679 
12680  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {
12681  NamedDecl *ObjectSetClass = LookupSingleName(TUScope,
12682  &Context.Idents.get("object_setClass"),
12683  SourceLocation(), LookupOrdinaryName);
12684  if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) {
12685  SourceLocation RHSLocEnd = getLocForEndOfToken(RHS.get()->getEndLoc());
12686  Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign)
12687  << FixItHint::CreateInsertion(LHS.get()->getBeginLoc(),
12688  "object_setClass(")
12689  << FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc),
12690  ",")
12691  << FixItHint::CreateInsertion(RHSLocEnd, ")");
12692  }
12693  else
12694  Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign);
12695  }
12696  else if (const ObjCIvarRefExpr *OIRE =
12697  dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
12698  DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get());
12699 
12700  // Opc is not a compound assignment if CompResultTy is null.
12701  if (CompResultTy.isNull()) {
12702  if (ConvertHalfVec)
12703  return convertHalfVecBinOp(*this, LHS, RHS, Opc, ResultTy, VK, OK, false,
12704  OpLoc, FPFeatures);
12705  return new (Context) BinaryOperator(LHS.get(), RHS.get(), Opc, ResultTy, VK,
12706  OK, OpLoc, FPFeatures);
12707  }
12708 
12709  // Handle compound assignments.
12710  if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() !=
12711  OK_ObjCProperty) {
12712  VK = VK_LValue;
12713  OK = LHS.get()->getObjectKind();
12714  }
12715 
12716  if (ConvertHalfVec)
12717  return convertHalfVecBinOp(*this, LHS, RHS, Opc, ResultTy, VK, OK, true,
12718  OpLoc, FPFeatures);
12719 
12720  return new (Context) CompoundAssignOperator(
12721  LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, CompLHSTy, CompResultTy,
12722  OpLoc, FPFeatures);
12723 }
12724 
12725 /// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison
12726 /// operators are mixed in a way that suggests that the programmer forgot that
12727 /// comparison operators have higher precedence. The most typical example of
12728 /// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1".
12730  SourceLocation OpLoc, Expr *LHSExpr,
12731  Expr *RHSExpr) {
12732  BinaryOperator *LHSBO = dyn_cast<BinaryOperator>(LHSExpr);
12733  BinaryOperator *RHSBO = dyn_cast<BinaryOperator>(RHSExpr);
12734 
12735  // Check that one of the sides is a comparison operator and the other isn't.
12736  bool isLeftComp = LHSBO && LHSBO->isComparisonOp();
12737  bool isRightComp = RHSBO && RHSBO->isComparisonOp();
12738  if (isLeftComp == isRightComp)
12739  return;
12740 
12741  // Bitwise operations are sometimes used as eager logical ops.
12742  // Don't diagnose this.
12743  bool isLeftBitwise = LHSBO && LHSBO->isBitwiseOp();
12744  bool isRightBitwise = RHSBO && RHSBO->isBitwiseOp();
12745  if (isLeftBitwise || isRightBitwise)
12746  return;
12747 
12748  SourceRange DiagRange = isLeftComp
12749  ? SourceRange(LHSExpr->getBeginLoc(), OpLoc)
12750  : SourceRange(OpLoc, RHSExpr->getEndLoc());
12751  StringRef OpStr = isLeftComp ? LHSBO->getOpcodeStr() : RHSBO->getOpcodeStr();
12752  SourceRange ParensRange =
12753  isLeftComp
12754  ? SourceRange(LHSBO->getRHS()->getBeginLoc(), RHSExpr->getEndLoc())
12755  : SourceRange(LHSExpr->getBeginLoc(), RHSBO->getLHS()->getEndLoc());
12756 
12757  Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
12758  << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr;
12759  SuggestParentheses(Self, OpLoc,
12760  Self.PDiag(diag::note_precedence_silence) << OpStr,
12761  (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
12762  SuggestParentheses(Self, OpLoc,
12763  Self.PDiag(diag::note_precedence_bitwise_first)
12765  ParensRange);
12766 }
12767 
12768 /// It accepts a '&&' expr that is inside a '||' one.
12769 /// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
12770 /// in parentheses.
12771 static void
12773  BinaryOperator *Bop) {
12774  assert(Bop->getOpcode() == BO_LAnd);
12775  Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or)
12776  << Bop->getSourceRange() << OpLoc;
12777  SuggestParentheses(Self, Bop->getOperatorLoc(),
12778  Self.PDiag(diag::note_precedence_silence)
12779  << Bop->getOpcodeStr(),
12780  Bop->getSourceRange());
12781 }
12782 
12783 /// Returns true if the given expression can be evaluated as a constant
12784 /// 'true'.
12785 static bool EvaluatesAsTrue(Sema &S, Expr *E) {
12786  bool Res;
12787  return !E->isValueDependent() &&
12788  E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res;
12789 }
12790 
12791 /// Returns true if the given expression can be evaluated as a constant
12792 /// 'false'.
12793 static bool EvaluatesAsFalse(Sema &S, Expr *E) {
12794  bool Res;
12795  return !E->isValueDependent() &&
12796  E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res;
12797 }
12798 
12799 /// Look for '&&' in the left hand of a '||' expr.
12801  Expr *LHSExpr, Expr *RHSExpr) {
12802  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) {
12803  if (Bop->getOpcode() == BO_LAnd) {
12804  // If it's "a && b || 0" don't warn since the precedence doesn't matter.
12805  if (EvaluatesAsFalse(S, RHSExpr))
12806  return;
12807  // If it's "1 && a || b" don't warn since the precedence doesn't matter.
12808  if (!EvaluatesAsTrue(S, Bop->getLHS()))
12809  return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
12810  } else if (Bop->getOpcode() == BO_LOr) {
12811  if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
12812  // If it's "a || b && 1 || c" we didn't warn earlier for
12813  // "a || b && 1", but warn now.
12814  if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS()))
12815  return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop);
12816  }
12817  }
12818  }
12819 }
12820 
12821 /// Look for '&&' in the right hand of a '||' expr.
12823  Expr *LHSExpr, Expr *RHSExpr) {
12824  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) {
12825  if (Bop->getOpcode() == BO_LAnd) {
12826  // If it's "0 || a && b" don't warn since the precedence doesn't matter.
12827  if (EvaluatesAsFalse(S, LHSExpr))
12828  return;
12829  // If it's "a || b && 1" don't warn since the precedence doesn't matter.
12830  if (!EvaluatesAsTrue(S, Bop->getRHS()))
12831  return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
12832  }
12833  }
12834 }
12835 
12836 /// Look for bitwise op in the left or right hand of a bitwise op with
12837 /// lower precedence and emit a diagnostic together with a fixit hint that wraps
12838 /// the '&' expression in parentheses.
12840  SourceLocation OpLoc, Expr *SubExpr) {
12841  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {
12842  if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
12843  S.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
12844  << Bop->getOpcodeStr() << BinaryOperator::getOpcodeStr(Opc)
12845  << Bop->getSourceRange() << OpLoc;
12846  SuggestParentheses(S, Bop->getOperatorLoc(),
12847  S.PDiag(diag::note_precedence_silence)
12848  << Bop->getOpcodeStr(),
12849  Bop->getSourceRange());
12850  }
12851  }
12852 }
12853 
12855  Expr *SubExpr, StringRef Shift) {
12856  if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {
12857  if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
12858  StringRef Op = Bop->getOpcodeStr();
12859  S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
12860  << Bop->getSourceRange() << OpLoc << Shift << Op;
12861  SuggestParentheses(S, Bop->getOperatorLoc(),
12862  S.PDiag(diag::note_precedence_silence) << Op,
12863  Bop->getSourceRange());
12864  }
12865  }
12866 }
12867 
12869  Expr *LHSExpr, Expr *RHSExpr) {
12870  CXXOperatorCallExpr *OCE = dyn_cast<CXXOperatorCallExpr>(LHSExpr);
12871  if (!OCE)
12872  return;
12873 
12874  FunctionDecl *FD = OCE->getDirectCallee();
12875  if (!FD || !FD->isOverloadedOperator())
12876  return;
12877 
12879  if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
12880  return;
12881 
12882  S.Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
12883  << LHSExpr->getSourceRange() << RHSExpr->getSourceRange()
12884  << (Kind == OO_LessLess);
12886  S.PDiag(diag::note_precedence_silence)
12887  << (Kind == OO_LessLess ? "<<" : ">>"),
12888  OCE->getSourceRange());
12890  S, OpLoc, S.PDiag(diag::note_evaluate_comparison_first),
12891  SourceRange(OCE->getArg(1)->getBeginLoc(), RHSExpr->getEndLoc()));
12892 }
12893 
12894 /// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky
12895 /// precedence.
12897  SourceLocation OpLoc, Expr *LHSExpr,
12898  Expr *RHSExpr){
12899  // Diagnose "arg1 'bitwise' arg2 'eq' arg3".
12900  if (BinaryOperator::isBitwiseOp(Opc))
12901  DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr);
12902 
12903  // Diagnose "arg1 & arg2 | arg3"
12904  if ((Opc == BO_Or || Opc == BO_Xor) &&
12905  !OpLoc.isMacroID()/* Don't warn in macros. */) {
12906  DiagnoseBitwiseOpInBitwiseOp(Self, Opc, OpLoc, LHSExpr);
12907  DiagnoseBitwiseOpInBitwiseOp(Self, Opc, OpLoc, RHSExpr);
12908  }
12909 
12910  // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does.
12911  // We don't warn for 'assert(a || b && "bad")' since this is safe.
12912  if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) {
12913  DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr);
12914  DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr);
12915  }
12916 
12917  if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext()))
12918  || Opc == BO_Shr) {
12919  StringRef Shift = BinaryOperator::getOpcodeStr(Opc);
12920  DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift);
12921  DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift);
12922  }
12923 
12924  // Warn on overloaded shift operators and comparisons, such as:
12925  // cout << 5 == 4;
12927  DiagnoseShiftCompare(Self, OpLoc, LHSExpr, RHSExpr);
12928 }
12929 
12930 // Binary Operators. 'Tok' is the token for the operator.
12932  tok::TokenKind Kind,
12933  Expr *LHSExpr, Expr *RHSExpr) {
12934  BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
12935  assert(LHSExpr && "ActOnBinOp(): missing left expression");
12936  assert(RHSExpr && "ActOnBinOp(): missing right expression");
12937 
12938  // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
12939  DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr);
12940 
12941  return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
12942 }
12943 
12944 /// Build an overloaded binary operator expression in the given scope.
12946  BinaryOperatorKind Opc,
12947  Expr *LHS, Expr *RHS) {
12948  switch (Opc) {
12949  case BO_Assign:
12950  case BO_DivAssign:
12951  case BO_RemAssign:
12952  case BO_SubAssign:
12953  case BO_AndAssign:
12954  case BO_OrAssign:
12955  case BO_XorAssign:
12956  DiagnoseSelfAssignment(S, LHS, RHS, OpLoc, false);
12957  CheckIdentityFieldAssignment(LHS, RHS, OpLoc, S);
12958  break;
12959  default:
12960  break;
12961  }
12962 
12963  // Find all of the overloaded operators visible from this
12964  // point. We perform both an operator-name lookup from the local
12965  // scope and an argument-dependent lookup based on the types of
12966  // the arguments.
12967  UnresolvedSet<16> Functions;
12968  OverloadedOperatorKind OverOp
12970  if (Sc && OverOp != OO_None && OverOp != OO_Equal)
12971  S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(),
12972  RHS->getType(), Functions);
12973 
12974  // Build the (potentially-overloaded, potentially-dependent)
12975  // binary operation.
12976  return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS);
12977 }
12978 
12980  BinaryOperatorKind Opc,
12981  Expr *LHSExpr, Expr *RHSExpr) {
12982  ExprResult LHS, RHS;
12983  std::tie(LHS, RHS) = CorrectDelayedTyposInBinOp(*this, Opc, LHSExpr, RHSExpr);
12984  if (!LHS.isUsable() || !RHS.isUsable())
12985  return ExprError();
12986  LHSExpr = LHS.get();
12987  RHSExpr = RHS.get();
12988 
12989  // We want to end up calling one of checkPseudoObjectAssignment
12990  // (if the LHS is a pseudo-object), BuildOverloadedBinOp (if
12991  // both expressions are overloadable or either is type-dependent),
12992  // or CreateBuiltinBinOp (in any other case). We also want to get
12993  // any placeholder types out of the way.
12994 
12995  // Handle pseudo-objects in the LHS.
12996  if (const BuiltinType *pty = LHSExpr->getType()->getAsPlaceholderType()) {
12997  // Assignments with a pseudo-object l-value need special analysis.
12998  if (pty->getKind() == BuiltinType::PseudoObject &&
13000  return checkPseudoObjectAssignment(S, OpLoc, Opc, LHSExpr, RHSExpr);
13001 
13002  // Don't resolve overloads if the other type is overloadable.
13003  if (getLangOpts().CPlusPlus && pty->getKind() == BuiltinType::Overload) {
13004  // We can't actually test that if we still have a placeholder,
13005  // though. Fortunately, none of the exceptions we see in that
13006  // code below are valid when the LHS is an overload set. Note
13007  // that an overload set can be dependently-typed, but it never
13008  // instantiates to having an overloadable type.
13009  ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
13010  if (resolvedRHS.isInvalid()) return ExprError();
13011  RHSExpr = resolvedRHS.get();
13012 
13013  if (RHSExpr->isTypeDependent() ||
13014  RHSExpr->getType()->isOverloadableType())
13015  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
13016  }
13017 
13018  // If we're instantiating "a.x < b" or "A::x < b" and 'x' names a function
13019  // template, diagnose the missing 'template' keyword instead of diagnosing
13020  // an invalid use of a bound member function.
13021  //
13022  // Note that "A::x < b" might be valid if 'b' has an overloadable type due
13023  // to C++1z [over.over]/1.4, but we already checked for that case above.
13024  if (Opc == BO_LT && inTemplateInstantiation() &&
13025  (pty->getKind() == BuiltinType::BoundMember ||
13026  pty->getKind() == BuiltinType::Overload)) {
13027  auto *OE = dyn_cast<OverloadExpr>(LHSExpr);
13028  if (OE && !OE->hasTemplateKeyword() && !OE->hasExplicitTemplateArgs() &&
13029  std::any_of(OE->decls_begin(), OE->decls_end(), [](NamedDecl *ND) {
13030  return isa<FunctionTemplateDecl>(ND);
13031  })) {
13032  Diag(OE->getQualifier() ? OE->getQualifierLoc().getBeginLoc()
13033  : OE->getNameLoc(),
13034  diag::err_template_kw_missing)
13035  << OE->getName().getAsString() << "";
13036  return ExprError();
13037  }
13038  }
13039 
13040  ExprResult LHS = CheckPlaceholderExpr(LHSExpr);
13041  if (LHS.isInvalid()) return ExprError();
13042  LHSExpr = LHS.get();
13043  }
13044 
13045  // Handle pseudo-objects in the RHS.
13046  if (const BuiltinType *pty = RHSExpr->getType()->getAsPlaceholderType()) {
13047  // An overload in the RHS can potentially be resolved by the type
13048  // being assigned to.
13049  if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
13050  if (getLangOpts().CPlusPlus &&
13051  (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent() ||
13052  LHSExpr->getType()->isOverloadableType()))
13053  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
13054 
13055  return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
13056  }
13057 
13058  // Don't resolve overloads if the other type is overloadable.
13059  if (getLangOpts().CPlusPlus && pty->getKind() == BuiltinType::Overload &&
13060  LHSExpr->getType()->isOverloadableType())
13061  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
13062 
13063  ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
13064  if (!resolvedRHS.isUsable()) return ExprError();
13065  RHSExpr = resolvedRHS.get();
13066  }
13067 
13068  if (getLangOpts().CPlusPlus) {
13069  // If either expression is type-dependent, always build an
13070  // overloaded op.
13071  if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())
13072  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
13073 
13074  // Otherwise, build an overloaded op if either expression has an
13075  // overloadable type.
13076  if (LHSExpr->getType()->isOverloadableType() ||
13077  RHSExpr->getType()->isOverloadableType())
13078  return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
13079  }
13080 
13081  // Build a built-in binary operation.
13082  return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
13083 }
13084 
13086  if (T.isNull() || T->isDependentType())
13087  return false;
13088 
13089  if (!T->isPromotableIntegerType())
13090  return true;
13091 
13092  return Ctx.getIntWidth(T) >= Ctx.getIntWidth(Ctx.IntTy);
13093 }
13094 
13096  UnaryOperatorKind Opc,
13097  Expr *InputExpr) {
13098  ExprResult Input = InputExpr;
13099  ExprValueKind VK = VK_RValue;
13101  QualType resultType;
13102  bool CanOverflow = false;
13103 
13104  bool ConvertHalfVec = false;
13105  if (getLangOpts().OpenCL) {
13106  QualType Ty = InputExpr->getType();
13107  // The only legal unary operation for atomics is '&'.
13108  if ((Opc != UO_AddrOf && Ty->isAtomicType()) ||
13109  // OpenCL special types - image, sampler, pipe, and blocks are to be used
13110  // only with a builtin functions and therefore should be disallowed here.
13111  (Ty->isImageType() || Ty->isSamplerT() || Ty->isPipeType()
13112  || Ty->isBlockPointerType())) {
13113  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
13114  << InputExpr->getType()
13115  << Input.get()->getSourceRange());
13116  }
13117  }
13118  // Diagnose operations on the unsupported types for OpenMP device compilation.
13119  if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice) {
13122  checkOpenMPDeviceExpr(InputExpr);
13123  }
13124 
13125  switch (Opc) {
13126  case UO_PreInc:
13127  case UO_PreDec:
13128  case UO_PostInc:
13129  case UO_PostDec:
13130  resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OK,
13131  OpLoc,
13132  Opc == UO_PreInc ||
13133  Opc == UO_PostInc,
13134  Opc == UO_PreInc ||
13135  Opc == UO_PreDec);
13136  CanOverflow = isOverflowingIntegerType(Context, resultType);
13137  break;
13138  case UO_AddrOf:
13139  resultType = CheckAddressOfOperand(Input, OpLoc);
13140  CheckAddressOfNoDeref(InputExpr);
13141  RecordModifiableNonNullParam(*this, InputExpr);
13142  break;
13143  case UO_Deref: {
13144  Input = DefaultFunctionArrayLvalueConversion(Input.get());
13145  if (Input.isInvalid()) return ExprError();
13146  resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc);
13147  break;
13148  }
13149  case UO_Plus:
13150  case UO_Minus:
13151  CanOverflow = Opc == UO_Minus &&
13152  isOverflowingIntegerType(Context, Input.get()->getType());
13153  Input = UsualUnaryConversions(Input.get());
13154  if (Input.isInvalid()) return ExprError();
13155  // Unary plus and minus require promoting an operand of half vector to a
13156  // float vector and truncating the result back to a half vector. For now, we
13157  // do this only when HalfArgsAndReturns is set (that is, when the target is
13158  // arm or arm64).
13159  ConvertHalfVec =
13160  needsConversionOfHalfVec(true, Context, Input.get()->getType());
13161 
13162  // If the operand is a half vector, promote it to a float vector.
13163  if (ConvertHalfVec)
13164  Input = convertVector(Input.get(), Context.FloatTy, *this);
13165  resultType = Input.get()->getType();
13166  if (resultType->isDependentType())
13167  break;
13168  if (resultType->isArithmeticType()) // C99 6.5.3.3p1
13169  break;
13170  else if (resultType->isVectorType() &&
13171  // The z vector extensions don't allow + or - with bool vectors.
13172  (!Context.getLangOpts().ZVector ||
13173  resultType->getAs<VectorType>()->getVectorKind() !=
13175  break;
13176  else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6
13177  Opc == UO_Plus &&
13178  resultType->isPointerType())
13179  break;
13180 
13181  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
13182  << resultType << Input.get()->getSourceRange());
13183 
13184  case UO_Not: // bitwise complement
13185  Input = UsualUnaryConversions(Input.get());
13186  if (Input.isInvalid())
13187  return ExprError();
13188  resultType = Input.get()->getType();
13189 
13190  if (resultType->isDependentType())
13191  break;
13192  // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
13193  if (resultType->isComplexType() || resultType->isComplexIntegerType())
13194  // C99 does not support '~' for complex conjugation.
13195  Diag(OpLoc, diag::ext_integer_complement_complex)
13196  << resultType << Input.get()->getSourceRange();
13197  else if (resultType->hasIntegerRepresentation())
13198  break;
13199  else if (resultType->isExtVectorType() && Context.getLangOpts().OpenCL) {
13200  // OpenCL v1.1 s6.3.f: The bitwise operator not (~) does not operate
13201  // on vector float types.
13202  QualType T = resultType->getAs<ExtVectorType>()->getElementType();
13203  if (!T->isIntegerType())
13204  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
13205  << resultType << Input.get()->getSourceRange());
13206  } else {
13207  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
13208  << resultType << Input.get()->getSourceRange());
13209  }
13210  break;
13211 
13212  case UO_LNot: // logical negation
13213  // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
13214  Input = DefaultFunctionArrayLvalueConversion(Input.get());
13215  if (Input.isInvalid()) return ExprError();
13216  resultType = Input.get()->getType();
13217 
13218  // Though we still have to promote half FP to float...
13219  if (resultType->isHalfType() && !Context.getLangOpts().NativeHalfType) {
13220  Input = ImpCastExprToType(Input.get(), Context.FloatTy, CK_FloatingCast).get();
13221  resultType = Context.FloatTy;
13222  }
13223 
13224  if (resultType->isDependentType())
13225  break;
13226  if (resultType->isScalarType() && !isScopedEnumerationType(resultType)) {
13227  // C99 6.5.3.3p1: ok, fallthrough;
13228  if (Context.getLangOpts().CPlusPlus) {
13229  // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9:
13230  // operand contextually converted to bool.
13231  Input = ImpCastExprToType(Input.get(), Context.BoolTy,
13232  ScalarTypeToBooleanCastKind(resultType));
13233  } else if (Context.getLangOpts().OpenCL &&
13234  Context.getLangOpts().OpenCLVersion < 120) {
13235  // OpenCL v1.1 6.3.h: The logical operator not (!) does not
13236  // operate on scalar float types.
13237  if (!resultType->isIntegerType() && !resultType->isPointerType())
13238  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
13239  << resultType << Input.get()->getSourceRange());
13240  }
13241  } else if (resultType->isExtVectorType()) {
13242  if (Context.getLangOpts().OpenCL &&
13243  Context.getLangOpts().OpenCLVersion < 120 &&
13244  !Context.getLangOpts().OpenCLCPlusPlus) {
13245  // OpenCL v1.1 6.3.h: The logical operator not (!) does not
13246  // operate on vector float types.
13247  QualType T = resultType->getAs<ExtVectorType>()->getElementType();
13248  if (!T->isIntegerType())
13249  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
13250  << resultType << Input.get()->getSourceRange());
13251  }
13252  // Vector logical not returns the signed variant of the operand type.
13253  resultType = GetSignedVectorType(resultType);
13254  break;
13255  } else {
13256  // FIXME: GCC's vector extension permits the usage of '!' with a vector
13257  // type in C++. We should allow that here too.
13258  return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
13259  << resultType << Input.get()->getSourceRange());
13260  }
13261 
13262  // LNot always has type int. C99 6.5.3.3p5.
13263  // In C++, it's bool. C++ 5.3.1p8
13264  resultType = Context.getLogicalOperationType();
13265  break;
13266  case UO_Real:
13267  case UO_Imag:
13268  resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real);
13269  // _Real maps ordinary l-values into ordinary l-values. _Imag maps ordinary
13270  // complex l-values to ordinary l-values and all other values to r-values.
13271  if (Input.isInvalid()) return ExprError();
13272  if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) {
13273  if (Input.get()->getValueKind() != VK_RValue &&
13274  Input.get()->getObjectKind() == OK_Ordinary)
13275  VK = Input.get()->getValueKind();
13276  } else if (!getLangOpts().CPlusPlus) {
13277  // In C, a volatile scalar is read by __imag. In C++, it is not.
13278  Input = DefaultLvalueConversion(Input.get());
13279  }
13280  break;
13281  case UO_Extension:
13282  resultType = Input.get()->getType();
13283  VK = Input.get()->getValueKind();
13284  OK = Input.get()->getObjectKind();
13285  break;
13286  case UO_Coawait:
13287  // It's unnecessary to represent the pass-through operator co_await in the
13288  // AST; just return the input expression instead.
13289  assert(!Input.get()->getType()->isDependentType() &&
13290  "the co_await expression must be non-dependant before "
13291  "building operator co_await");
13292  return Input;
13293  }
13294  if (resultType.isNull() || Input.isInvalid())
13295  return ExprError();
13296 
13297  // Check for array bounds violations in the operand of the UnaryOperator,
13298  // except for the '*' and '&' operators that have to be handled specially
13299  // by CheckArrayAccess (as there are special cases like &array[arraysize]
13300  // that are explicitly defined as valid by the standard).
13301  if (Opc != UO_AddrOf && Opc != UO_Deref)
13302  CheckArrayAccess(Input.get());
13303 
13304  auto *UO = new (Context)
13305  UnaryOperator(Input.get(), Opc, resultType, VK, OK, OpLoc, CanOverflow);
13306 
13307  if (Opc == UO_Deref && UO->getType()->hasAttr(attr::NoDeref) &&
13308  !isa<ArrayType>(UO->getType().getDesugaredType(Context)))
13309  ExprEvalContexts.back().PossibleDerefs.insert(UO);
13310 
13311  // Convert the result back to a half vector.
13312  if (ConvertHalfVec)
13313  return convertVector(UO, Context.HalfTy, *this);
13314  return UO;
13315 }
13316 
13317 /// Determine whether the given expression is a qualified member
13318 /// access expression, of a form that could be turned into a pointer to member
13319 /// with the address-of operator.
13321  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
13322  if (!DRE->getQualifier())
13323  return false;
13324 
13325  ValueDecl *VD = DRE->getDecl();
13326  if (!VD->isCXXClassMember())
13327  return false;
13328 
13329  if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
13330  return true;
13331  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(VD))
13332  return Method->isInstance();
13333 
13334  return false;
13335  }
13336 
13337  if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
13338  if (!ULE->getQualifier())
13339  return false;
13340 
13341  for (NamedDecl *D : ULE->decls()) {
13342  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
13343  if (Method->isInstance())
13344  return true;
13345  } else {
13346  // Overload set does not contain methods.
13347  break;
13348  }
13349  }
13350 
13351  return false;
13352  }
13353 
13354  return false;
13355 }
13356 
13358  UnaryOperatorKind Opc, Expr *Input) {
13359  // First things first: handle placeholders so that the
13360  // overloaded-operator check considers the right type.
13361  if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) {
13362  // Increment and decrement of pseudo-object references.
13363  if (pty->getKind() == BuiltinType::PseudoObject &&
13365  return checkPseudoObjectIncDec(S, OpLoc, Opc, Input);
13366 
13367  // extension is always a builtin operator.
13368  if (Opc == UO_Extension)
13369  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
13370 
13371  // & gets special logic for several kinds of placeholder.
13372  // The builtin code knows what to do.
13373  if (Opc == UO_AddrOf &&
13374  (pty->getKind() == BuiltinType::Overload ||
13375  pty->getKind() == BuiltinType::UnknownAny ||
13376  pty->getKind() == BuiltinType::BoundMember))
13377  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
13378 
13379  // Anything else needs to be handled now.
13380  ExprResult Result = CheckPlaceholderExpr(Input);
13381  if (Result.isInvalid()) return ExprError();
13382  Input = Result.get();
13383  }
13384 
13385  if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() &&
13387  !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) {
13388  // Find all of the overloaded operators visible from this
13389  // point. We perform both an operator-name lookup from the local
13390  // scope and an argument-dependent lookup based on the types of
13391  // the arguments.
13392  UnresolvedSet<16> Functions;
13394  if (S && OverOp != OO_None)
13395  LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
13396  Functions);
13397 
13398  return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input);
13399  }
13400 
13401  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
13402 }
13403 
13404 // Unary Operators. 'Tok' is the token for the operator.
13406  tok::TokenKind Op, Expr *Input) {
13407  return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input);
13408 }
13409 
13410 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
13412  LabelDecl *TheDecl) {
13413  TheDecl->markUsed(Context);
13414  // Create the AST node. The address of a label always has type 'void*'.
13415  return new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl,
13416  Context.getPointerType(Context.VoidTy));
13417 }
13418 
13420  PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
13421 }
13422 
13424  // Note that function is also called by TreeTransform when leaving a
13425  // StmtExpr scope without rebuilding anything.
13426 
13427  DiscardCleanupsInEvaluationContext();
13428  PopExpressionEvaluationContext();
13429 }
13430 
13431 ExprResult
13433  SourceLocation RPLoc) { // "({..})"
13434  assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
13435  CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
13436 
13437  if (hasAnyUnrecoverableErrorsInThisFunction())
13438  DiscardCleanupsInEvaluationContext();
13439  assert(!Cleanup.exprNeedsCleanups() &&
13440  "cleanups within StmtExpr not correctly bound!");
13441  PopExpressionEvaluationContext();
13442 
13443  // FIXME: there are a variety of strange constraints to enforce here, for
13444  // example, it is not possible to goto into a stmt expression apparently.
13445  // More semantic analysis is needed.
13446 
13447  // If there are sub-stmts in the compound stmt, take the type of the last one
13448  // as the type of the stmtexpr.
13449  QualType Ty = Context.VoidTy;
13450  bool StmtExprMayBindToTemp = false;
13451  if (!Compound->body_empty()) {
13452  // For GCC compatibility we get the last Stmt excluding trailing NullStmts.
13453  if (const auto *LastStmt =
13454  dyn_cast<ValueStmt>(Compound->getStmtExprResult())) {
13455  if (const Expr *Value = LastStmt->getExprStmt()) {
13456  StmtExprMayBindToTemp = true;
13457  Ty = Value->getType();
13458  }
13459  }
13460  }
13461 
13462  // FIXME: Check that expression type is complete/non-abstract; statement
13463  // expressions are not lvalues.
13464  Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc);
13465  if (StmtExprMayBindToTemp)
13466  return MaybeBindToTemporary(ResStmtExpr);
13467  return ResStmtExpr;
13468 }
13469 
13471  if (ER.isInvalid())
13472  return ExprError();
13473 
13474  // Do function/array conversion on the last expression, but not
13475  // lvalue-to-rvalue. However, initialize an unqualified type.
13476  ER = DefaultFunctionArrayConversion(ER.get());
13477  if (ER.isInvalid())
13478  return ExprError();
13479  Expr *E = ER.get();
13480 
13481  if (E->isTypeDependent())
13482  return E;
13483 
13484  // In ARC, if the final expression ends in a consume, splice
13485  // the consume out and bind it later. In the alternate case
13486  // (when dealing with a retainable type), the result
13487  // initialization will create a produce. In both cases the
13488  // result will be +1, and we'll need to balance that out with
13489  // a bind.
13490  auto *Cast = dyn_cast<ImplicitCastExpr>(E);
13491  if (Cast && Cast->getCastKind() == CK_ARCConsumeObject)
13492  return Cast->getSubExpr();
13493 
13494  // FIXME: Provide a better location for the initialization.
13495  return PerformCopyInitialization(
13497  E->getBeginLoc(), E->getType().getUnqualifiedType()),
13498  SourceLocation(), E);
13499 }
13500 
13502  TypeSourceInfo *TInfo,
13503  ArrayRef<OffsetOfComponent> Components,
13504  SourceLocation RParenLoc) {
13505  QualType ArgTy = TInfo->getType();
13506  bool Dependent = ArgTy->isDependentType();
13507  SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange();
13508 
13509  // We must have at least one component that refers to the type, and the first
13510  // one is known to be a field designator. Verify that the ArgTy represents
13511  // a struct/union/class.
13512  if (!Dependent && !ArgTy->isRecordType())
13513  return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type)
13514  << ArgTy << TypeRange);
13515 
13516  // Type must be complete per C99 7.17p3 because a declaring a variable
13517  // with an incomplete type would be ill-formed.
13518  if (!Dependent
13519  && RequireCompleteType(BuiltinLoc, ArgTy,
13520  diag::err_offsetof_incomplete_type, TypeRange))
13521  return ExprError();
13522 
13523  bool DidWarnAboutNonPOD = false;
13524  QualType CurrentType = ArgTy;
13526  SmallVector<Expr*, 4> Exprs;
13527  for (const OffsetOfComponent &OC : Components) {
13528  if (OC.isBrackets) {
13529  // Offset of an array sub-field. TODO: Should we allow vector elements?
13530  if (!CurrentType->isDependentType()) {
13531  const ArrayType *AT = Context.getAsArrayType(CurrentType);
13532  if(!AT)
13533  return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
13534  << CurrentType);
13535  CurrentType = AT->getElementType();
13536  } else
13537  CurrentType = Context.DependentTy;
13538 
13539  ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E));
13540  if (IdxRval.isInvalid())
13541  return ExprError();
13542  Expr *Idx = IdxRval.get();
13543 
13544  // The expression must be an integral expression.
13545  // FIXME: An integral constant expression?
13546  if (!Idx->isTypeDependent() && !Idx->isValueDependent() &&
13547  !Idx->getType()->isIntegerType())
13548  return ExprError(
13549  Diag(Idx->getBeginLoc(), diag::err_typecheck_subscript_not_integer)
13550  << Idx->getSourceRange());
13551 
13552  // Record this array index.
13553  Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
13554  Exprs.push_back(Idx);
13555  continue;
13556  }
13557 
13558  // Offset of a field.
13559  if (CurrentType->isDependentType()) {
13560  // We have the offset of a field, but we can't look into the dependent
13561  // type. Just record the identifier of the field.
13562  Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
13563  CurrentType = Context.DependentTy;
13564  continue;
13565  }
13566 
13567  // We need to have a complete type to look into.
13568  if (RequireCompleteType(OC.LocStart, CurrentType,
13569  diag::err_offsetof_incomplete_type))
13570  return ExprError();
13571 
13572  // Look for the designated field.
13573  const RecordType *RC = CurrentType->getAs<RecordType>();
13574  if (!RC)
13575  return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
13576  << CurrentType);
13577  RecordDecl *RD = RC->getDecl();
13578 
13579  // C++ [lib.support.types]p5:
13580  // The macro offsetof accepts a restricted set of type arguments in this
13581  // International Standard. type shall be a POD structure or a POD union
13582  // (clause 9).
13583  // C++11 [support.types]p4:
13584  // If type is not a standard-layout class (Clause 9), the results are
13585  // undefined.
13586  if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
13587  bool IsSafe = LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
13588  unsigned DiagID =
13589  LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
13590  : diag::ext_offsetof_non_pod_type;
13591 
13592  if (!IsSafe && !DidWarnAboutNonPOD &&
13593  DiagRuntimeBehavior(BuiltinLoc, nullptr,
13594  PDiag(DiagID)
13595  << SourceRange(Components[0].LocStart, OC.LocEnd)
13596  << CurrentType))
13597  DidWarnAboutNonPOD = true;
13598  }
13599 
13600  // Look for the field.
13601  LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName);
13602  LookupQualifiedName(R, RD);
13603  FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>();
13604  IndirectFieldDecl *IndirectMemberDecl = nullptr;
13605  if (!MemberDecl) {
13606  if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>()))
13607  MemberDecl = IndirectMemberDecl->getAnonField();
13608  }
13609 
13610  if (!MemberDecl)
13611  return ExprError(Diag(BuiltinLoc, diag::err_no_member)
13612  << OC.U.IdentInfo << RD << SourceRange(OC.LocStart,
13613  OC.LocEnd));
13614 
13615  // C99 7.17p3:
13616  // (If the specified member is a bit-field, the behavior is undefined.)
13617  //
13618  // We diagnose this as an error.
13619  if (MemberDecl->isBitField()) {
13620  Diag(OC.LocEnd, diag::err_offsetof_bitfield)
13621  << MemberDecl->getDeclName()
13622  << SourceRange(BuiltinLoc, RParenLoc);
13623  Diag(MemberDecl->getLocation(), diag::note_bitfield_decl);
13624  return ExprError();
13625  }
13626 
13627  RecordDecl *Parent = MemberDecl->getParent();
13628  if (IndirectMemberDecl)
13629  Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
13630 
13631  // If the member was found in a base class, introduce OffsetOfNodes for
13632  // the base class indirections.
13633  CXXBasePaths Paths;
13634  if (IsDerivedFrom(OC.LocStart, CurrentType, Context.getTypeDeclType(Parent),
13635  Paths)) {
13636  if (Paths.getDetectedVirtual()) {
13637  Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
13638  << MemberDecl->getDeclName()
13639  << SourceRange(BuiltinLoc, RParenLoc);
13640  return ExprError();
13641  }
13642 
13643  CXXBasePath &Path = Paths.front();
13644  for (const CXXBasePathElement &B : Path)
13645  Comps.push_back(OffsetOfNode(B.Base));
13646  }
13647 
13648  if (IndirectMemberDecl) {
13649  for (auto *FI : IndirectMemberDecl->chain()) {
13650  assert(isa<FieldDecl>(FI));
13651  Comps.push_back(OffsetOfNode(OC.LocStart,
13652  cast<FieldDecl>(FI), OC.LocEnd));
13653  }
13654  } else
13655  Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
13656 
13657  CurrentType = MemberDecl->getType().getNonReferenceType();
13658  }
13659 
13660  return OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, TInfo,
13661  Comps, Exprs, RParenLoc);
13662 }
13663 
13665  SourceLocation BuiltinLoc,
13667  ParsedType ParsedArgTy,
13668  ArrayRef<OffsetOfComponent> Components,
13669  SourceLocation RParenLoc) {
13670 
13671  TypeSourceInfo *ArgTInfo;
13672  QualType ArgTy = GetTypeFromParser(ParsedArgTy, &ArgTInfo);
13673  if (ArgTy.isNull())
13674  return ExprError();
13675 
13676  if (!ArgTInfo)
13677  ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc);
13678 
13679  return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, Components, RParenLoc);
13680 }
13681 
13682 
13684  Expr *CondExpr,
13685  Expr *LHSExpr, Expr *RHSExpr,
13686  SourceLocation RPLoc) {
13687  assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
13688 
13689  ExprValueKind VK = VK_RValue;
13691  QualType resType;
13692  bool ValueDependent = false;
13693  bool CondIsTrue = false;
13694  if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
13695  resType = Context.DependentTy;
13696  ValueDependent = true;
13697  } else {
13698  // The conditional expression is required to be a constant expression.
13699  llvm::APSInt condEval(32);
13700  ExprResult CondICE
13701  = VerifyIntegerConstantExpression(CondExpr, &condEval,
13702  diag::err_typecheck_choose_expr_requires_constant, false);
13703  if (CondICE.isInvalid())
13704  return ExprError();
13705  CondExpr = CondICE.get();
13706  CondIsTrue = condEval.getZExtValue();
13707 
13708  // If the condition is > zero, then the AST type is the same as the LHSExpr.
13709  Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
13710 
13711  resType = ActiveExpr->getType();
13712  ValueDependent = ActiveExpr->isValueDependent();
13713  VK = ActiveExpr->getValueKind();
13714  OK = ActiveExpr->getObjectKind();
13715  }
13716 
13717  return new (Context)
13718  ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, resType, VK, OK, RPLoc,
13719  CondIsTrue, resType->isDependentType(), ValueDependent);
13720 }
13721 
13722 //===----------------------------------------------------------------------===//
13723 // Clang Extensions.
13724 //===----------------------------------------------------------------------===//
13725 
13726 /// ActOnBlockStart - This callback is invoked when a block literal is started.
13727 void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) {
13728  BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc);
13729 
13730  if (LangOpts.CPlusPlus) {
13731  Decl *ManglingContextDecl;
13732  if (MangleNumberingContext *MCtx =
13733  getCurrentMangleNumberContext(Block->getDeclContext(),
13734  ManglingContextDecl)) {
13735  unsigned ManglingNumber = MCtx->getManglingNumber(Block);
13736  Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
13737  }
13738  }
13739 
13740  PushBlockScope(CurScope, Block);
13741  CurContext->addDecl(Block);
13742  if (CurScope)
13743  PushDeclContext(CurScope, Block);
13744  else
13745  CurContext = Block;
13746 
13747  getCurBlock()->HasImplicitReturnType = true;
13748 
13749  // Enter a new evaluation context to insulate the block from any
13750  // cleanups from the enclosing full-expression.
13751  PushExpressionEvaluationContext(
13752  ExpressionEvaluationContext::PotentiallyEvaluated);
13753 }
13754 
13756  Scope *CurScope) {
13757  assert(ParamInfo.getIdentifier() == nullptr &&
13758  "block-id should have no identifier!");
13759  assert(ParamInfo.getContext() == DeclaratorContext::BlockLiteralContext);
13760  BlockScopeInfo *CurBlock = getCurBlock();
13761 
13762  TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope);
13763  QualType T = Sig->getType();
13764 
13765  // FIXME: We should allow unexpanded parameter packs here, but that would,
13766  // in turn, make the block expression contain unexpanded parameter packs.
13767  if (DiagnoseUnexpandedParameterPack(CaretLoc, Sig, UPPC_Block)) {
13768  // Drop the parameters.
13770  EPI.HasTrailingReturn = false;
13771  EPI.TypeQuals.addConst();
13772  T = Context.getFunctionType(Context.DependentTy, None, EPI);
13773  Sig = Context.getTrivialTypeSourceInfo(T);
13774  }
13775 
13776  // GetTypeForDeclarator always produces a function type for a block
13777  // literal signature. Furthermore, it is always a FunctionProtoType
13778  // unless the function was written with a typedef.
13779  assert(T->isFunctionType() &&
13780  "GetTypeForDeclarator made a non-function block signature");
13781 
13782  // Look for an explicit signature in that function type.
13783  FunctionProtoTypeLoc ExplicitSignature;
13784 
13785  if ((ExplicitSignature = Sig->getTypeLoc()
13787 
13788  // Check whether that explicit signature was synthesized by
13789  // GetTypeForDeclarator. If so, don't save that as part of the
13790  // written signature.
13791  if (ExplicitSignature.getLocalRangeBegin() ==
13792  ExplicitSignature.getLocalRangeEnd()) {
13793  // This would be much cheaper if we stored TypeLocs instead of
13794  // TypeSourceInfos.
13795  TypeLoc Result = ExplicitSignature.getReturnLoc();
13796  unsigned Size = Result.getFullDataSize();
13797  Sig = Context.CreateTypeSourceInfo(Result.getType(), Size);
13798  Sig->getTypeLoc().initializeFullCopy(Result, Size);
13799 
13800  ExplicitSignature = FunctionProtoTypeLoc();
13801  }
13802  }
13803 
13804  CurBlock->TheDecl->setSignatureAsWritten(Sig);
13805  CurBlock->FunctionType = T;
13806 
13807  const FunctionType *Fn = T->getAs<FunctionType>();
13808  QualType RetTy = Fn->getReturnType();
13809  bool isVariadic =
13810  (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
13811 
13812  CurBlock->TheDecl->setIsVariadic(isVariadic);
13813 
13814  // Context.DependentTy is used as a placeholder for a missing block
13815  // return type. TODO: what should we do with declarators like:
13816  // ^ * { ... }
13817  // If the answer is "apply template argument deduction"....
13818  if (RetTy != Context.DependentTy) {
13819  CurBlock->ReturnType = RetTy;
13820  CurBlock->TheDecl->setBlockMissingReturnType(false);
13821  CurBlock->HasImplicitReturnType = false;
13822  }
13823 
13824  // Push block parameters from the declarator if we had them.
13826  if (ExplicitSignature) {
13827  for (unsigned I = 0, E = ExplicitSignature.getNumParams(); I != E; ++I) {
13828  ParmVarDecl *Param = ExplicitSignature.getParam(I);
13829  if (Param->getIdentifier() == nullptr &&
13830  !Param->isImplicit() &&
13831  !Param->isInvalidDecl() &&
13832  !getLangOpts().CPlusPlus)
13833  Diag(Param->getLocation(), diag::err_parameter_name_omitted);
13834  Params.push_back(Param);
13835  }
13836 
13837  // Fake up parameter variables if we have a typedef, like
13838  // ^ fntype { ... }
13839  } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) {
13840  for (const auto &I : Fn->param_types()) {
13841  ParmVarDecl *Param = BuildParmVarDeclForTypedef(
13842  CurBlock->TheDecl, ParamInfo.getBeginLoc(), I);
13843  Params.push_back(Param);
13844  }
13845  }
13846 
13847  // Set the parameters on the block decl.
13848  if (!Params.empty()) {
13849  CurBlock->TheDecl->setParams(Params);
13850  CheckParmsForFunctionDef(CurBlock->TheDecl->parameters(),
13851  /*CheckParameterNames=*/false);
13852  }
13853 
13854  // Finally we can process decl attributes.
13855  ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
13856 
13857  // Put the parameter variables in scope.
13858  for (auto AI : CurBlock->TheDecl->parameters()) {
13859  AI->setOwningFunction(CurBlock->TheDecl);
13860 
13861  // If this has an identifier, add it to the scope stack.
13862  if (AI->getIdentifier()) {
13863  CheckShadow(CurBlock->TheScope, AI);
13864 
13865  PushOnScopeChains(AI, CurBlock->TheScope);
13866  }
13867  }
13868 }
13869 
13870 /// ActOnBlockError - If there is an error parsing a block, this callback
13871 /// is invoked to pop the information about the block from the action impl.
13872 void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
13873  // Leave the expression-evaluation context.
13874  DiscardCleanupsInEvaluationContext();
13875  PopExpressionEvaluationContext();
13876 
13877  // Pop off CurBlock, handle nested blocks.
13878  PopDeclContext();
13879  PopFunctionScopeInfo();
13880 }
13881 
13882 /// ActOnBlockStmtExpr - This is called when the body of a block statement
13883 /// literal was successfully completed. ^(int x){...}
13885  Stmt *Body, Scope *CurScope) {
13886  // If blocks are disabled, emit an error.
13887  if (!LangOpts.Blocks)
13888  Diag(CaretLoc, diag::err_blocks_disable) << LangOpts.OpenCL;
13889 
13890  // Leave the expression-evaluation context.
13891  if (hasAnyUnrecoverableErrorsInThisFunction())
13892  DiscardCleanupsInEvaluationContext();
13893  assert(!Cleanup.exprNeedsCleanups() &&
13894  "cleanups within block not correctly bound!");
13895  PopExpressionEvaluationContext();
13896 
13897  BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back());
13898  BlockDecl *BD = BSI->TheDecl;
13899 
13900  if (BSI->HasImplicitReturnType)
13901  deduceClosureReturnType(*BSI);
13902 
13903  QualType RetTy = Context.VoidTy;
13904  if (!BSI->ReturnType.isNull())
13905  RetTy = BSI->ReturnType;
13906 
13907  bool NoReturn = BD->hasAttr<NoReturnAttr>();
13908  QualType BlockTy;
13909 
13910  // If the user wrote a function type in some form, try to use that.
13911  if (!BSI->FunctionType.isNull()) {
13912  const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>();
13913 
13914  FunctionType::ExtInfo Ext = FTy->getExtInfo();
13915  if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true);
13916 
13917  // Turn protoless block types into nullary block types.
13918  if (isa<FunctionNoProtoType>(FTy)) {
13920  EPI.ExtInfo = Ext;
13921  BlockTy = Context.getFunctionType(RetTy, None, EPI);
13922 
13923  // Otherwise, if we don't need to change anything about the function type,
13924  // preserve its sugar structure.
13925  } else if (FTy->getReturnType() == RetTy &&
13926  (!NoReturn || FTy->getNoReturnAttr())) {
13927  BlockTy = BSI->FunctionType;
13928 
13929  // Otherwise, make the minimal modifications to the function type.
13930  } else {
13931  const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy);
13933  EPI.TypeQuals = Qualifiers();
13934  EPI.ExtInfo = Ext;
13935  BlockTy = Context.getFunctionType(RetTy, FPT->getParamTypes(), EPI);
13936  }
13937 
13938  // If we don't have a function type, just build one from nothing.
13939  } else {
13941  EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn);
13942  BlockTy = Context.getFunctionType(RetTy, None, EPI);
13943  }
13944 
13945  DiagnoseUnusedParameters(BD->parameters());
13946  BlockTy = Context.getBlockPointerType(BlockTy);
13947 
13948  // If needed, diagnose invalid gotos and switches in the block.
13949  if (getCurFunction()->NeedsScopeChecking() &&
13950  !PP.isCodeCompletionEnabled())
13951  DiagnoseInvalidJumps(cast<CompoundStmt>(Body));
13952 
13953  BD->setBody(cast<CompoundStmt>(Body));
13954 
13955  if (Body && getCurFunction()->HasPotentialAvailabilityViolations)
13956  DiagnoseUnguardedAvailabilityViolations(BD);
13957 
13958  // Try to apply the named return value optimization. We have to check again
13959  // if we can do this, though, because blocks keep return statements around
13960  // to deduce an implicit return type.
13961  if (getLangOpts().CPlusPlus && RetTy->isRecordType() &&
13962  !BD->isDependentContext())
13963  computeNRVO(Body, BSI);
13964 
13967  checkNonTrivialCUnion(RetTy, BD->getCaretLocation(), NTCUC_FunctionReturn,
13968  NTCUK_Destruct|NTCUK_Copy);
13969 
13970  PopDeclContext();
13971 
13972  // Pop the block scope now but keep it alive to the end of this function.
13973  AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
13974  PoppedFunctionScopePtr ScopeRAII = PopFunctionScopeInfo(&WP, BD, BlockTy);
13975 
13976  // Set the captured variables on the block.
13978  for (Capture &Cap : BSI->Captures) {
13979  if (Cap.isInvalid() || Cap.isThisCapture())
13980  continue;
13981 
13982  VarDecl *Var = Cap.getVariable();
13983  Expr *CopyExpr = nullptr;
13984  if (getLangOpts().CPlusPlus && Cap.isCopyCapture()) {
13985  if (const RecordType *Record =
13986  Cap.getCaptureType()->getAs<RecordType>()) {
13987  // The capture logic needs the destructor, so make sure we mark it.
13988  // Usually this is unnecessary because most local variables have
13989  // their destructors marked at declaration time, but parameters are
13990  // an exception because it's technically only the call site that
13991  // actually requires the destructor.
13992  if (isa<ParmVarDecl>(Var))
13993  FinalizeVarWithDestructor(Var, Record);
13994 
13995  // Enter a separate potentially-evaluated context while building block
13996  // initializers to isolate their cleanups from those of the block
13997  // itself.
13998  // FIXME: Is this appropriate even when the block itself occurs in an
13999  // unevaluated operand?
14001  *this, ExpressionEvaluationContext::PotentiallyEvaluated);
14002 
14003  SourceLocation Loc = Cap.getLocation();
14004 
14005  ExprResult Result = BuildDeclarationNameExpr(
14006  CXXScopeSpec(), DeclarationNameInfo(Var->getDeclName(), Loc), Var);
14007 
14008  // According to the blocks spec, the capture of a variable from
14009  // the stack requires a const copy constructor. This is not true
14010  // of the copy/move done to move a __block variable to the heap.
14011  if (!Result.isInvalid() &&
14012  !Result.get()->getType().isConstQualified()) {
14013  Result = ImpCastExprToType(Result.get(),
14014  Result.get()->getType().withConst(),
14015  CK_NoOp, VK_LValue);
14016  }
14017 
14018  if (!Result.isInvalid()) {
14019  Result = PerformCopyInitialization(
14021  Cap.getCaptureType(), false),
14022  Loc, Result.get());
14023  }
14024 
14025  // Build a full-expression copy expression if initialization
14026  // succeeded and used a non-trivial constructor. Recover from
14027  // errors by pretending that the copy isn't necessary.
14028  if (!Result.isInvalid() &&
14029  !cast<CXXConstructExpr>(Result.get())->getConstructor()
14030  ->isTrivial()) {
14031  Result = MaybeCreateExprWithCleanups(Result);
14032  CopyExpr = Result.get();
14033  }
14034  }
14035  }
14036 
14037  BlockDecl::Capture NewCap(Var, Cap.isBlockCapture(), Cap.isNested(),
14038  CopyExpr);
14039  Captures.push_back(NewCap);
14040  }
14041  BD->setCaptures(Context, Captures, BSI->CXXThisCaptureIndex != 0);
14042 
14043  BlockExpr *Result = new (Context) BlockExpr(BD, BlockTy);
14044 
14045  // If the block isn't obviously global, i.e. it captures anything at
14046  // all, then we need to do a few things in the surrounding context:
14047  if (Result->getBlockDecl()->hasCaptures()) {
14048  // First, this expression has a new cleanup object.
14049  ExprCleanupObjects.push_back(Result->getBlockDecl());
14050  Cleanup.setExprNeedsCleanups(true);
14051 
14052  // It also gets a branch-protected scope if any of the captured
14053  // variables needs destruction.
14054  for (const auto &CI : Result->getBlockDecl()->captures()) {
14055  const VarDecl *var = CI.getVariable();
14056  if (var->getType().isDestructedType() != QualType::DK_none) {
14057  setFunctionHasBranchProtectedScope();
14058  break;
14059  }
14060  }
14061  }
14062 
14063  if (getCurFunction())
14064  getCurFunction()->addBlock(BD);
14065 
14066  return Result;
14067 }
14068 
14070  SourceLocation RPLoc) {
14071  TypeSourceInfo *TInfo;
14072  GetTypeFromParser(Ty, &TInfo);
14073  return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc);
14074 }
14075 
14077  Expr *E, TypeSourceInfo *TInfo,
14078  SourceLocation RPLoc) {
14079  Expr *OrigExpr = E;
14080  bool IsMS = false;
14081 
14082  // CUDA device code does not support varargs.
14083  if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) {
14084  if (const FunctionDecl *F = dyn_cast<FunctionDecl>(CurContext)) {
14085  CUDAFunctionTarget T = IdentifyCUDATarget(F);
14086  if (T == CFT_Global || T == CFT_Device || T == CFT_HostDevice)
14087  return ExprError(Diag(E->getBeginLoc(), diag::err_va_arg_in_device));
14088  }
14089  }
14090 
14091  // NVPTX does not support va_arg expression.
14092  if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice &&
14093  Context.getTargetInfo().getTriple().isNVPTX())
14094  targetDiag(E->getBeginLoc(), diag::err_va_arg_in_device);
14095 
14096  // It might be a __builtin_ms_va_list. (But don't ever mark a va_arg()
14097  // as Microsoft ABI on an actual Microsoft platform, where
14098  // __builtin_ms_va_list and __builtin_va_list are the same.)
14099  if (!E->isTypeDependent() && Context.getTargetInfo().hasBuiltinMSVaList() &&
14101  QualType MSVaListType = Context.getBuiltinMSVaListType();
14102  if (Context.hasSameType(MSVaListType, E->getType())) {
14103  if (CheckForModifiableLvalue(E, BuiltinLoc, *this))
14104  return ExprError();
14105  IsMS = true;
14106  }
14107  }
14108 
14109  // Get the va_list type
14110  QualType VaListType = Context.getBuiltinVaListType();
14111  if (!IsMS) {
14112  if (VaListType->isArrayType()) {
14113  // Deal with implicit array decay; for example, on x86-64,
14114  // va_list is an array, but it's supposed to decay to
14115  // a pointer for va_arg.
14116  VaListType = Context.getArrayDecayedType(VaListType);
14117  // Make sure the input expression also decays appropriately.
14118  ExprResult Result = UsualUnaryConversions(E);
14119  if (Result.isInvalid())
14120  return ExprError();
14121  E = Result.get();
14122  } else if (VaListType->isRecordType() && getLangOpts().CPlusPlus) {
14123  // If va_list is a record type and we are compiling in C++ mode,
14124  // check the argument using reference binding.
14126  Context, Context.getLValueReferenceType(VaListType), false);
14127  ExprResult Init = PerformCopyInitialization(Entity, SourceLocation(), E);
14128  if (Init.isInvalid())
14129  return ExprError();
14130  E = Init.getAs<Expr>();
14131  } else {
14132  // Otherwise, the va_list argument must be an l-value because
14133  // it is modified by va_arg.
14134  if (!E->isTypeDependent() &&
14135  CheckForModifiableLvalue(E, BuiltinLoc, *this))
14136  return ExprError();
14137  }
14138  }
14139 
14140  if (!IsMS && !E->isTypeDependent() &&
14141  !Context.hasSameType(VaListType, E->getType()))
14142  return ExprError(
14143  Diag(E->getBeginLoc(),
14144  diag::err_first_argument_to_va_arg_not_of_type_va_list)
14145  << OrigExpr->getType() << E->getSourceRange());
14146 
14147  if (!TInfo->getType()->isDependentType()) {
14148  if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(),
14149  diag::err_second_parameter_to_va_arg_incomplete,
14150  TInfo->getTypeLoc()))
14151  return ExprError();
14152 
14153  if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(),
14154  TInfo->getType(),
14155  diag::err_second_parameter_to_va_arg_abstract,
14156  TInfo->getTypeLoc()))
14157  return ExprError();
14158 
14159  if (!TInfo->getType().isPODType(Context)) {
14160  Diag(TInfo->getTypeLoc().getBeginLoc(),
14161  TInfo->getType()->isObjCLifetimeType()
14162  ? diag::warn_second_parameter_to_va_arg_ownership_qualified
14163  : diag::warn_second_parameter_to_va_arg_not_pod)
14164  << TInfo->getType()
14165  << TInfo->getTypeLoc().getSourceRange();
14166  }
14167 
14168  // Check for va_arg where arguments of the given type will be promoted
14169  // (i.e. this va_arg is guaranteed to have undefined behavior).
14170  QualType PromoteType;
14171  if (TInfo->getType()->isPromotableIntegerType()) {
14172  PromoteType = Context.getPromotedIntegerType(TInfo->getType());
14173  if (Context.typesAreCompatible(PromoteType, TInfo->getType()))
14174  PromoteType = QualType();
14175  }
14176  if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float))
14177  PromoteType = Context.DoubleTy;
14178  if (!PromoteType.isNull())
14179  DiagRuntimeBehavior(TInfo->getTypeLoc().getBeginLoc(), E,
14180  PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
14181  << TInfo->getType()
14182  << PromoteType
14183  << TInfo->getTypeLoc().getSourceRange());
14184  }
14185 
14186  QualType T = TInfo->getType().getNonLValueExprType(Context);
14187  return new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T, IsMS);
14188 }
14189 
14191  // The type of __null will be int or long, depending on the size of
14192  // pointers on the target.
14193  QualType Ty;
14194  unsigned pw = Context.getTargetInfo().getPointerWidth(0);
14195  if (pw == Context.getTargetInfo().getIntWidth())
14196  Ty = Context.IntTy;
14197  else if (pw == Context.getTargetInfo().getLongWidth())
14198  Ty = Context.LongTy;
14199  else if (pw == Context.getTargetInfo().getLongLongWidth())
14200  Ty = Context.LongLongTy;
14201  else {
14202  llvm_unreachable("I don't know size of pointer!");
14203  }
14204 
14205  return new (Context) GNUNullExpr(Ty, TokenLoc);
14206 }
14207 
14209  SourceLocation BuiltinLoc,
14210  SourceLocation RPLoc) {
14211  return BuildSourceLocExpr(Kind, BuiltinLoc, RPLoc, CurContext);
14212 }
14213 
14215  SourceLocation BuiltinLoc,
14216  SourceLocation RPLoc,
14217  DeclContext *ParentContext) {
14218  return new (Context)
14219  SourceLocExpr(Context, Kind, BuiltinLoc, RPLoc, ParentContext);
14220 }
14221 
14223  bool Diagnose) {
14224  if (!getLangOpts().ObjC)
14225  return false;
14226 
14227  const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>();
14228  if (!PT)
14229  return false;
14230 
14231  if (!PT->isObjCIdType()) {
14232  // Check if the destination is the 'NSString' interface.
14233  const ObjCInterfaceDecl *ID = PT->getInterfaceDecl();
14234  if (!ID || !ID->getIdentifier()->isStr("NSString"))
14235  return false;
14236  }
14237 
14238  // Ignore any parens, implicit casts (should only be
14239  // array-to-pointer decays), and not-so-opaque values. The last is
14240  // important for making this trigger for property assignments.
14241  Expr *SrcExpr = Exp->IgnoreParenImpCasts();
14242  if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(SrcExpr))
14243  if (OV->getSourceExpr())
14244  SrcExpr = OV->getSourceExpr()->IgnoreParenImpCasts();
14245 
14246  StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr);
14247  if (!SL || !SL->isAscii())
14248  return false;
14249  if (Diagnose) {
14250  Diag(SL->getBeginLoc(), diag::err_missing_atsign_prefix)
14251  << FixItHint::CreateInsertion(SL->getBeginLoc(), "@");
14252  Exp = BuildObjCStringLiteral(SL->getBeginLoc(), SL).get();
14253  }
14254  return true;
14255 }
14256 
14258  const Expr *SrcExpr) {
14259  if (!DstType->isFunctionPointerType() ||
14260  !SrcExpr->getType()->isFunctionType())
14261  return false;
14262 
14263  auto *DRE = dyn_cast<DeclRefExpr>(SrcExpr->IgnoreParenImpCasts());
14264  if (!DRE)
14265  return false;
14266 
14267  auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
14268  if (!FD)
14269  return false;
14270 
14271  return !S.checkAddressOfFunctionIsAvailable(FD,
14272  /*Complain=*/true,
14273  SrcExpr->getBeginLoc());
14274 }
14275 
14277  SourceLocation Loc,
14278  QualType DstType, QualType SrcType,
14279  Expr *SrcExpr, AssignmentAction Action,
14280  bool *Complained) {
14281  if (Complained)
14282  *Complained = false;
14283 
14284  // Decode the result (notice that AST's are still created for extensions).
14285  bool CheckInferredResultType = false;
14286  bool isInvalid = false;
14287  unsigned DiagKind = 0;
14288  FixItHint Hint;
14289  ConversionFixItGenerator ConvHints;
14290  bool MayHaveConvFixit = false;
14291  bool MayHaveFunctionDiff = false;
14292  const ObjCInterfaceDecl *IFace = nullptr;
14293  const ObjCProtocolDecl *PDecl = nullptr;
14294 
14295  switch (ConvTy) {
14296  case Compatible:
14297  DiagnoseAssignmentEnum(DstType, SrcType, SrcExpr);
14298  return false;
14299 
14300  case PointerToInt:
14301  DiagKind = diag::ext_typecheck_convert_pointer_int;
14302  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
14303  MayHaveConvFixit = true;
14304  break;
14305  case IntToPointer:
14306  DiagKind = diag::ext_typecheck_convert_int_pointer;
14307  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
14308  MayHaveConvFixit = true;
14309  break;
14310  case IncompatiblePointer:
14311  if (Action == AA_Passing_CFAudited)
14312  DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
14313  else if (SrcType->isFunctionPointerType() &&
14314  DstType->isFunctionPointerType())
14315  DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
14316  else
14317  DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
14318 
14319  CheckInferredResultType = DstType->isObjCObjectPointerType() &&
14320  SrcType->isObjCObjectPointerType();
14321  if (Hint.isNull() && !CheckInferredResultType) {
14322  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
14323  }
14324  else if (CheckInferredResultType) {
14325  SrcType = SrcType.getUnqualifiedType();
14326  DstType = DstType.getUnqualifiedType();
14327  }
14328  MayHaveConvFixit = true;
14329  break;
14330  case IncompatiblePointerSign:
14331  DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
14332  break;
14333  case FunctionVoidPointer:
14334  DiagKind = diag::ext_typecheck_convert_pointer_void_func;
14335  break;
14336  case IncompatiblePointerDiscardsQualifiers: {
14337  // Perform array-to-pointer decay if necessary.
14338  if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType);
14339 
14340  Qualifiers lhq = SrcType->getPointeeType().getQualifiers();
14341  Qualifiers rhq = DstType->getPointeeType().getQualifiers();
14342  if (lhq.getAddressSpace() != rhq.getAddressSpace()) {
14343  DiagKind = diag::err_typecheck_incompatible_address_space;
14344  break;
14345 
14346  } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) {
14347  DiagKind = diag::err_typecheck_incompatible_ownership;
14348  break;
14349  }
14350 
14351  llvm_unreachable("unknown error case for discarding qualifiers!");
14352  // fallthrough
14353  }
14354  case CompatiblePointerDiscardsQualifiers:
14355  // If the qualifiers lost were because we were applying the
14356  // (deprecated) C++ conversion from a string literal to a char*
14357  // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME:
14358  // Ideally, this check would be performed in
14359  // checkPointerTypesForAssignment. However, that would require a
14360  // bit of refactoring (so that the second argument is an
14361  // expression, rather than a type), which should be done as part
14362  // of a larger effort to fix checkPointerTypesForAssignment for
14363  // C++ semantics.
14364  if (getLangOpts().CPlusPlus &&
14365  IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
14366  return false;
14367  DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
14368  break;
14369  case IncompatibleNestedPointerQualifiers:
14370  DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
14371  break;
14372  case IncompatibleNestedPointerAddressSpaceMismatch:
14373  DiagKind = diag::err_typecheck_incompatible_nested_address_space;
14374  break;
14375  case IntToBlockPointer:
14376  DiagKind = diag::err_int_to_block_pointer;
14377  break;
14378  case IncompatibleBlockPointer:
14379  DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
14380  break;
14381  case IncompatibleObjCQualifiedId: {
14382  if (SrcType->isObjCQualifiedIdType()) {
14383  const ObjCObjectPointerType *srcOPT =
14384  SrcType->getAs<ObjCObjectPointerType>();
14385  for (auto *srcProto : srcOPT->quals()) {
14386  PDecl = srcProto;
14387  break;
14388  }
14389  if (const ObjCInterfaceType *IFaceT =
14391  IFace = IFaceT->getDecl();
14392  }
14393  else if (DstType->isObjCQualifiedIdType()) {
14394  const ObjCObjectPointerType *dstOPT =
14395  DstType->getAs<ObjCObjectPointerType>();
14396  for (auto *dstProto : dstOPT->quals()) {
14397  PDecl = dstProto;
14398  break;
14399  }
14400  if (const ObjCInterfaceType *IFaceT =
14402  IFace = IFaceT->getDecl();
14403  }
14404  DiagKind = diag::warn_incompatible_qualified_id;
14405  break;
14406  }
14407  case IncompatibleVectors:
14408  DiagKind = diag::warn_incompatible_vectors;
14409  break;
14410  case IncompatibleObjCWeakRef:
14411  DiagKind = diag::err_arc_weak_unavailable_assign;
14412  break;
14413  case Incompatible:
14414  if (maybeDiagnoseAssignmentToFunction(*this, DstType, SrcExpr)) {
14415  if (Complained)
14416  *Complained = true;
14417  return true;
14418  }
14419 
14420  DiagKind = diag::err_typecheck_convert_incompatible;
14421  ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
14422  MayHaveConvFixit = true;
14423  isInvalid = true;
14424  MayHaveFunctionDiff = true;
14425  break;
14426  }
14427 
14428  QualType FirstType, SecondType;
14429  switch (Action) {
14430  case AA_Assigning:
14431  case AA_Initializing:
14432  // The destination type comes first.
14433  FirstType = DstType;
14434  SecondType = SrcType;
14435  break;
14436 
14437  case AA_Returning:
14438  case AA_Passing:
14439  case AA_Passing_CFAudited:
14440  case AA_Converting:
14441  case AA_Sending:
14442  case AA_Casting:
14443  // The source type comes first.
14444  FirstType = SrcType;
14445  SecondType = DstType;
14446  break;
14447  }
14448 
14449  PartialDiagnostic FDiag = PDiag(DiagKind);
14450  if (Action == AA_Passing_CFAudited)
14451  FDiag << FirstType << SecondType << AA_Passing << SrcExpr->getSourceRange();
14452  else
14453  FDiag << FirstType << SecondType << Action << SrcExpr->getSourceRange();
14454 
14455  // If we can fix the conversion, suggest the FixIts.
14456  assert(ConvHints.isNull() || Hint.isNull());
14457  if (!ConvHints.isNull()) {
14458  for (FixItHint &H : ConvHints.Hints)
14459  FDiag << H;
14460  } else {
14461  FDiag << Hint;
14462  }
14463  if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); }
14464 
14465  if (MayHaveFunctionDiff)
14466  HandleFunctionTypeMismatch(FDiag, SecondType, FirstType);
14467 
14468  Diag(Loc, FDiag);
14469  if (DiagKind == diag::warn_incompatible_qualified_id &&
14470  PDecl && IFace && !IFace->hasDefinition())
14471  Diag(IFace->getLocation(), diag::note_incomplete_class_and_qualified_id)
14472  << IFace << PDecl;
14473 
14474  if (SecondType == Context.OverloadTy)
14475  NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
14476  FirstType, /*TakingAddress=*/true);
14477 
14478  if (CheckInferredResultType)
14479  EmitRelatedResultTypeNote(SrcExpr);
14480 
14481  if (Action == AA_Returning && ConvTy == IncompatiblePointer)
14482  EmitRelatedResultTypeNoteForReturn(DstType);
14483 
14484  if (Complained)
14485  *Complained = true;
14486  return isInvalid;
14487 }
14488 
14490  llvm::APSInt *Result) {
14491  class SimpleICEDiagnoser : public VerifyICEDiagnoser {
14492  public:
14493  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override {
14494  S.Diag(Loc, diag::err_expr_not_ice) << S.LangOpts.CPlusPlus << SR;
14495  }
14496  } Diagnoser;
14497 
14498  return VerifyIntegerConstantExpression(E, Result, Diagnoser);
14499 }
14500 
14502  llvm::APSInt *Result,
14503  unsigned DiagID,
14504  bool AllowFold) {
14505  class IDDiagnoser : public VerifyICEDiagnoser {
14506  unsigned DiagID;
14507 
14508  public:
14509  IDDiagnoser(unsigned DiagID)
14510  : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { }
14511 
14512  void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override {
14513  S.Diag(Loc, DiagID) << SR;
14514  }
14515  } Diagnoser(DiagID);
14516 
14517  return VerifyIntegerConstantExpression(E, Result, Diagnoser, AllowFold);
14518 }
14519 
14521  SourceRange SR) {
14522  S.Diag(Loc, diag::ext_expr_not_ice) << SR << S.LangOpts.CPlusPlus;
14523 }
14524 
14525 ExprResult
14527  VerifyICEDiagnoser &Diagnoser,
14528  bool AllowFold) {
14529  SourceLocation DiagLoc = E->getBeginLoc();
14530 
14531  if (getLangOpts().CPlusPlus11) {
14532  // C++11 [expr.const]p5:
14533  // If an expression of literal class type is used in a context where an
14534  // integral constant expression is required, then that class type shall
14535  // have a single non-explicit conversion function to an integral or
14536  // unscoped enumeration type
14537  ExprResult Converted;
14538  class CXX11ConvertDiagnoser : public ICEConvertDiagnoser {
14539  public:
14540  CXX11ConvertDiagnoser(bool Silent)
14541  : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false,
14542  Silent, true) {}
14543 
14544  SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
14545  QualType T) override {
14546  return S.Diag(Loc, diag::err_ice_not_integral) << T;
14547  }
14548 
14549  SemaDiagnosticBuilder diagnoseIncomplete(
14550  Sema &S, SourceLocation Loc, QualType T) override {
14551  return S.Diag(Loc, diag::err_ice_incomplete_type) << T;
14552  }
14553 
14554  SemaDiagnosticBuilder diagnoseExplicitConv(
14555  Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
14556  return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy;
14557  }
14558 
14559  SemaDiagnosticBuilder noteExplicitConv(
14560  Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
14561  return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
14562  << ConvTy->isEnumeralType() << ConvTy;
14563  }
14564 
14565  SemaDiagnosticBuilder diagnoseAmbiguous(
14566  Sema &S, SourceLocation Loc, QualType T) override {
14567  return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T;
14568  }
14569 
14570  SemaDiagnosticBuilder noteAmbiguous(
14571  Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
14572  return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
14573  << ConvTy->isEnumeralType() << ConvTy;
14574  }
14575 
14576  SemaDiagnosticBuilder diagnoseConversion(
14577  Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
14578  llvm_unreachable("conversion functions are permitted");
14579  }
14580  } ConvertDiagnoser(Diagnoser.Suppress);
14581 
14582  Converted = PerformContextualImplicitConversion(DiagLoc, E,
14583  ConvertDiagnoser);
14584  if (Converted.isInvalid())
14585  return Converted;
14586  E = Converted.get();
14588  return ExprError();
14589  } else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {
14590  // An ICE must be of integral or unscoped enumeration type.
14591  if (!Diagnoser.Suppress)
14592  Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange());
14593  return ExprError();
14594  }
14595 
14596  // Circumvent ICE checking in C++11 to avoid evaluating the expression twice
14597  // in the non-ICE case.
14598  if (!getLangOpts().CPlusPlus11 && E->isIntegerConstantExpr(Context)) {
14599  if (Result)
14600  *Result = E->EvaluateKnownConstIntCheckOverflow(Context);
14601  if (!isa<ConstantExpr>(E))
14602  E = ConstantExpr::Create(Context, E);
14603  return E;
14604  }
14605 
14606  Expr::EvalResult EvalResult;
14608  EvalResult.Diag = &Notes;
14609 
14610  // Try to evaluate the expression, and produce diagnostics explaining why it's
14611  // not a constant expression as a side-effect.
14612  bool Folded =
14613  E->EvaluateAsRValue(EvalResult, Context, /*isConstantContext*/ true) &&
14614  EvalResult.Val.isInt() && !EvalResult.HasSideEffects;
14615 
14616  if (!isa<ConstantExpr>(E))
14617  E = ConstantExpr::Create(Context, E, EvalResult.Val);
14618 
14619  // In C++11, we can rely on diagnostics being produced for any expression
14620  // which is not a constant expression. If no diagnostics were produced, then
14621  // this is a constant expression.
14622  if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) {
14623  if (Result)
14624  *Result = EvalResult.Val.getInt();
14625  return E;
14626  }
14627 
14628  // If our only note is the usual "invalid subexpression" note, just point
14629  // the caret at its location rather than producing an essentially
14630  // redundant note.
14631  if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
14632  diag::note_invalid_subexpr_in_const_expr) {
14633  DiagLoc = Notes[0].first;
14634  Notes.clear();
14635  }
14636 
14637  if (!Folded || !AllowFold) {
14638  if (!Diagnoser.Suppress) {
14639  Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange());
14640  for (const PartialDiagnosticAt &Note : Notes)
14641  Diag(Note.first, Note.second);
14642  }
14643 
14644  return ExprError();
14645  }
14646 
14647  Diagnoser.diagnoseFold(*this, DiagLoc, E->getSourceRange());
14648  for (const PartialDiagnosticAt &Note : Notes)
14649  Diag(Note.first, Note.second);
14650 
14651  if (Result)
14652  *Result = EvalResult.Val.getInt();
14653  return E;
14654 }
14655 
14656 namespace {
14657  // Handle the case where we conclude a expression which we speculatively
14658  // considered to be unevaluated is actually evaluated.
14659  class TransformToPE : public TreeTransform<TransformToPE> {
14660  typedef TreeTransform<TransformToPE> BaseTransform;
14661 
14662  public:
14663  TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { }
14664 
14665  // Make sure we redo semantic analysis
14666  bool AlwaysRebuild() { return true; }
14667  bool ReplacingOriginal() { return true; }
14668 
14669  // We need to special-case DeclRefExprs referring to FieldDecls which
14670  // are not part of a member pointer formation; normal TreeTransforming
14671  // doesn't catch this case because of the way we represent them in the AST.
14672  // FIXME: This is a bit ugly; is it really the best way to handle this
14673  // case?
14674  //
14675  // Error on DeclRefExprs referring to FieldDecls.
14676  ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
14677  if (isa<FieldDecl>(E->getDecl()) &&
14678  !SemaRef.isUnevaluatedContext())
14679  return SemaRef.Diag(E->getLocation(),
14680  diag::err_invalid_non_static_member_use)
14681  << E->getDecl() << E->getSourceRange();
14682 
14683  return BaseTransform::TransformDeclRefExpr(E);
14684  }
14685 
14686  // Exception: filter out member pointer formation
14687  ExprResult TransformUnaryOperator(UnaryOperator *E) {
14688  if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType())
14689  return E;
14690 
14691  return BaseTransform::TransformUnaryOperator(E);
14692  }
14693 
14694  // The body of a lambda-expression is in a separate expression evaluation
14695  // context so never needs to be transformed.
14696  // FIXME: Ideally we wouldn't transform the closure type either, and would
14697  // just recreate the capture expressions and lambda expression.
14698  StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body) {
14699  return SkipLambdaBody(E, Body);
14700  }
14701  };
14702 }
14703 
14705  assert(isUnevaluatedContext() &&
14706  "Should only transform unevaluated expressions");
14707  ExprEvalContexts.back().Context =
14708  ExprEvalContexts[ExprEvalContexts.size()-2].Context;
14709  if (isUnevaluatedContext())
14710  return E;
14711  return TransformToPE(*this).TransformExpr(E);
14712 }
14713 
14714 void
14716  ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl,
14718  ExprEvalContexts.emplace_back(NewContext, ExprCleanupObjects.size(), Cleanup,
14719  LambdaContextDecl, ExprContext);
14720  Cleanup.reset();
14721  if (!MaybeODRUseExprs.empty())
14722  std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
14723 }
14724 
14725 void
14729  Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl;
14730  PushExpressionEvaluationContext(NewContext, ClosureContextDecl, ExprContext);
14731 }
14732 
14733 namespace {
14734 
14735 const DeclRefExpr *CheckPossibleDeref(Sema &S, const Expr *PossibleDeref) {
14736  PossibleDeref = PossibleDeref->IgnoreParenImpCasts();
14737  if (const auto *E = dyn_cast<UnaryOperator>(PossibleDeref)) {
14738  if (E->getOpcode() == UO_Deref)
14739  return CheckPossibleDeref(S, E->getSubExpr());
14740  } else if (const auto *E = dyn_cast<ArraySubscriptExpr>(PossibleDeref)) {
14741  return CheckPossibleDeref(S, E->getBase());
14742  } else if (const auto *E = dyn_cast<MemberExpr>(PossibleDeref)) {
14743  return CheckPossibleDeref(S, E->getBase());
14744  } else if (const auto E = dyn_cast<DeclRefExpr>(PossibleDeref)) {
14745  QualType Inner;
14746  QualType Ty = E->getType();
14747  if (const auto *Ptr = Ty->getAs<PointerType>())
14748  Inner = Ptr->getPointeeType();
14749  else if (const auto *Arr = S.Context.getAsArrayType(Ty))
14750  Inner = Arr->getElementType();
14751  else
14752  return nullptr;
14753 
14754  if (Inner->hasAttr(attr::NoDeref))
14755  return E;
14756  }
14757  return nullptr;
14758 }
14759 
14760 } // namespace
14761 
14763  for (const Expr *E : Rec.PossibleDerefs) {
14764  const DeclRefExpr *DeclRef = CheckPossibleDeref(*this, E);
14765  if (DeclRef) {
14766  const ValueDecl *Decl = DeclRef->getDecl();
14767  Diag(E->getExprLoc(), diag::warn_dereference_of_noderef_type)
14768  << Decl->getName() << E->getSourceRange();
14769  Diag(Decl->getLocation(), diag::note_previous_decl) << Decl->getName();
14770  } else {
14771  Diag(E->getExprLoc(), diag::warn_dereference_of_noderef_type_no_decl)
14772  << E->getSourceRange();
14773  }
14774  }
14775  Rec.PossibleDerefs.clear();
14776 }
14777 
14779  ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
14780  unsigned NumTypos = Rec.NumTypos;
14781 
14782  if (!Rec.Lambdas.empty()) {
14784  if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument || Rec.isUnevaluated() ||
14785  (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17)) {
14786  unsigned D;
14787  if (Rec.isUnevaluated()) {
14788  // C++11 [expr.prim.lambda]p2:
14789  // A lambda-expression shall not appear in an unevaluated operand
14790  // (Clause 5).
14791  D = diag::err_lambda_unevaluated_operand;
14792  } else if (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17) {
14793  // C++1y [expr.const]p2:
14794  // A conditional-expression e is a core constant expression unless the
14795  // evaluation of e, following the rules of the abstract machine, would
14796  // evaluate [...] a lambda-expression.
14797  D = diag::err_lambda_in_constant_expression;
14798  } else if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument) {
14799  // C++17 [expr.prim.lamda]p2:
14800  // A lambda-expression shall not appear [...] in a template-argument.
14801  D = diag::err_lambda_in_invalid_context;
14802  } else
14803  llvm_unreachable("Couldn't infer lambda error message.");
14804 
14805  for (const auto *L : Rec.Lambdas)
14806  Diag(L->getBeginLoc(), D);
14807  }
14808  }
14809 
14810  WarnOnPendingNoDerefs(Rec);
14811 
14812  // When are coming out of an unevaluated context, clear out any
14813  // temporaries that we may have created as part of the evaluation of
14814  // the expression in that context: they aren't relevant because they
14815  // will never be constructed.
14816  if (Rec.isUnevaluated() || Rec.isConstantEvaluated()) {
14817  ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects,
14818  ExprCleanupObjects.end());
14819  Cleanup = Rec.ParentCleanup;
14820  CleanupVarDeclMarking();
14821  std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
14822  // Otherwise, merge the contexts together.
14823  } else {
14824  Cleanup.mergeFrom(Rec.ParentCleanup);
14825  MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(),
14826  Rec.SavedMaybeODRUseExprs.end());
14827  }
14828 
14829  // Pop the current expression evaluation context off the stack.
14830  ExprEvalContexts.pop_back();
14831 
14832  // The global expression evaluation context record is never popped.
14833  ExprEvalContexts.back().NumTypos += NumTypos;
14834 }
14835 
14837  ExprCleanupObjects.erase(
14838  ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects,
14839  ExprCleanupObjects.end());
14840  Cleanup.reset();
14841  MaybeODRUseExprs.clear();
14842 }
14843 
14845  ExprResult Result = CheckPlaceholderExpr(E);
14846  if (Result.isInvalid())
14847  return ExprError();
14848  E = Result.get();
14849  if (!E->getType()->isVariablyModifiedType())
14850  return E;
14851  return TransformToPotentiallyEvaluated(E);
14852 }
14853 
14854 /// Are we in a context that is potentially constant evaluated per C++20
14855 /// [expr.const]p12?
14857  /// C++2a [expr.const]p12:
14858  // An expression or conversion is potentially constant evaluated if it is
14859  switch (SemaRef.ExprEvalContexts.back().Context) {
14861  // -- a manifestly constant-evaluated expression,
14865  // -- a potentially-evaluated expression,
14867  // -- an immediate subexpression of a braced-init-list,
14868 
14869  // -- [FIXME] an expression of the form & cast-expression that occurs
14870  // within a templated entity
14871  // -- a subexpression of one of the above that is not a subexpression of
14872  // a nested unevaluated operand.
14873  return true;
14874 
14877  // Expressions in this context are never evaluated.
14878  return false;
14879  }
14880  llvm_unreachable("Invalid context");
14881 }
14882 
14883 /// Return true if this function has a calling convention that requires mangling
14884 /// in the size of the parameter pack.
14886  // These manglings don't do anything on non-Windows or non-x86 platforms, so
14887  // we don't need parameter type sizes.
14888  const llvm::Triple &TT = S.Context.getTargetInfo().getTriple();
14889  if (!TT.isOSWindows() || (TT.getArch() != llvm::Triple::x86 &&
14890  TT.getArch() != llvm::Triple::x86_64))
14891  return false;
14892 
14893  // If this is C++ and this isn't an extern "C" function, parameters do not
14894  // need to be complete. In this case, C++ mangling will apply, which doesn't
14895  // use the size of the parameters.
14896  if (S.getLangOpts().CPlusPlus && !FD->isExternC())
14897  return false;
14898 
14899  // Stdcall, fastcall, and vectorcall need this special treatment.
14900  CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
14901  switch (CC) {
14902  case CC_X86StdCall:
14903  case CC_X86FastCall:
14904  case CC_X86VectorCall:
14905  return true;
14906  default:
14907  break;
14908  }
14909  return false;
14910 }
14911 
14912 /// Require that all of the parameter types of function be complete. Normally,
14913 /// parameter types are only required to be complete when a function is called
14914 /// or defined, but to mangle functions with certain calling conventions, the
14915 /// mangler needs to know the size of the parameter list. In this situation,
14916 /// MSVC doesn't emit an error or instantiate templates. Instead, MSVC mangles
14917 /// the function as _foo@0, i.e. zero bytes of parameters, which will usually
14918 /// result in a linker error. Clang doesn't implement this behavior, and instead
14919 /// attempts to error at compile time.
14921  SourceLocation Loc) {
14922  class ParamIncompleteTypeDiagnoser : public Sema::TypeDiagnoser {
14923  FunctionDecl *FD;
14924  ParmVarDecl *Param;
14925 
14926  public:
14927  ParamIncompleteTypeDiagnoser(FunctionDecl *FD, ParmVarDecl *Param)
14928  : FD(FD), Param(Param) {}
14929 
14930  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
14931  CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
14932  StringRef CCName;
14933  switch (CC) {
14934  case CC_X86StdCall:
14935  CCName = "stdcall";
14936  break;
14937  case CC_X86FastCall:
14938  CCName = "fastcall";
14939  break;
14940  case CC_X86VectorCall:
14941  CCName = "vectorcall";
14942  break;
14943  default:
14944  llvm_unreachable("CC does not need mangling");
14945  }
14946 
14947  S.Diag(Loc, diag::err_cconv_incomplete_param_type)
14948  << Param->getDeclName() << FD->getDeclName() << CCName;
14949  }
14950  };
14951 
14952  for (ParmVarDecl *Param : FD->parameters()) {
14953  ParamIncompleteTypeDiagnoser Diagnoser(FD, Param);
14954  S.RequireCompleteType(Loc, Param->getType(), Diagnoser);
14955  }
14956 }
14957 
14958 namespace {
14959 enum class OdrUseContext {
14960  /// Declarations in this context are not odr-used.
14961  None,
14962  /// Declarations in this context are formally odr-used, but this is a
14963  /// dependent context.
14964  Dependent,
14965  /// Declarations in this context are odr-used but not actually used (yet).
14966  FormallyOdrUsed,
14967  /// Declarations in this context are used.
14968  Used
14969 };
14970 }
14971 
14972 /// Are we within a context in which references to resolved functions or to
14973 /// variables result in odr-use?
14975  OdrUseContext Result;
14976 
14977  switch (SemaRef.ExprEvalContexts.back().Context) {
14981  return OdrUseContext::None;
14982 
14985  Result = OdrUseContext::Used;
14986  break;
14987 
14989  Result = OdrUseContext::FormallyOdrUsed;
14990  break;
14991 
14993  // A default argument formally results in odr-use, but doesn't actually
14994  // result in a use in any real sense until it itself is used.
14995  Result = OdrUseContext::FormallyOdrUsed;
14996  break;
14997  }
14998 
14999  if (SemaRef.CurContext->isDependentContext())
15000  return OdrUseContext::Dependent;
15001 
15002  return Result;
15003 }
15004 
15006  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Func);
15007  return Func->isConstexpr() &&
15008  (Func->isImplicitlyInstantiable() || (MD && !MD->isUserProvided()));
15009 }
15010 
15011 /// Mark a function referenced, and check whether it is odr-used
15012 /// (C++ [basic.def.odr]p2, C99 6.9p3)
15014  bool MightBeOdrUse) {
15015  assert(Func && "No function?");
15016 
15017  Func->setReferenced();
15018 
15019  // Recursive functions aren't really used until they're used from some other
15020  // context.
15021  bool IsRecursiveCall = CurContext == Func;
15022 
15023  // C++11 [basic.def.odr]p3:
15024  // A function whose name appears as a potentially-evaluated expression is
15025  // odr-used if it is the unique lookup result or the selected member of a
15026  // set of overloaded functions [...].
15027  //
15028  // We (incorrectly) mark overload resolution as an unevaluated context, so we
15029  // can just check that here.
15030  OdrUseContext OdrUse =
15031  MightBeOdrUse ? isOdrUseContext(*this) : OdrUseContext::None;
15032  if (IsRecursiveCall && OdrUse == OdrUseContext::Used)
15033  OdrUse = OdrUseContext::FormallyOdrUsed;
15034 
15035  // C++20 [expr.const]p12:
15036  // A function [...] is needed for constant evaluation if it is [...] a
15037  // constexpr function that is named by an expression that is potentially
15038  // constant evaluated
15039  bool NeededForConstantEvaluation =
15042 
15043  // Determine whether we require a function definition to exist, per
15044  // C++11 [temp.inst]p3:
15045  // Unless a function template specialization has been explicitly
15046  // instantiated or explicitly specialized, the function template
15047  // specialization is implicitly instantiated when the specialization is
15048  // referenced in a context that requires a function definition to exist.
15049  // C++20 [temp.inst]p7:
15050  // The existence of a definition of a [...] function is considered to
15051  // affect the semantics of the program if the [...] function is needed for
15052  // constant evaluation by an expression
15053  // C++20 [basic.def.odr]p10:
15054  // Every program shall contain exactly one definition of every non-inline
15055  // function or variable that is odr-used in that program outside of a
15056  // discarded statement
15057  // C++20 [special]p1:
15058  // The implementation will implicitly define [defaulted special members]
15059  // if they are odr-used or needed for constant evaluation.
15060  //
15061  // Note that we skip the implicit instantiation of templates that are only
15062  // used in unused default arguments or by recursive calls to themselves.
15063  // This is formally non-conforming, but seems reasonable in practice.
15064  bool NeedDefinition = !IsRecursiveCall && (OdrUse == OdrUseContext::Used ||
15065  NeededForConstantEvaluation);
15066 
15067  // C++14 [temp.expl.spec]p6:
15068  // If a template [...] is explicitly specialized then that specialization
15069  // shall be declared before the first use of that specialization that would
15070  // cause an implicit instantiation to take place, in every translation unit
15071  // in which such a use occurs
15072  if (NeedDefinition &&
15074  Func->getMemberSpecializationInfo()))
15075  checkSpecializationVisibility(Loc, Func);
15076 
15077  // C++14 [except.spec]p17:
15078  // An exception-specification is considered to be needed when:
15079  // - the function is odr-used or, if it appears in an unevaluated operand,
15080  // would be odr-used if the expression were potentially-evaluated;
15081  //
15082  // Note, we do this even if MightBeOdrUse is false. That indicates that the
15083  // function is a pure virtual function we're calling, and in that case the
15084  // function was selected by overload resolution and we need to resolve its
15085  // exception specification for a different reason.
15086  const FunctionProtoType *FPT = Func->getType()->getAs<FunctionProtoType>();
15088  ResolveExceptionSpec(Loc, FPT);
15089 
15090  if (getLangOpts().CUDA)
15091  CheckCUDACall(Loc, Func);
15092 
15093  // If we need a definition, try to create one.
15094  if (NeedDefinition && !Func->getBody()) {
15095  if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) {
15096  Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
15097  if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
15098  if (Constructor->isDefaultConstructor()) {
15099  if (Constructor->isTrivial() &&
15100  !Constructor->hasAttr<DLLExportAttr>())
15101  return;
15102  DefineImplicitDefaultConstructor(Loc, Constructor);
15103  } else if (Constructor->isCopyConstructor()) {
15104  DefineImplicitCopyConstructor(Loc, Constructor);
15105  } else if (Constructor->isMoveConstructor()) {
15106  DefineImplicitMoveConstructor(Loc, Constructor);
15107  }
15108  } else if (Constructor->getInheritedConstructor()) {
15109  DefineInheritingConstructor(Loc, Constructor);
15110  }
15111  } else if (CXXDestructorDecl *Destructor =
15112  dyn_cast<CXXDestructorDecl>(Func)) {
15113  Destructor = cast<CXXDestructorDecl>(Destructor->getFirstDecl());
15114  if (Destructor->isDefaulted() && !Destructor->isDeleted()) {
15115  if (Destructor->isTrivial() && !Destructor->hasAttr<DLLExportAttr>())
15116  return;
15117  DefineImplicitDestructor(Loc, Destructor);
15118  }
15119  if (Destructor->isVirtual() && getLangOpts().AppleKext)
15120  MarkVTableUsed(Loc, Destructor->getParent());
15121  } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(Func)) {
15122  if (MethodDecl->isOverloadedOperator() &&
15123  MethodDecl->getOverloadedOperator() == OO_Equal) {
15124  MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
15125  if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
15126  if (MethodDecl->isCopyAssignmentOperator())
15127  DefineImplicitCopyAssignment(Loc, MethodDecl);
15128  else if (MethodDecl->isMoveAssignmentOperator())
15129  DefineImplicitMoveAssignment(Loc, MethodDecl);
15130  }
15131  } else if (isa<CXXConversionDecl>(MethodDecl) &&
15132  MethodDecl->getParent()->isLambda()) {
15133  CXXConversionDecl *Conversion =
15134  cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
15135  if (Conversion->isLambdaToBlockPointerConversion())
15136  DefineImplicitLambdaToBlockPointerConversion(Loc, Conversion);
15137  else
15138  DefineImplicitLambdaToFunctionPointerConversion(Loc, Conversion);
15139  } else if (MethodDecl->isVirtual() && getLangOpts().AppleKext)
15140  MarkVTableUsed(Loc, MethodDecl->getParent());
15141  }
15142 
15143  // Implicit instantiation of function templates and member functions of
15144  // class templates.
15145  if (Func->isImplicitlyInstantiable()) {
15148  SourceLocation PointOfInstantiation = Func->getPointOfInstantiation();
15149  bool FirstInstantiation = PointOfInstantiation.isInvalid();
15150  if (FirstInstantiation) {
15151  PointOfInstantiation = Loc;
15152  Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
15153  } else if (TSK != TSK_ImplicitInstantiation) {
15154  // Use the point of use as the point of instantiation, instead of the
15155  // point of explicit instantiation (which we track as the actual point
15156  // of instantiation). This gives better backtraces in diagnostics.
15157  PointOfInstantiation = Loc;
15158  }
15159 
15160  if (FirstInstantiation || TSK != TSK_ImplicitInstantiation ||
15161  Func->isConstexpr()) {
15162  if (isa<CXXRecordDecl>(Func->getDeclContext()) &&
15163  cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass() &&
15164  CodeSynthesisContexts.size())
15165  PendingLocalImplicitInstantiations.push_back(
15166  std::make_pair(Func, PointOfInstantiation));
15167  else if (Func->isConstexpr())
15168  // Do not defer instantiations of constexpr functions, to avoid the
15169  // expression evaluator needing to call back into Sema if it sees a
15170  // call to such a function.
15171  InstantiateFunctionDefinition(PointOfInstantiation, Func);
15172  else {
15173  Func->setInstantiationIsPending(true);
15174  PendingInstantiations.push_back(
15175  std::make_pair(Func, PointOfInstantiation));
15176  // Notify the consumer that a function was implicitly instantiated.
15177  Consumer.HandleCXXImplicitFunctionInstantiation(Func);
15178  }
15179  }
15180  } else {
15181  // Walk redefinitions, as some of them may be instantiable.
15182  for (auto i : Func->redecls()) {
15183  if (!i->isUsed(false) && i->isImplicitlyInstantiable())
15184  MarkFunctionReferenced(Loc, i, MightBeOdrUse);
15185  }
15186  }
15187  }
15188 
15189  // If this is the first "real" use, act on that.
15190  if (OdrUse == OdrUseContext::Used && !Func->isUsed(/*CheckUsedAttr=*/false)) {
15191  // Keep track of used but undefined functions.
15192  if (!Func->isDefined()) {
15193  if (mightHaveNonExternalLinkage(Func))
15194  UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
15195  else if (Func->getMostRecentDecl()->isInlined() &&
15196  !LangOpts.GNUInline &&
15197  !Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
15198  UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
15199  else if (isExternalWithNoLinkageType(Func))
15200  UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
15201  }
15202 
15203  // Some x86 Windows calling conventions mangle the size of the parameter
15204  // pack into the name. Computing the size of the parameters requires the
15205  // parameter types to be complete. Check that now.
15206  if (funcHasParameterSizeMangling(*this, Func))
15207  CheckCompleteParameterTypesForMangler(*this, Func, Loc);
15208 
15209  Func->markUsed(Context);
15210 
15211  if (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)
15212  checkOpenMPDeviceFunction(Loc, Func);
15213  }
15214 }
15215 
15216 /// Directly mark a variable odr-used. Given a choice, prefer to use
15217 /// MarkVariableReferenced since it does additional checks and then
15218 /// calls MarkVarDeclODRUsed.
15219 /// If the variable must be captured:
15220 /// - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
15221 /// - else capture it in the DeclContext that maps to the
15222 /// *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.
15223 static void
15225  const unsigned *const FunctionScopeIndexToStopAt = nullptr) {
15226  // Keep track of used but undefined variables.
15227  // FIXME: We shouldn't suppress this warning for static data members.
15228  if (Var->hasDefinition(SemaRef.Context) == VarDecl::DeclarationOnly &&
15229  (!Var->isExternallyVisible() || Var->isInline() ||
15230  SemaRef.isExternalWithNoLinkageType(Var)) &&
15231  !(Var->isStaticDataMember() && Var->hasInit())) {
15232  SourceLocation &old = SemaRef.UndefinedButUsed[Var->getCanonicalDecl()];
15233  if (old.isInvalid())
15234  old = Loc;
15235  }
15236  QualType CaptureType, DeclRefType;
15237  if (SemaRef.LangOpts.OpenMP)
15238  SemaRef.tryCaptureOpenMPLambdas(Var);
15240  /*EllipsisLoc*/ SourceLocation(),
15241  /*BuildAndDiagnose*/ true,
15242  CaptureType, DeclRefType,
15243  FunctionScopeIndexToStopAt);
15244 
15245  Var->markUsed(SemaRef.Context);
15246 }
15247 
15249  SourceLocation Loc,
15250  unsigned CapturingScopeIndex) {
15251  MarkVarDeclODRUsed(Capture, Loc, *this, &CapturingScopeIndex);
15252 }
15253 
15254 static void
15256  ValueDecl *var, DeclContext *DC) {
15257  DeclContext *VarDC = var->getDeclContext();
15258 
15259  // If the parameter still belongs to the translation unit, then
15260  // we're actually just using one parameter in the declaration of
15261  // the next.
15262  if (isa<ParmVarDecl>(var) &&
15263  isa<TranslationUnitDecl>(VarDC))
15264  return;
15265 
15266  // For C code, don't diagnose about capture if we're not actually in code
15267  // right now; it's impossible to write a non-constant expression outside of
15268  // function context, so we'll get other (more useful) diagnostics later.
15269  //
15270  // For C++, things get a bit more nasty... it would be nice to suppress this
15271  // diagnostic for certain cases like using a local variable in an array bound
15272  // for a member of a local class, but the correct predicate is not obvious.
15273  if (!S.getLangOpts().CPlusPlus && !S.CurContext->isFunctionOrMethod())
15274  return;
15275 
15276  unsigned ValueKind = isa<BindingDecl>(var) ? 1 : 0;
15277  unsigned ContextKind = 3; // unknown
15278  if (isa<CXXMethodDecl>(VarDC) &&
15279  cast<CXXRecordDecl>(VarDC->getParent())->isLambda()) {
15280  ContextKind = 2;
15281  } else if (isa<FunctionDecl>(VarDC)) {
15282  ContextKind = 0;
15283  } else if (isa<BlockDecl>(VarDC)) {
15284  ContextKind = 1;
15285  }
15286 
15287  S.Diag(loc, diag::err_reference_to_local_in_enclosing_context)
15288  << var << ValueKind << ContextKind << VarDC;
15289  S.Diag(var->getLocation(), diag::note_entity_declared_at)
15290  << var;
15291 
15292  // FIXME: Add additional diagnostic info about class etc. which prevents
15293  // capture.
15294 }
15295 
15296 
15298  bool &SubCapturesAreNested,
15299  QualType &CaptureType,
15300  QualType &DeclRefType) {
15301  // Check whether we've already captured it.
15302  if (CSI->CaptureMap.count(Var)) {
15303  // If we found a capture, any subcaptures are nested.
15304  SubCapturesAreNested = true;
15305 
15306  // Retrieve the capture type for this variable.
15307  CaptureType = CSI->getCapture(Var).getCaptureType();
15308 
15309  // Compute the type of an expression that refers to this variable.
15310  DeclRefType = CaptureType.getNonReferenceType();
15311 
15312  // Similarly to mutable captures in lambda, all the OpenMP captures by copy
15313  // are mutable in the sense that user can change their value - they are
15314  // private instances of the captured declarations.
15315  const Capture &Cap = CSI->getCapture(Var);
15316  if (Cap.isCopyCapture() &&
15317  !(isa<LambdaScopeInfo>(CSI) && cast<LambdaScopeInfo>(CSI)->Mutable) &&
15318  !(isa<CapturedRegionScopeInfo>(CSI) &&
15319  cast<CapturedRegionScopeInfo>(CSI)->CapRegionKind == CR_OpenMP))
15320  DeclRefType.addConst();
15321  return true;
15322  }
15323  return false;
15324 }
15325 
15326 // Only block literals, captured statements, and lambda expressions can
15327 // capture; other scopes don't work.
15329  SourceLocation Loc,
15330  const bool Diagnose, Sema &S) {
15331  if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC) || isLambdaCallOperator(DC))
15333  else if (Var->hasLocalStorage()) {
15334  if (Diagnose)
15335  diagnoseUncapturableValueReference(S, Loc, Var, DC);
15336  }
15337  return nullptr;
15338 }
15339 
15340 // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
15341 // certain types of variables (unnamed, variably modified types etc.)
15342 // so check for eligibility.
15344  SourceLocation Loc,
15345  const bool Diagnose, Sema &S) {
15346 
15347  bool IsBlock = isa<BlockScopeInfo>(CSI);
15348  bool IsLambda = isa<LambdaScopeInfo>(CSI);
15349 
15350  // Lambdas are not allowed to capture unnamed variables
15351  // (e.g. anonymous unions).
15352  // FIXME: The C++11 rule don't actually state this explicitly, but I'm
15353  // assuming that's the intent.
15354  if (IsLambda && !Var->getDeclName()) {
15355  if (Diagnose) {
15356  S.Diag(Loc, diag::err_lambda_capture_anonymous_var);
15357  S.Diag(Var->getLocation(), diag::note_declared_at);
15358  }
15359  return false;
15360  }
15361 
15362  // Prohibit variably-modified types in blocks; they're difficult to deal with.
15363  if (Var->getType()->isVariablyModifiedType() && IsBlock) {
15364  if (Diagnose) {
15365  S.Diag(Loc, diag::err_ref_vm_type);
15366  S.Diag(Var->getLocation(), diag::note_previous_decl)
15367  << Var->getDeclName();
15368  }
15369  return false;
15370  }
15371  // Prohibit structs with flexible array members too.
15372  // We cannot capture what is in the tail end of the struct.
15373  if (const RecordType *VTTy = Var->getType()->getAs<RecordType>()) {
15374  if (VTTy->getDecl()->hasFlexibleArrayMember()) {
15375  if (Diagnose) {
15376  if (IsBlock)
15377  S.Diag(Loc, diag::err_ref_flexarray_type);
15378  else
15379  S.Diag(Loc, diag::err_lambda_capture_flexarray_type)
15380  << Var->getDeclName();
15381  S.Diag(Var->getLocation(), diag::note_previous_decl)
15382  << Var->getDeclName();
15383  }
15384  return false;
15385  }
15386  }
15387  const bool HasBlocksAttr = Var->hasAttr<BlocksAttr>();
15388  // Lambdas and captured statements are not allowed to capture __block
15389  // variables; they don't support the expected semantics.
15390  if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
15391  if (Diagnose) {
15392  S.Diag(Loc, diag::err_capture_block_variable)
15393  << Var->getDeclName() << !IsLambda;
15394  S.Diag(Var->getLocation(), diag::note_previous_decl)
15395  << Var->getDeclName();
15396  }
15397  return false;
15398  }
15399  // OpenCL v2.0 s6.12.5: Blocks cannot reference/capture other blocks
15400  if (S.getLangOpts().OpenCL && IsBlock &&
15401  Var->getType()->isBlockPointerType()) {
15402  if (Diagnose)
15403  S.Diag(Loc, diag::err_opencl_block_ref_block);
15404  return false;
15405  }
15406 
15407  return true;
15408 }
15409 
15410 // Returns true if the capture by block was successful.
15411 static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *Var,
15412  SourceLocation Loc,
15413  const bool BuildAndDiagnose,
15414  QualType &CaptureType,
15415  QualType &DeclRefType,
15416  const bool Nested,
15417  Sema &S, bool Invalid) {
15418  bool ByRef = false;
15419 
15420  // Blocks are not allowed to capture arrays, excepting OpenCL.
15421  // OpenCL v2.0 s1.12.5 (revision 40): arrays are captured by reference
15422  // (decayed to pointers).
15423  if (!Invalid && !S.getLangOpts().OpenCL && CaptureType->isArrayType()) {
15424  if (BuildAndDiagnose) {
15425  S.Diag(Loc, diag::err_ref_array_type);
15426  S.Diag(Var->getLocation(), diag::note_previous_decl)
15427  << Var->getDeclName();
15428  Invalid = true;
15429  } else {
15430  return false;
15431  }
15432  }
15433 
15434  // Forbid the block-capture of autoreleasing variables.
15435  if (!Invalid &&
15437  if (BuildAndDiagnose) {
15438  S.Diag(Loc, diag::err_arc_autoreleasing_capture)
15439  << /*block*/ 0;
15440  S.Diag(Var->getLocation(), diag::note_previous_decl)
15441  << Var->getDeclName();
15442  Invalid = true;
15443  } else {
15444  return false;
15445  }
15446  }
15447 
15448  // Warn about implicitly autoreleasing indirect parameters captured by blocks.
15449  if (const auto *PT = CaptureType->getAs<PointerType>()) {
15450  // This function finds out whether there is an AttributedType of kind
15451  // attr::ObjCOwnership in Ty. The existence of AttributedType of kind
15452  // attr::ObjCOwnership implies __autoreleasing was explicitly specified
15453  // rather than being added implicitly by the compiler.
15454  auto IsObjCOwnershipAttributedType = [](QualType Ty) {
15455  while (const auto *AttrTy = Ty->getAs<AttributedType>()) {
15456  if (AttrTy->getAttrKind() == attr::ObjCOwnership)
15457  return true;
15458 
15459  // Peel off AttributedTypes that are not of kind ObjCOwnership.
15460  Ty = AttrTy->getModifiedType();
15461  }
15462 
15463  return false;
15464  };
15465 
15466  QualType PointeeTy = PT->getPointeeType();
15467 
15468  if (!Invalid && PointeeTy->getAs<ObjCObjectPointerType>() &&
15470  !IsObjCOwnershipAttributedType(PointeeTy)) {
15471  if (BuildAndDiagnose) {
15472  SourceLocation VarLoc = Var->getLocation();
15473  S.Diag(Loc, diag::warn_block_capture_autoreleasing);
15474  S.Diag(VarLoc, diag::note_declare_parameter_strong);
15475  }
15476  }
15477  }
15478 
15479  const bool HasBlocksAttr = Var->hasAttr<BlocksAttr>();
15480  if (HasBlocksAttr || CaptureType->isReferenceType() ||
15481  (S.getLangOpts().OpenMP && S.isOpenMPCapturedDecl(Var))) {
15482  // Block capture by reference does not change the capture or
15483  // declaration reference types.
15484  ByRef = true;
15485  } else {
15486  // Block capture by copy introduces 'const'.
15487  CaptureType = CaptureType.getNonReferenceType().withConst();
15488  DeclRefType = CaptureType;
15489  }
15490 
15491  // Actually capture the variable.
15492  if (BuildAndDiagnose)
15493  BSI->addCapture(Var, HasBlocksAttr, ByRef, Nested, Loc, SourceLocation(),
15494  CaptureType, Invalid);
15495 
15496  return !Invalid;
15497 }
15498 
15499 
15500 /// Capture the given variable in the captured region.
15502  VarDecl *Var,
15503  SourceLocation Loc,
15504  const bool BuildAndDiagnose,
15505  QualType &CaptureType,
15506  QualType &DeclRefType,
15507  const bool RefersToCapturedVariable,
15508  Sema &S, bool Invalid) {
15509  // By default, capture variables by reference.
15510  bool ByRef = true;
15511  // Using an LValue reference type is consistent with Lambdas (see below).
15512  if (S.getLangOpts().OpenMP && RSI->CapRegionKind == CR_OpenMP) {
15513  if (S.isOpenMPCapturedDecl(Var)) {
15514  bool HasConst = DeclRefType.isConstQualified();
15515  DeclRefType = DeclRefType.getUnqualifiedType();
15516  // Don't lose diagnostics about assignments to const.
15517  if (HasConst)
15518  DeclRefType.addConst();
15519  }
15520  ByRef = S.isOpenMPCapturedByRef(Var, RSI->OpenMPLevel);
15521  }
15522 
15523  if (ByRef)
15524  CaptureType = S.Context.getLValueReferenceType(DeclRefType);
15525  else
15526  CaptureType = DeclRefType;
15527 
15528  // Actually capture the variable.
15529  if (BuildAndDiagnose)
15530  RSI->addCapture(Var, /*isBlock*/ false, ByRef, RefersToCapturedVariable,
15531  Loc, SourceLocation(), CaptureType, Invalid);
15532 
15533  return !Invalid;
15534 }
15535 
15536 /// Capture the given variable in the lambda.
15538  VarDecl *Var,
15539  SourceLocation Loc,
15540  const bool BuildAndDiagnose,
15541  QualType &CaptureType,
15542  QualType &DeclRefType,
15543  const bool RefersToCapturedVariable,
15544  const Sema::TryCaptureKind Kind,
15545  SourceLocation EllipsisLoc,
15546  const bool IsTopScope,
15547  Sema &S, bool Invalid) {
15548  // Determine whether we are capturing by reference or by value.
15549  bool ByRef = false;
15550  if (IsTopScope && Kind != Sema::TryCapture_Implicit) {
15551  ByRef = (Kind == Sema::TryCapture_ExplicitByRef);
15552  } else {
15554  }
15555 
15556  // Compute the type of the field that will capture this variable.
15557  if (ByRef) {
15558  // C++11 [expr.prim.lambda]p15:
15559  // An entity is captured by reference if it is implicitly or
15560  // explicitly captured but not captured by copy. It is
15561  // unspecified whether additional unnamed non-static data
15562  // members are declared in the closure type for entities
15563  // captured by reference.
15564  //
15565  // FIXME: It is not clear whether we want to build an lvalue reference
15566  // to the DeclRefType or to CaptureType.getNonReferenceType(). GCC appears
15567  // to do the former, while EDG does the latter. Core issue 1249 will
15568  // clarify, but for now we follow GCC because it's a more permissive and
15569  // easily defensible position.
15570  CaptureType = S.Context.getLValueReferenceType(DeclRefType);
15571  } else {
15572  // C++11 [expr.prim.lambda]p14:
15573  // For each entity captured by copy, an unnamed non-static
15574  // data member is declared in the closure type. The
15575  // declaration order of these members is unspecified. The type
15576  // of such a data member is the type of the corresponding
15577  // captured entity if the entity is not a reference to an
15578  // object, or the referenced type otherwise. [Note: If the
15579  // captured entity is a reference to a function, the
15580  // corresponding data member is also a reference to a
15581  // function. - end note ]
15582  if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()){
15583  if (!RefType->getPointeeType()->isFunctionType())
15584  CaptureType = RefType->getPointeeType();
15585  }
15586 
15587  // Forbid the lambda copy-capture of autoreleasing variables.
15588  if (!Invalid &&
15590  if (BuildAndDiagnose) {
15591  S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;
15592  S.Diag(Var->getLocation(), diag::note_previous_decl)
15593  << Var->getDeclName();
15594  Invalid = true;
15595  } else {
15596  return false;
15597  }
15598  }
15599 
15600  // Make sure that by-copy captures are of a complete and non-abstract type.
15601  if (!Invalid && BuildAndDiagnose) {
15602  if (!CaptureType->isDependentType() &&
15603  S.RequireCompleteType(Loc, CaptureType,
15604  diag::err_capture_of_incomplete_type,
15605  Var->getDeclName()))
15606  Invalid = true;
15607  else if (S.RequireNonAbstractType(Loc, CaptureType,
15608  diag::err_capture_of_abstract_type))
15609  Invalid = true;
15610  }
15611  }
15612 
15613  // Compute the type of a reference to this captured variable.
15614  if (ByRef)
15615  DeclRefType = CaptureType.getNonReferenceType();
15616  else {
15617  // C++ [expr.prim.lambda]p5:
15618  // The closure type for a lambda-expression has a public inline
15619  // function call operator [...]. This function call operator is
15620  // declared const (9.3.1) if and only if the lambda-expression's
15621  // parameter-declaration-clause is not followed by mutable.
15622  DeclRefType = CaptureType.getNonReferenceType();
15623  if (!LSI->Mutable && !CaptureType->isReferenceType())
15624  DeclRefType.addConst();
15625  }
15626 
15627  // Add the capture.
15628  if (BuildAndDiagnose)
15629  LSI->addCapture(Var, /*isBlock=*/false, ByRef, RefersToCapturedVariable,
15630  Loc, EllipsisLoc, CaptureType, Invalid);
15631 
15632  return !Invalid;
15633 }
15634 
15636  VarDecl *Var, SourceLocation ExprLoc, TryCaptureKind Kind,
15637  SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType,
15638  QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt) {
15639  // An init-capture is notionally from the context surrounding its
15640  // declaration, but its parent DC is the lambda class.
15641  DeclContext *VarDC = Var->getDeclContext();
15642  if (Var->isInitCapture())
15643  VarDC = VarDC->getParent();
15644 
15645  DeclContext *DC = CurContext;
15646  const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
15647  ? *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
15648  // We need to sync up the Declaration Context with the
15649  // FunctionScopeIndexToStopAt
15650  if (FunctionScopeIndexToStopAt) {
15651  unsigned FSIndex = FunctionScopes.size() - 1;
15652  while (FSIndex != MaxFunctionScopesIndex) {
15654  --FSIndex;
15655  }
15656  }
15657 
15658 
15659  // If the variable is declared in the current context, there is no need to
15660  // capture it.
15661  if (VarDC == DC) return true;
15662 
15663  // Capture global variables if it is required to use private copy of this
15664  // variable.
15665  bool IsGlobal = !Var->hasLocalStorage();
15666  if (IsGlobal &&
15667  !(LangOpts.OpenMP && isOpenMPCapturedDecl(Var, /*CheckScopeInfo=*/true,
15668  MaxFunctionScopesIndex)))
15669  return true;
15670  Var = Var->getCanonicalDecl();
15671 
15672  // Walk up the stack to determine whether we can capture the variable,
15673  // performing the "simple" checks that don't depend on type. We stop when
15674  // we've either hit the declared scope of the variable or find an existing
15675  // capture of that variable. We start from the innermost capturing-entity
15676  // (the DC) and ensure that all intervening capturing-entities
15677  // (blocks/lambdas etc.) between the innermost capturer and the variable`s
15678  // declcontext can either capture the variable or have already captured
15679  // the variable.
15680  CaptureType = Var->getType();
15681  DeclRefType = CaptureType.getNonReferenceType();
15682  bool Nested = false;
15683  bool Explicit = (Kind != TryCapture_Implicit);
15684  unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
15685  do {
15686  // Only block literals, captured statements, and lambda expressions can
15687  // capture; other scopes don't work.
15688  DeclContext *ParentDC = getParentOfCapturingContextOrNull(DC, Var,
15689  ExprLoc,
15690  BuildAndDiagnose,
15691  *this);
15692  // We need to check for the parent *first* because, if we *have*
15693  // private-captured a global variable, we need to recursively capture it in
15694  // intermediate blocks, lambdas, etc.
15695  if (!ParentDC) {
15696  if (IsGlobal) {
15697  FunctionScopesIndex = MaxFunctionScopesIndex - 1;
15698  break;
15699  }
15700  return true;
15701  }
15702 
15703  FunctionScopeInfo *FSI = FunctionScopes[FunctionScopesIndex];
15704  CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FSI);
15705 
15706 
15707  // Check whether we've already captured it.
15708  if (isVariableAlreadyCapturedInScopeInfo(CSI, Var, Nested, CaptureType,
15709  DeclRefType)) {
15710  CSI->getCapture(Var).markUsed(BuildAndDiagnose);
15711  break;
15712  }
15713  // If we are instantiating a generic lambda call operator body,
15714  // we do not want to capture new variables. What was captured
15715  // during either a lambdas transformation or initial parsing
15716  // should be used.
15718  if (BuildAndDiagnose) {
15719  LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
15721  Diag(ExprLoc, diag::err_lambda_impcap) << Var->getDeclName();
15722  Diag(Var->getLocation(), diag::note_previous_decl)
15723  << Var->getDeclName();
15724  Diag(LSI->Lambda->getBeginLoc(), diag::note_lambda_decl);
15725  } else
15726  diagnoseUncapturableValueReference(*this, ExprLoc, Var, DC);
15727  }
15728  return true;
15729  }
15730 
15731  // Try to capture variable-length arrays types.
15732  if (Var->getType()->isVariablyModifiedType()) {
15733  // We're going to walk down into the type and look for VLA
15734  // expressions.
15735  QualType QTy = Var->getType();
15736  if (ParmVarDecl *PVD = dyn_cast_or_null<ParmVarDecl>(Var))
15737  QTy = PVD->getOriginalType();
15738  captureVariablyModifiedType(Context, QTy, CSI);
15739  }
15740 
15741  if (getLangOpts().OpenMP) {
15742  if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
15743  // OpenMP private variables should not be captured in outer scope, so
15744  // just break here. Similarly, global variables that are captured in a
15745  // target region should not be captured outside the scope of the region.
15746  if (RSI->CapRegionKind == CR_OpenMP) {
15747  bool IsOpenMPPrivateDecl = isOpenMPPrivateDecl(Var, RSI->OpenMPLevel);
15748  auto IsTargetCap = !IsOpenMPPrivateDecl &&
15749  isOpenMPTargetCapturedDecl(Var, RSI->OpenMPLevel);
15750  // When we detect target captures we are looking from inside the
15751  // target region, therefore we need to propagate the capture from the
15752  // enclosing region. Therefore, the capture is not initially nested.
15753  if (IsTargetCap)
15754  adjustOpenMPTargetScopeIndex(FunctionScopesIndex, RSI->OpenMPLevel);
15755 
15756  if (IsTargetCap || IsOpenMPPrivateDecl) {
15757  Nested = !IsTargetCap;
15758  DeclRefType = DeclRefType.getUnqualifiedType();
15759  CaptureType = Context.getLValueReferenceType(DeclRefType);
15760  break;
15761  }
15762  }
15763  }
15764  }
15765  if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None && !Explicit) {
15766  // No capture-default, and this is not an explicit capture
15767  // so cannot capture this variable.
15768  if (BuildAndDiagnose) {
15769  Diag(ExprLoc, diag::err_lambda_impcap) << Var->getDeclName();
15770  Diag(Var->getLocation(), diag::note_previous_decl)
15771  << Var->getDeclName();
15772  if (cast<LambdaScopeInfo>(CSI)->Lambda)
15773  Diag(cast<LambdaScopeInfo>(CSI)->Lambda->getBeginLoc(),
15774  diag::note_lambda_decl);
15775  // FIXME: If we error out because an outer lambda can not implicitly
15776  // capture a variable that an inner lambda explicitly captures, we
15777  // should have the inner lambda do the explicit capture - because
15778  // it makes for cleaner diagnostics later. This would purely be done
15779  // so that the diagnostic does not misleadingly claim that a variable
15780  // can not be captured by a lambda implicitly even though it is captured
15781  // explicitly. Suggestion:
15782  // - create const bool VariableCaptureWasInitiallyExplicit = Explicit
15783  // at the function head
15784  // - cache the StartingDeclContext - this must be a lambda
15785  // - captureInLambda in the innermost lambda the variable.
15786  }
15787  return true;
15788  }
15789 
15790  FunctionScopesIndex--;
15791  DC = ParentDC;
15792  Explicit = false;
15793  } while (!VarDC->Equals(DC));
15794 
15795  // Walk back down the scope stack, (e.g. from outer lambda to inner lambda)
15796  // computing the type of the capture at each step, checking type-specific
15797  // requirements, and adding captures if requested.
15798  // If the variable had already been captured previously, we start capturing
15799  // at the lambda nested within that one.
15800  bool Invalid = false;
15801  for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
15802  ++I) {
15803  CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[I]);
15804 
15805  // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
15806  // certain types of variables (unnamed, variably modified types etc.)
15807  // so check for eligibility.
15808  if (!Invalid)
15809  Invalid =
15810  !isVariableCapturable(CSI, Var, ExprLoc, BuildAndDiagnose, *this);
15811 
15812  // After encountering an error, if we're actually supposed to capture, keep
15813  // capturing in nested contexts to suppress any follow-on diagnostics.
15814  if (Invalid && !BuildAndDiagnose)
15815  return true;
15816 
15817  if (BlockScopeInfo *BSI = dyn_cast<BlockScopeInfo>(CSI)) {
15818  Invalid = !captureInBlock(BSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
15819  DeclRefType, Nested, *this, Invalid);
15820  Nested = true;
15821  } else if (CapturedRegionScopeInfo *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
15822  Invalid = !captureInCapturedRegion(RSI, Var, ExprLoc, BuildAndDiagnose,
15823  CaptureType, DeclRefType, Nested,
15824  *this, Invalid);
15825  Nested = true;
15826  } else {
15827  LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
15828  Invalid =
15829  !captureInLambda(LSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
15830  DeclRefType, Nested, Kind, EllipsisLoc,
15831  /*IsTopScope*/ I == N - 1, *this, Invalid);
15832  Nested = true;
15833  }
15834 
15835  if (Invalid && !BuildAndDiagnose)
15836  return true;
15837  }
15838  return Invalid;
15839 }
15840 
15842  TryCaptureKind Kind, SourceLocation EllipsisLoc) {
15843  QualType CaptureType;
15844  QualType DeclRefType;
15845  return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc,
15846  /*BuildAndDiagnose=*/true, CaptureType,
15847  DeclRefType, nullptr);
15848 }
15849 
15851  QualType CaptureType;
15852  QualType DeclRefType;
15853  return !tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(),
15854  /*BuildAndDiagnose=*/false, CaptureType,
15855  DeclRefType, nullptr);
15856 }
15857 
15859  QualType CaptureType;
15860  QualType DeclRefType;
15861 
15862  // Determine whether we can capture this variable.
15863  if (tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(),
15864  /*BuildAndDiagnose=*/false, CaptureType,
15865  DeclRefType, nullptr))
15866  return QualType();
15867 
15868  return DeclRefType;
15869 }
15870 
15871 namespace {
15872 // Helper to copy the template arguments from a DeclRefExpr or MemberExpr.
15873 // The produced TemplateArgumentListInfo* points to data stored within this
15874 // object, so should only be used in contexts where the pointer will not be
15875 // used after the CopiedTemplateArgs object is destroyed.
15876 class CopiedTemplateArgs {
15877  bool HasArgs;
15878  TemplateArgumentListInfo TemplateArgStorage;
15879 public:
15880  template<typename RefExpr>
15881  CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
15882  if (HasArgs)
15883  E->copyTemplateArgumentsInto(TemplateArgStorage);
15884  }
15885  operator TemplateArgumentListInfo*()
15886 #ifdef __has_cpp_attribute
15887 #if __has_cpp_attribute(clang::lifetimebound)
15888  [[clang::lifetimebound]]
15889 #endif
15890 #endif
15891  {
15892  return HasArgs ? &TemplateArgStorage : nullptr;
15893  }
15894 };
15895 }
15896 
15897 /// Walk the set of potential results of an expression and mark them all as
15898 /// non-odr-uses if they satisfy the side-conditions of the NonOdrUseReason.
15899 ///
15900 /// \return A new expression if we found any potential results, ExprEmpty() if
15901 /// not, and ExprError() if we diagnosed an error.
15903  NonOdrUseReason NOUR) {
15904  // Per C++11 [basic.def.odr], a variable is odr-used "unless it is
15905  // an object that satisfies the requirements for appearing in a
15906  // constant expression (5.19) and the lvalue-to-rvalue conversion (4.1)
15907  // is immediately applied." This function handles the lvalue-to-rvalue
15908  // conversion part.
15909  //
15910  // If we encounter a node that claims to be an odr-use but shouldn't be, we
15911  // transform it into the relevant kind of non-odr-use node and rebuild the
15912  // tree of nodes leading to it.
15913  //
15914  // This is a mini-TreeTransform that only transforms a restricted subset of
15915  // nodes (and only certain operands of them).
15916 
15917  // Rebuild a subexpression.
15918  auto Rebuild = [&](Expr *Sub) {
15919  return rebuildPotentialResultsAsNonOdrUsed(S, Sub, NOUR);
15920  };
15921 
15922  // Check whether a potential result satisfies the requirements of NOUR.
15923  auto IsPotentialResultOdrUsed = [&](NamedDecl *D) {
15924  // Any entity other than a VarDecl is always odr-used whenever it's named
15925  // in a potentially-evaluated expression.
15926  auto *VD = dyn_cast<VarDecl>(D);
15927  if (!VD)
15928  return true;
15929 
15930  // C++2a [basic.def.odr]p4:
15931  // A variable x whose name appears as a potentially-evalauted expression
15932  // e is odr-used by e unless
15933  // -- x is a reference that is usable in constant expressions, or
15934  // -- x is a variable of non-reference type that is usable in constant
15935  // expressions and has no mutable subobjects, and e is an element of
15936  // the set of potential results of an expression of
15937  // non-volatile-qualified non-class type to which the lvalue-to-rvalue
15938  // conversion is applied, or
15939  // -- x is a variable of non-reference type, and e is an element of the
15940  // set of potential results of a discarded-value expression to which
15941  // the lvalue-to-rvalue conversion is not applied
15942  //
15943  // We check the first bullet and the "potentially-evaluated" condition in
15944  // BuildDeclRefExpr. We check the type requirements in the second bullet
15945  // in CheckLValueToRValueConversionOperand below.
15946  switch (NOUR) {
15947  case NOUR_None:
15948  case NOUR_Unevaluated:
15949  llvm_unreachable("unexpected non-odr-use-reason");
15950 
15951  case NOUR_Constant:
15952  // Constant references were handled when they were built.
15953  if (VD->getType()->isReferenceType())
15954  return true;
15955  if (auto *RD = VD->getType()->getAsCXXRecordDecl())
15956  if (RD->hasMutableFields())
15957  return true;
15958  if (!VD->isUsableInConstantExpressions(S.Context))
15959  return true;
15960  break;
15961 
15962  case NOUR_Discarded:
15963  if (VD->getType()->isReferenceType())
15964  return true;
15965  break;
15966  }
15967  return false;
15968  };
15969 
15970  // Mark that this expression does not constitute an odr-use.
15971  auto MarkNotOdrUsed = [&] {
15972  S.MaybeODRUseExprs.erase(E);
15973  if (LambdaScopeInfo *LSI = S.getCurLambda())
15974  LSI->markVariableExprAsNonODRUsed(E);
15975  };
15976 
15977  // C++2a [basic.def.odr]p2:
15978  // The set of potential results of an expression e is defined as follows:
15979  switch (E->getStmtClass()) {
15980  // -- If e is an id-expression, ...
15981  case Expr::DeclRefExprClass: {
15982  auto *DRE = cast<DeclRefExpr>(E);
15983  if (DRE->isNonOdrUse() || IsPotentialResultOdrUsed(DRE->getDecl()))
15984  break;
15985 
15986  // Rebuild as a non-odr-use DeclRefExpr.
15987  MarkNotOdrUsed();
15988  return DeclRefExpr::Create(
15989  S.Context, DRE->getQualifierLoc(), DRE->getTemplateKeywordLoc(),
15990  DRE->getDecl(), DRE->refersToEnclosingVariableOrCapture(),
15991  DRE->getNameInfo(), DRE->getType(), DRE->getValueKind(),
15992  DRE->getFoundDecl(), CopiedTemplateArgs(DRE), NOUR);
15993  }
15994 
15995  case Expr::FunctionParmPackExprClass: {
15996  auto *FPPE = cast<FunctionParmPackExpr>(E);
15997  // If any of the declarations in the pack is odr-used, then the expression
15998  // as a whole constitutes an odr-use.
15999  for (VarDecl *D : *FPPE)
16000  if (IsPotentialResultOdrUsed(D))
16001  return ExprEmpty();
16002 
16003  // FIXME: Rebuild as a non-odr-use FunctionParmPackExpr? In practice,
16004  // nothing cares about whether we marked this as an odr-use, but it might
16005  // be useful for non-compiler tools.
16006  MarkNotOdrUsed();
16007  break;
16008  }
16009 
16010  // -- If e is a subscripting operation with an array operand...
16011  case Expr::ArraySubscriptExprClass: {
16012  auto *ASE = cast<ArraySubscriptExpr>(E);
16013  Expr *OldBase = ASE->getBase()->IgnoreImplicit();
16014  if (!OldBase->getType()->isArrayType())
16015  break;
16016  ExprResult Base = Rebuild(OldBase);
16017  if (!Base.isUsable())
16018  return Base;
16019  Expr *LHS = ASE->getBase() == ASE->getLHS() ? Base.get() : ASE->getLHS();
16020  Expr *RHS = ASE->getBase() == ASE->getRHS() ? Base.get() : ASE->getRHS();
16021  SourceLocation LBracketLoc = ASE->getBeginLoc(); // FIXME: Not stored.
16022  return S.ActOnArraySubscriptExpr(nullptr, LHS, LBracketLoc, RHS,
16023  ASE->getRBracketLoc());
16024  }
16025 
16026  case Expr::MemberExprClass: {
16027  auto *ME = cast<MemberExpr>(E);
16028  // -- If e is a class member access expression [...] naming a non-static
16029  // data member...
16030  if (isa<FieldDecl>(ME->getMemberDecl())) {
16031  ExprResult Base = Rebuild(ME->getBase());
16032  if (!Base.isUsable())
16033  return Base;
16034  return MemberExpr::Create(
16035  S.Context, Base.get(), ME->isArrow(), ME->getOperatorLoc(),
16036  ME->getQualifierLoc(), ME->getTemplateKeywordLoc(),
16037  ME->getMemberDecl(), ME->getFoundDecl(), ME->getMemberNameInfo(),
16038  CopiedTemplateArgs(ME), ME->getType(), ME->getValueKind(),
16039  ME->getObjectKind(), ME->isNonOdrUse());
16040  }
16041 
16042  if (ME->getMemberDecl()->isCXXInstanceMember())
16043  break;
16044 
16045  // -- If e is a class member access expression naming a static data member,
16046  // ...
16047  if (ME->isNonOdrUse() || IsPotentialResultOdrUsed(ME->getMemberDecl()))
16048  break;
16049 
16050  // Rebuild as a non-odr-use MemberExpr.
16051  MarkNotOdrUsed();
16052  return MemberExpr::Create(
16053  S.Context, ME->getBase(), ME->isArrow(), ME->getOperatorLoc(),
16054  ME->getQualifierLoc(), ME->getTemplateKeywordLoc(), ME->getMemberDecl(),
16055  ME->getFoundDecl(), ME->getMemberNameInfo(), CopiedTemplateArgs(ME),
16056  ME->getType(), ME->getValueKind(), ME->getObjectKind(), NOUR);
16057  return ExprEmpty();
16058  }
16059 
16060  case Expr::BinaryOperatorClass: {
16061  auto *BO = cast<BinaryOperator>(E);
16062  Expr *LHS = BO->getLHS();
16063  Expr *RHS = BO->getRHS();
16064  // -- If e is a pointer-to-member expression of the form e1 .* e2 ...
16065  if (BO->getOpcode() == BO_PtrMemD) {
16066  ExprResult Sub = Rebuild(LHS);
16067  if (!Sub.isUsable())
16068  return Sub;
16069  LHS = Sub.get();
16070  // -- If e is a comma expression, ...
16071  } else if (BO->getOpcode() == BO_Comma) {
16072  ExprResult Sub = Rebuild(RHS);
16073  if (!Sub.isUsable())
16074  return Sub;
16075  RHS = Sub.get();
16076  } else {
16077  break;
16078  }
16079  return S.BuildBinOp(nullptr, BO->getOperatorLoc(), BO->getOpcode(),
16080  LHS, RHS);
16081  }
16082 
16083  // -- If e has the form (e1)...
16084  case Expr::ParenExprClass: {
16085  auto *PE = cast<ParenExpr>(E);
16086  ExprResult Sub = Rebuild(PE->getSubExpr());
16087  if (!Sub.isUsable())
16088  return Sub;
16089  return S.ActOnParenExpr(PE->getLParen(), PE->getRParen(), Sub.get());
16090  }
16091 
16092  // -- If e is a glvalue conditional expression, ...
16093  // We don't apply this to a binary conditional operator. FIXME: Should we?
16094  case Expr::ConditionalOperatorClass: {
16095  auto *CO = cast<ConditionalOperator>(E);
16096  ExprResult LHS = Rebuild(CO->getLHS());
16097  if (LHS.isInvalid())
16098  return ExprError();
16099  ExprResult RHS = Rebuild(CO->getRHS());
16100  if (RHS.isInvalid())
16101  return ExprError();
16102  if (!LHS.isUsable() && !RHS.isUsable())
16103  return ExprEmpty();
16104  if (!LHS.isUsable())
16105  LHS = CO->getLHS();
16106  if (!RHS.isUsable())
16107  RHS = CO->getRHS();
16108  return S.ActOnConditionalOp(CO->getQuestionLoc(), CO->getColonLoc(),
16109  CO->getCond(), LHS.get(), RHS.get());
16110  }
16111 
16112  // [Clang extension]
16113  // -- If e has the form __extension__ e1...
16114  case Expr::UnaryOperatorClass: {
16115  auto *UO = cast<UnaryOperator>(E);
16116  if (UO->getOpcode() != UO_Extension)
16117  break;
16118  ExprResult Sub = Rebuild(UO->getSubExpr());
16119  if (!Sub.isUsable())
16120  return Sub;
16121  return S.BuildUnaryOp(nullptr, UO->getOperatorLoc(), UO_Extension,
16122  Sub.get());
16123  }
16124 
16125  // [Clang extension]
16126  // -- If e has the form _Generic(...), the set of potential results is the
16127  // union of the sets of potential results of the associated expressions.
16128  case Expr::GenericSelectionExprClass: {
16129  auto *GSE = cast<GenericSelectionExpr>(E);
16130 
16131  SmallVector<Expr *, 4> AssocExprs;
16132  bool AnyChanged = false;
16133  for (Expr *OrigAssocExpr : GSE->getAssocExprs()) {
16134  ExprResult AssocExpr = Rebuild(OrigAssocExpr);
16135  if (AssocExpr.isInvalid())
16136  return ExprError();
16137  if (AssocExpr.isUsable()) {
16138  AssocExprs.push_back(AssocExpr.get());
16139  AnyChanged = true;
16140  } else {
16141  AssocExprs.push_back(OrigAssocExpr);
16142  }
16143  }
16144 
16145  return AnyChanged ? S.CreateGenericSelectionExpr(
16146  GSE->getGenericLoc(), GSE->getDefaultLoc(),
16147  GSE->getRParenLoc(), GSE->getControllingExpr(),
16148  GSE->getAssocTypeSourceInfos(), AssocExprs)
16149  : ExprEmpty();
16150  }
16151 
16152  // [Clang extension]
16153  // -- If e has the form __builtin_choose_expr(...), the set of potential
16154  // results is the union of the sets of potential results of the
16155  // second and third subexpressions.
16156  case Expr::ChooseExprClass: {
16157  auto *CE = cast<ChooseExpr>(E);
16158 
16159  ExprResult LHS = Rebuild(CE->getLHS());
16160  if (LHS.isInvalid())
16161  return ExprError();
16162 
16163  ExprResult RHS = Rebuild(CE->getLHS());
16164  if (RHS.isInvalid())
16165  return ExprError();
16166 
16167  if (!LHS.get() && !RHS.get())
16168  return ExprEmpty();
16169  if (!LHS.isUsable())
16170  LHS = CE->getLHS();
16171  if (!RHS.isUsable())
16172  RHS = CE->getRHS();
16173 
16174  return S.ActOnChooseExpr(CE->getBuiltinLoc(), CE->getCond(), LHS.get(),
16175  RHS.get(), CE->getRParenLoc());
16176  }
16177 
16178  // Step through non-syntactic nodes.
16179  case Expr::ConstantExprClass: {
16180  auto *CE = cast<ConstantExpr>(E);
16181  ExprResult Sub = Rebuild(CE->getSubExpr());
16182  if (!Sub.isUsable())
16183  return Sub;
16184  return ConstantExpr::Create(S.Context, Sub.get());
16185  }
16186 
16187  // We could mostly rely on the recursive rebuilding to rebuild implicit
16188  // casts, but not at the top level, so rebuild them here.
16189  case Expr::ImplicitCastExprClass: {
16190  auto *ICE = cast<ImplicitCastExpr>(E);
16191  // Only step through the narrow set of cast kinds we expect to encounter.
16192  // Anything else suggests we've left the region in which potential results
16193  // can be found.
16194  switch (ICE->getCastKind()) {
16195  case CK_NoOp:
16196  case CK_DerivedToBase:
16197  case CK_UncheckedDerivedToBase: {
16198  ExprResult Sub = Rebuild(ICE->getSubExpr());
16199  if (!Sub.isUsable())
16200  return Sub;
16201  CXXCastPath Path(ICE->path());
16202  return S.ImpCastExprToType(Sub.get(), ICE->getType(), ICE->getCastKind(),
16203  ICE->getValueKind(), &Path);
16204  }
16205 
16206  default:
16207  break;
16208  }
16209  break;
16210  }
16211 
16212  default:
16213  break;
16214  }
16215 
16216  // Can't traverse through this node. Nothing to do.
16217  return ExprEmpty();
16218 }
16219 
16221  // Check whether the operand is or contains an object of non-trivial C union
16222  // type.
16223  if (E->getType().isVolatileQualified() &&
16226  checkNonTrivialCUnion(E->getType(), E->getExprLoc(),
16228  NTCUK_Destruct|NTCUK_Copy);
16229 
16230  // C++2a [basic.def.odr]p4:
16231  // [...] an expression of non-volatile-qualified non-class type to which
16232  // the lvalue-to-rvalue conversion is applied [...]
16233  if (E->getType().isVolatileQualified() || E->getType()->getAs<RecordType>())
16234  return E;
16235 
16236  ExprResult Result =
16238  if (Result.isInvalid())
16239  return ExprError();
16240  return Result.get() ? Result : E;
16241 }
16242 
16244  Res = CorrectDelayedTyposInExpr(Res);
16245 
16246  if (!Res.isUsable())
16247  return Res;
16248 
16249  // If a constant-expression is a reference to a variable where we delay
16250  // deciding whether it is an odr-use, just assume we will apply the
16251  // lvalue-to-rvalue conversion. In the one case where this doesn't happen
16252  // (a non-type template argument), we have special handling anyway.
16253  return CheckLValueToRValueConversionOperand(Res.get());
16254 }
16255 
16257  // Iterate through a local copy in case MarkVarDeclODRUsed makes a recursive
16258  // call.
16259  MaybeODRUseExprSet LocalMaybeODRUseExprs;
16260  std::swap(LocalMaybeODRUseExprs, MaybeODRUseExprs);
16261 
16262  for (Expr *E : LocalMaybeODRUseExprs) {
16263  if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
16264  MarkVarDeclODRUsed(cast<VarDecl>(DRE->getDecl()),
16265  DRE->getLocation(), *this);
16266  } else if (auto *ME = dyn_cast<MemberExpr>(E)) {
16267  MarkVarDeclODRUsed(cast<VarDecl>(ME->getMemberDecl()), ME->getMemberLoc(),
16268  *this);
16269  } else if (auto *FP = dyn_cast<FunctionParmPackExpr>(E)) {
16270  for (VarDecl *VD : *FP)
16271  MarkVarDeclODRUsed(VD, FP->getParameterPackLocation(), *this);
16272  } else {
16273  llvm_unreachable("Unexpected expression");
16274  }
16275  }
16276 
16277  assert(MaybeODRUseExprs.empty() &&
16278  "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?");
16279 }
16280 
16281 static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc,
16282  VarDecl *Var, Expr *E) {
16283  assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||
16284  isa<FunctionParmPackExpr>(E)) &&
16285  "Invalid Expr argument to DoMarkVarDeclReferenced");
16286  Var->setReferenced();
16287 
16288  if (Var->isInvalidDecl())
16289  return;
16290 
16291  auto *MSI = Var->getMemberSpecializationInfo();
16294 
16295  OdrUseContext OdrUse = isOdrUseContext(SemaRef);
16296  bool UsableInConstantExpr =
16298 
16299  // C++20 [expr.const]p12:
16300  // A variable [...] is needed for constant evaluation if it is [...] a
16301  // variable whose name appears as a potentially constant evaluated
16302  // expression that is either a contexpr variable or is of non-volatile
16303  // const-qualified integral type or of reference type
16304  bool NeededForConstantEvaluation =
16305  isPotentiallyConstantEvaluatedContext(SemaRef) && UsableInConstantExpr;
16306 
16307  bool NeedDefinition =
16308  OdrUse == OdrUseContext::Used || NeededForConstantEvaluation;
16309 
16311  dyn_cast<VarTemplateSpecializationDecl>(Var);
16312  assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
16313  "Can't instantiate a partial template specialization.");
16314 
16315  // If this might be a member specialization of a static data member, check
16316  // the specialization is visible. We already did the checks for variable
16317  // template specializations when we created them.
16318  if (NeedDefinition && TSK != TSK_Undeclared &&
16319  !isa<VarTemplateSpecializationDecl>(Var))
16320  SemaRef.checkSpecializationVisibility(Loc, Var);
16321 
16322  // Perform implicit instantiation of static data members, static data member
16323  // templates of class templates, and variable template specializations. Delay
16324  // instantiations of variable templates, except for those that could be used
16325  // in a constant expression.
16326  if (NeedDefinition && isTemplateInstantiation(TSK)) {
16327  // Per C++17 [temp.explicit]p10, we may instantiate despite an explicit
16328  // instantiation declaration if a variable is usable in a constant
16329  // expression (among other cases).
16330  bool TryInstantiating =
16331  TSK == TSK_ImplicitInstantiation ||
16332  (TSK == TSK_ExplicitInstantiationDeclaration && UsableInConstantExpr);
16333 
16334  if (TryInstantiating) {
16335  SourceLocation PointOfInstantiation =
16336  MSI ? MSI->getPointOfInstantiation() : Var->getPointOfInstantiation();
16337  bool FirstInstantiation = PointOfInstantiation.isInvalid();
16338  if (FirstInstantiation) {
16339  PointOfInstantiation = Loc;
16340  if (MSI)
16341  MSI->setPointOfInstantiation(PointOfInstantiation);
16342  else
16343  Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
16344  }
16345 
16346  bool InstantiationDependent = false;
16347  bool IsNonDependent =
16349  VarSpec->getTemplateArgsInfo(), InstantiationDependent)
16350  : true;
16351 
16352  // Do not instantiate specializations that are still type-dependent.
16353  if (IsNonDependent) {
16354  if (UsableInConstantExpr) {
16355  // Do not defer instantiations of variables that could be used in a
16356  // constant expression.
16357  SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
16358  } else if (FirstInstantiation ||
16359  isa<VarTemplateSpecializationDecl>(Var)) {
16360  // FIXME: For a specialization of a variable template, we don't
16361  // distinguish between "declaration and type implicitly instantiated"
16362  // and "implicit instantiation of definition requested", so we have
16363  // no direct way to avoid enqueueing the pending instantiation
16364  // multiple times.
16365  SemaRef.PendingInstantiations
16366  .push_back(std::make_pair(Var, PointOfInstantiation));
16367  }
16368  }
16369  }
16370  }
16371 
16372  // C++2a [basic.def.odr]p4:
16373  // A variable x whose name appears as a potentially-evaluated expression e
16374  // is odr-used by e unless
16375  // -- x is a reference that is usable in constant expressions
16376  // -- x is a variable of non-reference type that is usable in constant
16377  // expressions and has no mutable subobjects [FIXME], and e is an
16378  // element of the set of potential results of an expression of
16379  // non-volatile-qualified non-class type to which the lvalue-to-rvalue
16380  // conversion is applied
16381  // -- x is a variable of non-reference type, and e is an element of the set
16382  // of potential results of a discarded-value expression to which the
16383  // lvalue-to-rvalue conversion is not applied [FIXME]
16384  //
16385  // We check the first part of the second bullet here, and
16386  // Sema::CheckLValueToRValueConversionOperand deals with the second part.
16387  // FIXME: To get the third bullet right, we need to delay this even for
16388  // variables that are not usable in constant expressions.
16389 
16390  // If we already know this isn't an odr-use, there's nothing more to do.
16391  if (DeclRefExpr *DRE = dyn_cast_or_null<DeclRefExpr>(E))
16392  if (DRE->isNonOdrUse())
16393  return;
16394  if (MemberExpr *ME = dyn_cast_or_null<MemberExpr>(E))
16395  if (ME->isNonOdrUse())
16396  return;
16397 
16398  switch (OdrUse) {
16399  case OdrUseContext::None:
16400  assert((!E || isa<FunctionParmPackExpr>(E)) &&
16401  "missing non-odr-use marking for unevaluated decl ref");
16402  break;
16403 
16404  case OdrUseContext::FormallyOdrUsed:
16405  // FIXME: Ignoring formal odr-uses results in incorrect lambda capture
16406  // behavior.
16407  break;
16408 
16409  case OdrUseContext::Used:
16410  // If we might later find that this expression isn't actually an odr-use,
16411  // delay the marking.
16412  if (E && Var->isUsableInConstantExpressions(SemaRef.Context))
16413  SemaRef.MaybeODRUseExprs.insert(E);
16414  else
16415  MarkVarDeclODRUsed(Var, Loc, SemaRef);
16416  break;
16417 
16418  case OdrUseContext::Dependent:
16419  // If this is a dependent context, we don't need to mark variables as
16420  // odr-used, but we may still need to track them for lambda capture.
16421  // FIXME: Do we also need to do this inside dependent typeid expressions
16422  // (which are modeled as unevaluated at this point)?
16423  const bool RefersToEnclosingScope =
16424  (SemaRef.CurContext != Var->getDeclContext() &&
16425  Var->getDeclContext()->isFunctionOrMethod() && Var->hasLocalStorage());
16426  if (RefersToEnclosingScope) {
16427  LambdaScopeInfo *const LSI =
16428  SemaRef.getCurLambda(/*IgnoreNonLambdaCapturingScope=*/true);
16429  if (LSI && (!LSI->CallOperator ||
16430  !LSI->CallOperator->Encloses(Var->getDeclContext()))) {
16431  // If a variable could potentially be odr-used, defer marking it so
16432  // until we finish analyzing the full expression for any
16433  // lvalue-to-rvalue
16434  // or discarded value conversions that would obviate odr-use.
16435  // Add it to the list of potential captures that will be analyzed
16436  // later (ActOnFinishFullExpr) for eventual capture and odr-use marking
16437  // unless the variable is a reference that was initialized by a constant
16438  // expression (this will never need to be captured or odr-used).
16439  //
16440  // FIXME: We can simplify this a lot after implementing P0588R1.
16441  assert(E && "Capture variable should be used in an expression.");
16442  if (!Var->getType()->isReferenceType() ||
16443  !Var->isUsableInConstantExpressions(SemaRef.Context))
16444  LSI->addPotentialCapture(E->IgnoreParens());
16445  }
16446  }
16447  break;
16448  }
16449 }
16450 
16451 /// Mark a variable referenced, and check whether it is odr-used
16452 /// (C++ [basic.def.odr]p2, C99 6.9p3). Note that this should not be
16453 /// used directly for normal expressions referring to VarDecl.
16455  DoMarkVarDeclReferenced(*this, Loc, Var, nullptr);
16456 }
16457 
16458 static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc,
16459  Decl *D, Expr *E, bool MightBeOdrUse) {
16460  if (SemaRef.isInOpenMPDeclareTargetContext())
16461  SemaRef.checkDeclIsAllowedInOpenMPTarget(E, D);
16462 
16463  if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
16464  DoMarkVarDeclReferenced(SemaRef, Loc, Var, E);
16465  return;
16466  }
16467 
16468  SemaRef.MarkAnyDeclReferenced(Loc, D, MightBeOdrUse);
16469 
16470  // If this is a call to a method via a cast, also mark the method in the
16471  // derived class used in case codegen can devirtualize the call.
16472  const MemberExpr *ME = dyn_cast<MemberExpr>(E);
16473  if (!ME)
16474  return;
16475  CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl());
16476  if (!MD)
16477  return;
16478  // Only attempt to devirtualize if this is truly a virtual call.
16479  bool IsVirtualCall = MD->isVirtual() &&
16480  ME->performsVirtualDispatch(SemaRef.getLangOpts());
16481  if (!IsVirtualCall)
16482  return;
16483 
16484  // If it's possible to devirtualize the call, mark the called function
16485  // referenced.
16487  ME->getBase(), SemaRef.getLangOpts().AppleKext);
16488  if (DM)
16489  SemaRef.MarkAnyDeclReferenced(Loc, DM, MightBeOdrUse);
16490 }
16491 
16492 /// Perform reference-marking and odr-use handling for a DeclRefExpr.
16494  // TODO: update this with DR# once a defect report is filed.
16495  // C++11 defect. The address of a pure member should not be an ODR use, even
16496  // if it's a qualified reference.
16497  bool OdrUse = true;
16498  if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getDecl()))
16499  if (Method->isVirtual() &&
16500  !Method->getDevirtualizedMethod(Base, getLangOpts().AppleKext))
16501  OdrUse = false;
16502  MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse);
16503 }
16504 
16505 /// Perform reference-marking and odr-use handling for a MemberExpr.
16507  // C++11 [basic.def.odr]p2:
16508  // A non-overloaded function whose name appears as a potentially-evaluated
16509  // expression or a member of a set of candidate functions, if selected by
16510  // overload resolution when referred to from a potentially-evaluated
16511  // expression, is odr-used, unless it is a pure virtual function and its
16512  // name is not explicitly qualified.
16513  bool MightBeOdrUse = true;
16514  if (E->performsVirtualDispatch(getLangOpts())) {
16515  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getMemberDecl()))
16516  if (Method->isPure())
16517  MightBeOdrUse = false;
16518  }
16519  SourceLocation Loc =
16520  E->getMemberLoc().isValid() ? E->getMemberLoc() : E->getBeginLoc();
16521  MarkExprReferenced(*this, Loc, E->getMemberDecl(), E, MightBeOdrUse);
16522 }
16523 
16524 /// Perform reference-marking and odr-use handling for a FunctionParmPackExpr.
16526  for (VarDecl *VD : *E)
16527  MarkExprReferenced(*this, E->getParameterPackLocation(), VD, E, true);
16528 }
16529 
16530 /// Perform marking for a reference to an arbitrary declaration. It
16531 /// marks the declaration referenced, and performs odr-use checking for
16532 /// functions and variables. This method should not be used when building a
16533 /// normal expression which refers to a variable.
16535  bool MightBeOdrUse) {
16536  if (MightBeOdrUse) {
16537  if (auto *VD = dyn_cast<VarDecl>(D)) {
16538  MarkVariableReferenced(Loc, VD);
16539  return;
16540  }
16541  }
16542  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
16543  MarkFunctionReferenced(Loc, FD, MightBeOdrUse);
16544  return;
16545  }
16546  D->setReferenced();
16547 }
16548 
16549 namespace {
16550  // Mark all of the declarations used by a type as referenced.
16551  // FIXME: Not fully implemented yet! We need to have a better understanding
16552  // of when we're entering a context we should not recurse into.
16553  // FIXME: This is and EvaluatedExprMarker are more-or-less equivalent to
16554  // TreeTransforms rebuilding the type in a new context. Rather than
16555  // duplicating the TreeTransform logic, we should consider reusing it here.
16556  // Currently that causes problems when rebuilding LambdaExprs.
16557  class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> {
16558  Sema &S;
16559  SourceLocation Loc;
16560 
16561  public:
16562  typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited;
16563 
16564  MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { }
16565 
16566  bool TraverseTemplateArgument(const TemplateArgument &Arg);
16567  };
16568 }
16569 
16570 bool MarkReferencedDecls::TraverseTemplateArgument(
16571  const TemplateArgument &Arg) {
16572  {
16573  // A non-type template argument is a constant-evaluated context.
16576  if (Arg.getKind() == TemplateArgument::Declaration) {
16577  if (Decl *D = Arg.getAsDecl())
16578  S.MarkAnyDeclReferenced(Loc, D, true);
16579  } else if (Arg.getKind() == TemplateArgument::Expression) {
16581  }
16582  }
16583 
16584  return Inherited::TraverseTemplateArgument(Arg);
16585 }
16586 
16588  MarkReferencedDecls Marker(*this, Loc);
16589  Marker.TraverseType(T);
16590 }
16591 
16592 namespace {
16593  /// Helper class that marks all of the declarations referenced by
16594  /// potentially-evaluated subexpressions as "referenced".
16595  class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> {
16596  Sema &S;
16597  bool SkipLocalVariables;
16598 
16599  public:
16601 
16602  EvaluatedExprMarker(Sema &S, bool SkipLocalVariables)
16603  : Inherited(S.Context), S(S), SkipLocalVariables(SkipLocalVariables) { }
16604 
16605  void VisitDeclRefExpr(DeclRefExpr *E) {
16606  // If we were asked not to visit local variables, don't.
16607  if (SkipLocalVariables) {
16608  if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
16609  if (VD->hasLocalStorage())
16610  return;
16611  }
16612 
16613  S.MarkDeclRefReferenced(E);
16614  }
16615 
16616  void VisitMemberExpr(MemberExpr *E) {
16617  S.MarkMemberReferenced(E);
16618  Inherited::VisitMemberExpr(E);
16619  }
16620 
16621  void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
16623  E->getBeginLoc(),
16624  const_cast<CXXDestructorDecl *>(E->getTemporary()->getDestructor()));
16625  Visit(E->getSubExpr());
16626  }
16627 
16628  void VisitCXXNewExpr(CXXNewExpr *E) {
16629  if (E->getOperatorNew())
16631  if (E->getOperatorDelete())
16633  Inherited::VisitCXXNewExpr(E);
16634  }
16635 
16636  void VisitCXXDeleteExpr(CXXDeleteExpr *E) {
16637  if (E->getOperatorDelete())
16640  if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
16641  CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
16643  }
16644 
16645  Inherited::VisitCXXDeleteExpr(E);
16646  }
16647 
16648  void VisitCXXConstructExpr(CXXConstructExpr *E) {
16650  Inherited::VisitCXXConstructExpr(E);
16651  }
16652 
16653  void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
16654  Visit(E->getExpr());
16655  }
16656  };
16657 }
16658 
16659 /// Mark any declarations that appear within this expression or any
16660 /// potentially-evaluated subexpressions as "referenced".
16661 ///
16662 /// \param SkipLocalVariables If true, don't mark local variables as
16663 /// 'referenced'.
16665  bool SkipLocalVariables) {
16666  EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E);
16667 }
16668 
16669 /// Emit a diagnostic that describes an effect on the run-time behavior
16670 /// of the program being compiled.
16671 ///
16672 /// This routine emits the given diagnostic when the code currently being
16673 /// type-checked is "potentially evaluated", meaning that there is a
16674 /// possibility that the code will actually be executable. Code in sizeof()
16675 /// expressions, code used only during overload resolution, etc., are not
16676 /// potentially evaluated. This routine will suppress such diagnostics or,
16677 /// in the absolutely nutty case of potentially potentially evaluated
16678 /// expressions (C++ typeid), queue the diagnostic to potentially emit it
16679 /// later.
16680 ///
16681 /// This routine should be used for all diagnostics that describe the run-time
16682 /// behavior of a program, such as passing a non-POD value through an ellipsis.
16683 /// Failure to do so will likely result in spurious diagnostics or failures
16684 /// during overload resolution or within sizeof/alignof/typeof/typeid.
16686  const PartialDiagnostic &PD) {
16687  switch (ExprEvalContexts.back().Context) {
16688  case ExpressionEvaluationContext::Unevaluated:
16689  case ExpressionEvaluationContext::UnevaluatedList:
16690  case ExpressionEvaluationContext::UnevaluatedAbstract:
16691  case ExpressionEvaluationContext::DiscardedStatement:
16692  // The argument will never be evaluated, so don't complain.
16693  break;
16694 
16695  case ExpressionEvaluationContext::ConstantEvaluated:
16696  // Relevant diagnostics should be produced by constant evaluation.
16697  break;
16698 
16699  case ExpressionEvaluationContext::PotentiallyEvaluated:
16700  case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
16701  if (!Stmts.empty() && getCurFunctionOrMethodDecl()) {
16702  FunctionScopes.back()->PossiblyUnreachableDiags.
16703  push_back(sema::PossiblyUnreachableDiag(PD, Loc, Stmts));
16704  return true;
16705  }
16706 
16707  // The initializer of a constexpr variable or of the first declaration of a
16708  // static data member is not syntactically a constant evaluated constant,
16709  // but nonetheless is always required to be a constant expression, so we
16710  // can skip diagnosing.
16711  // FIXME: Using the mangling context here is a hack.
16712  if (auto *VD = dyn_cast_or_null<VarDecl>(
16713  ExprEvalContexts.back().ManglingContextDecl)) {
16714  if (VD->isConstexpr() ||
16715  (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
16716  break;
16717  // FIXME: For any other kind of variable, we should build a CFG for its
16718  // initializer and check whether the context in question is reachable.
16719  }
16720 
16721  Diag(Loc, PD);
16722  return true;
16723  }
16724 
16725  return false;
16726 }
16727 
16728 bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
16729  const PartialDiagnostic &PD) {
16730  return DiagRuntimeBehavior(
16731  Loc, Statement ? llvm::makeArrayRef(Statement) : llvm::None, PD);
16732 }
16733 
16735  CallExpr *CE, FunctionDecl *FD) {
16736  if (ReturnType->isVoidType() || !ReturnType->isIncompleteType())
16737  return false;
16738 
16739  // If we're inside a decltype's expression, don't check for a valid return
16740  // type or construct temporaries until we know whether this is the last call.
16741  if (ExprEvalContexts.back().ExprContext ==
16742  ExpressionEvaluationContextRecord::EK_Decltype) {
16743  ExprEvalContexts.back().DelayedDecltypeCalls.push_back(CE);
16744  return false;
16745  }
16746 
16747  class CallReturnIncompleteDiagnoser : public TypeDiagnoser {
16748  FunctionDecl *FD;
16749  CallExpr *CE;
16750 
16751  public:
16752  CallReturnIncompleteDiagnoser(FunctionDecl *FD, CallExpr *CE)
16753  : FD(FD), CE(CE) { }
16754 
16755  void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
16756  if (!FD) {
16757  S.Diag(Loc, diag::err_call_incomplete_return)
16758  << T << CE->getSourceRange();
16759  return;
16760  }
16761 
16762  S.Diag(Loc, diag::err_call_function_incomplete_return)
16763  << CE->getSourceRange() << FD->getDeclName() << T;
16764  S.Diag(FD->getLocation(), diag::note_entity_declared_at)
16765  << FD->getDeclName();
16766  }
16767  } Diagnoser(FD, CE);
16768 
16769  if (RequireCompleteType(Loc, ReturnType, Diagnoser))
16770  return true;
16771 
16772  return false;
16773 }
16774 
16775 // Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses
16776 // will prevent this condition from triggering, which is what we want.
16778  SourceLocation Loc;
16779 
16780  unsigned diagnostic = diag::warn_condition_is_assignment;
16781  bool IsOrAssign = false;
16782 
16783  if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
16784  if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
16785  return;
16786 
16787  IsOrAssign = Op->getOpcode() == BO_OrAssign;
16788 
16789  // Greylist some idioms by putting them into a warning subcategory.
16790  if (ObjCMessageExpr *ME
16791  = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
16792  Selector Sel = ME->getSelector();
16793 
16794  // self = [<foo> init...]
16795  if (isSelfExpr(Op->getLHS()) && ME->getMethodFamily() == OMF_init)
16796  diagnostic = diag::warn_condition_is_idiomatic_assignment;
16797 
16798  // <foo> = [<bar> nextObject]
16799  else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "nextObject")
16800  diagnostic = diag::warn_condition_is_idiomatic_assignment;
16801  }
16802 
16803  Loc = Op->getOperatorLoc();
16804  } else if (CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
16805  if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
16806  return;
16807 
16808  IsOrAssign = Op->getOperator() == OO_PipeEqual;
16809  Loc = Op->getOperatorLoc();
16810  } else if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
16811  return DiagnoseAssignmentAsCondition(POE->getSyntacticForm());
16812  else {
16813  // Not an assignment.
16814  return;
16815  }
16816 
16817  Diag(Loc, diagnostic) << E->getSourceRange();
16818 
16820  SourceLocation Close = getLocForEndOfToken(E->getSourceRange().getEnd());
16821  Diag(Loc, diag::note_condition_assign_silence)
16822  << FixItHint::CreateInsertion(Open, "(")
16823  << FixItHint::CreateInsertion(Close, ")");
16824 
16825  if (IsOrAssign)
16826  Diag(Loc, diag::note_condition_or_assign_to_comparison)
16827  << FixItHint::CreateReplacement(Loc, "!=");
16828  else
16829  Diag(Loc, diag::note_condition_assign_to_comparison)
16830  << FixItHint::CreateReplacement(Loc, "==");
16831 }
16832 
16833 /// Redundant parentheses over an equality comparison can indicate
16834 /// that the user intended an assignment used as condition.
16836  // Don't warn if the parens came from a macro.
16837  SourceLocation parenLoc = ParenE->getBeginLoc();
16838  if (parenLoc.isInvalid() || parenLoc.isMacroID())
16839  return;
16840  // Don't warn for dependent expressions.
16841  if (ParenE->isTypeDependent())
16842  return;
16843 
16844  Expr *E = ParenE->IgnoreParens();
16845 
16846  if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E))
16847  if (opE->getOpcode() == BO_EQ &&
16848  opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context)
16849  == Expr::MLV_Valid) {
16850  SourceLocation Loc = opE->getOperatorLoc();
16851 
16852  Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange();
16853  SourceRange ParenERange = ParenE->getSourceRange();
16854  Diag(Loc, diag::note_equality_comparison_silence)
16855  << FixItHint::CreateRemoval(ParenERange.getBegin())
16856  << FixItHint::CreateRemoval(ParenERange.getEnd());
16857  Diag(Loc, diag::note_equality_comparison_to_assign)
16858  << FixItHint::CreateReplacement(Loc, "=");
16859  }
16860 }
16861 
16863  bool IsConstexpr) {
16864  DiagnoseAssignmentAsCondition(E);
16865  if (ParenExpr *parenE = dyn_cast<ParenExpr>(E))
16866  DiagnoseEqualityWithExtraParens(parenE);
16867 
16868  ExprResult result = CheckPlaceholderExpr(E);
16869  if (result.isInvalid()) return ExprError();
16870  E = result.get();
16871 
16872  if (!E->isTypeDependent()) {
16873  if (getLangOpts().CPlusPlus)
16874  return CheckCXXBooleanCondition(E, IsConstexpr); // C++ 6.4p4
16875 
16876  ExprResult ERes = DefaultFunctionArrayLvalueConversion(E);
16877  if (ERes.isInvalid())
16878  return ExprError();
16879  E = ERes.get();
16880 
16881  QualType T = E->getType();
16882  if (!T->isScalarType()) { // C99 6.8.4.1p1
16883  Diag(Loc, diag::err_typecheck_statement_requires_scalar)
16884  << T << E->getSourceRange();
16885  return ExprError();
16886  }
16887  CheckBoolLikeConversion(E, Loc);
16888  }
16889 
16890  return E;
16891 }
16892 
16894  Expr *SubExpr, ConditionKind CK) {
16895  // Empty conditions are valid in for-statements.
16896  if (!SubExpr)
16897  return ConditionResult();
16898 
16899  ExprResult Cond;
16900  switch (CK) {
16901  case ConditionKind::Boolean:
16902  Cond = CheckBooleanCondition(Loc, SubExpr);
16903  break;
16904 
16905  case ConditionKind::ConstexprIf:
16906  Cond = CheckBooleanCondition(Loc, SubExpr, true);
16907  break;
16908 
16909  case ConditionKind::Switch:
16910  Cond = CheckSwitchCondition(Loc, SubExpr);
16911  break;
16912  }
16913  if (Cond.isInvalid())
16914  return ConditionError();
16915 
16916  // FIXME: FullExprArg doesn't have an invalid bit, so check nullness instead.
16917  FullExprArg FullExpr = MakeFullExpr(Cond.get(), Loc);
16918  if (!FullExpr.get())
16919  return ConditionError();
16920 
16921  return ConditionResult(*this, nullptr, FullExpr,
16922  CK == ConditionKind::ConstexprIf);
16923 }
16924 
16925 namespace {
16926  /// A visitor for rebuilding a call to an __unknown_any expression
16927  /// to have an appropriate type.
16928  struct RebuildUnknownAnyFunction
16929  : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
16930 
16931  Sema &S;
16932 
16933  RebuildUnknownAnyFunction(Sema &S) : S(S) {}
16934 
16935  ExprResult VisitStmt(Stmt *S) {
16936  llvm_unreachable("unexpected statement!");
16937  }
16938 
16939  ExprResult VisitExpr(Expr *E) {
16940  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call)
16941  << E->getSourceRange();
16942  return ExprError();
16943  }
16944 
16945  /// Rebuild an expression which simply semantically wraps another
16946  /// expression which it shares the type and value kind of.
16947  template <class T> ExprResult rebuildSugarExpr(T *E) {
16948  ExprResult SubResult = Visit(E->getSubExpr());
16949  if (SubResult.isInvalid()) return ExprError();
16950 
16951  Expr *SubExpr = SubResult.get();
16952  E->setSubExpr(SubExpr);
16953  E->setType(SubExpr->getType());
16954  E->setValueKind(SubExpr->getValueKind());
16955  assert(E->getObjectKind() == OK_Ordinary);
16956  return E;
16957  }
16958 
16959  ExprResult VisitParenExpr(ParenExpr *E) {
16960  return rebuildSugarExpr(E);
16961  }
16962 
16963  ExprResult VisitUnaryExtension(UnaryOperator *E) {
16964  return rebuildSugarExpr(E);
16965  }
16966 
16967  ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
16968  ExprResult SubResult = Visit(E->getSubExpr());
16969  if (SubResult.isInvalid()) return ExprError();
16970 
16971  Expr *SubExpr = SubResult.get();
16972  E->setSubExpr(SubExpr);
16973  E->setType(S.Context.getPointerType(SubExpr->getType()));
16974  assert(E->getValueKind() == VK_RValue);
16975  assert(E->getObjectKind() == OK_Ordinary);
16976  return E;
16977  }
16978 
16979  ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
16980  if (!isa<FunctionDecl>(VD)) return VisitExpr(E);
16981 
16982  E->setType(VD->getType());
16983 
16984  assert(E->getValueKind() == VK_RValue);
16985  if (S.getLangOpts().CPlusPlus &&
16986  !(isa<CXXMethodDecl>(VD) &&
16987  cast<CXXMethodDecl>(VD)->isInstance()))
16988  E->setValueKind(VK_LValue);
16989 
16990  return E;
16991  }
16992 
16993  ExprResult VisitMemberExpr(MemberExpr *E) {
16994  return resolveDecl(E, E->getMemberDecl());
16995  }
16996 
16997  ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
16998  return resolveDecl(E, E->getDecl());
16999  }
17000  };
17001 }
17002 
17003 /// Given a function expression of unknown-any type, try to rebuild it
17004 /// to have a function type.
17005 static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) {
17006  ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr);
17007  if (Result.isInvalid()) return ExprError();
17008  return S.DefaultFunctionArrayConversion(Result.get());
17009 }
17010 
17011 namespace {
17012  /// A visitor for rebuilding an expression of type __unknown_anytype
17013  /// into one which resolves the type directly on the referring
17014  /// expression. Strict preservation of the original source
17015  /// structure is not a goal.
17016  struct RebuildUnknownAnyExpr
17017  : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
17018 
17019  Sema &S;
17020 
17021  /// The current destination type.
17022  QualType DestType;
17023 
17024  RebuildUnknownAnyExpr(Sema &S, QualType CastType)
17025  : S(S), DestType(CastType) {}
17026 
17027  ExprResult VisitStmt(Stmt *S) {
17028  llvm_unreachable("unexpected statement!");
17029  }
17030 
17031  ExprResult VisitExpr(Expr *E) {
17032  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
17033  << E->getSourceRange();
17034  return ExprError();
17035  }
17036 
17037  ExprResult VisitCallExpr(CallExpr *E);
17038  ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E);
17039 
17040  /// Rebuild an expression which simply semantically wraps another
17041  /// expression which it shares the type and value kind of.
17042  template <class T> ExprResult rebuildSugarExpr(T *E) {
17043  ExprResult SubResult = Visit(E->getSubExpr());
17044  if (SubResult.isInvalid()) return ExprError();
17045  Expr *SubExpr = SubResult.get();
17046  E->setSubExpr(SubExpr);
17047  E->setType(SubExpr->getType());
17048  E->setValueKind(SubExpr->getValueKind());
17049  assert(E->getObjectKind() == OK_Ordinary);
17050  return E;
17051  }
17052 
17053  ExprResult VisitParenExpr(ParenExpr *E) {
17054  return rebuildSugarExpr(E);
17055  }
17056 
17057  ExprResult VisitUnaryExtension(UnaryOperator *E) {
17058  return rebuildSugarExpr(E);
17059  }
17060 
17061  ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
17062  const PointerType *Ptr = DestType->getAs<PointerType>();
17063  if (!Ptr) {
17064  S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
17065  << E->getSourceRange();
17066  return ExprError();
17067  }
17068 
17069  if (isa<CallExpr>(E->getSubExpr())) {
17070  S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
17071  << E->getSourceRange();
17072  return ExprError();
17073  }
17074 
17075  assert(E->getValueKind() == VK_RValue);
17076  assert(E->getObjectKind() == OK_Ordinary);
17077  E->setType(DestType);
17078 
17079  // Build the sub-expression as if it were an object of the pointee type.
17080  DestType = Ptr->getPointeeType();
17081  ExprResult SubResult = Visit(E->getSubExpr());
17082  if (SubResult.isInvalid()) return ExprError();
17083  E->setSubExpr(SubResult.get());
17084  return E;
17085  }
17086 
17087  ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E);
17088 
17089  ExprResult resolveDecl(Expr *E, ValueDecl *VD);
17090 
17091  ExprResult VisitMemberExpr(MemberExpr *E) {
17092  return resolveDecl(E, E->getMemberDecl());
17093  }
17094 
17095  ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
17096  return resolveDecl(E, E->getDecl());
17097  }
17098  };
17099 }
17100 
17101 /// Rebuilds a call expression which yielded __unknown_anytype.
17102 ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
17103  Expr *CalleeExpr = E->getCallee();
17104 
17105  enum FnKind {
17106  FK_MemberFunction,
17107  FK_FunctionPointer,
17108  FK_BlockPointer
17109  };
17110 
17111  FnKind Kind;
17112  QualType CalleeType = CalleeExpr->getType();
17113  if (CalleeType == S.Context.BoundMemberTy) {
17114  assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E));
17115  Kind = FK_MemberFunction;
17116  CalleeType = Expr::findBoundMemberType(CalleeExpr);
17117  } else if (const PointerType *Ptr = CalleeType->getAs<PointerType>()) {
17118  CalleeType = Ptr->getPointeeType();
17119  Kind = FK_FunctionPointer;
17120  } else {
17121  CalleeType = CalleeType->castAs<BlockPointerType>()->getPointeeType();
17122  Kind = FK_BlockPointer;
17123  }
17124  const FunctionType *FnType = CalleeType->castAs<FunctionType>();
17125 
17126  // Verify that this is a legal result type of a function.
17127  if (DestType->isArrayType() || DestType->isFunctionType()) {
17128  unsigned diagID = diag::err_func_returning_array_function;
17129  if (Kind == FK_BlockPointer)
17130  diagID = diag::err_block_returning_array_function;
17131 
17132  S.Diag(E->getExprLoc(), diagID)
17133  << DestType->isFunctionType() << DestType;
17134  return ExprError();
17135  }
17136 
17137  // Otherwise, go ahead and set DestType as the call's result.
17138  E->setType(DestType.getNonLValueExprType(S.Context));
17140  assert(E->getObjectKind() == OK_Ordinary);
17141 
17142  // Rebuild the function type, replacing the result type with DestType.
17143  const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FnType);
17144  if (Proto) {
17145  // __unknown_anytype(...) is a special case used by the debugger when
17146  // it has no idea what a function's signature is.
17147  //
17148  // We want to build this call essentially under the K&R
17149  // unprototyped rules, but making a FunctionNoProtoType in C++
17150  // would foul up all sorts of assumptions. However, we cannot
17151  // simply pass all arguments as variadic arguments, nor can we
17152  // portably just call the function under a non-variadic type; see
17153  // the comment on IR-gen's TargetInfo::isNoProtoCallVariadic.
17154  // However, it turns out that in practice it is generally safe to
17155  // call a function declared as "A foo(B,C,D);" under the prototype
17156  // "A foo(B,C,D,...);". The only known exception is with the
17157  // Windows ABI, where any variadic function is implicitly cdecl
17158  // regardless of its normal CC. Therefore we change the parameter
17159  // types to match the types of the arguments.
17160  //
17161  // This is a hack, but it is far superior to moving the
17162  // corresponding target-specific code from IR-gen to Sema/AST.
17163 
17164  ArrayRef<QualType> ParamTypes = Proto->getParamTypes();
17165  SmallVector<QualType, 8> ArgTypes;
17166  if (ParamTypes.empty() && Proto->isVariadic()) { // the special case
17167  ArgTypes.reserve(E->getNumArgs());
17168  for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
17169  Expr *Arg = E->getArg(i);
17170  QualType ArgType = Arg->getType();
17171  if (E->isLValue()) {
17172  ArgType = S.Context.getLValueReferenceType(ArgType);
17173  } else if (E->isXValue()) {
17174  ArgType = S.Context.getRValueReferenceType(ArgType);
17175  }
17176  ArgTypes.push_back(ArgType);
17177  }
17178  ParamTypes = ArgTypes;
17179  }
17180  DestType = S.Context.getFunctionType(DestType, ParamTypes,
17181  Proto->getExtProtoInfo());
17182  } else {
17183  DestType = S.Context.getFunctionNoProtoType(DestType,
17184  FnType->getExtInfo());
17185  }
17186 
17187  // Rebuild the appropriate pointer-to-function type.
17188  switch (Kind) {
17189  case FK_MemberFunction:
17190  // Nothing to do.
17191  break;
17192 
17193  case FK_FunctionPointer:
17194  DestType = S.Context.getPointerType(DestType);
17195  break;
17196 
17197  case FK_BlockPointer:
17198  DestType = S.Context.getBlockPointerType(DestType);
17199  break;
17200  }
17201 
17202  // Finally, we can recurse.
17203  ExprResult CalleeResult = Visit(CalleeExpr);
17204  if (!CalleeResult.isUsable()) return ExprError();
17205  E->setCallee(CalleeResult.get());
17206 
17207  // Bind a temporary if necessary.
17208  return S.MaybeBindToTemporary(E);
17209 }
17210 
17211 ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) {
17212  // Verify that this is a legal result type of a call.
17213  if (DestType->isArrayType() || DestType->isFunctionType()) {
17214  S.Diag(E->getExprLoc(), diag::err_func_returning_array_function)
17215  << DestType->isFunctionType() << DestType;
17216  return ExprError();
17217  }
17218 
17219  // Rewrite the method result type if available.
17220  if (ObjCMethodDecl *Method = E->getMethodDecl()) {
17221  assert(Method->getReturnType() == S.Context.UnknownAnyTy);
17222  Method->setReturnType(DestType);
17223  }
17224 
17225  // Change the type of the message.
17226  E->setType(DestType.getNonReferenceType());
17228 
17229  return S.MaybeBindToTemporary(E);
17230 }
17231 
17232 ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
17233  // The only case we should ever see here is a function-to-pointer decay.
17234  if (E->getCastKind() == CK_FunctionToPointerDecay) {
17235  assert(E->getValueKind() == VK_RValue);
17236  assert(E->getObjectKind() == OK_Ordinary);
17237 
17238  E->setType(DestType);
17239 
17240  // Rebuild the sub-expression as the pointee (function) type.
17241  DestType = DestType->castAs<PointerType>()->getPointeeType();
17242 
17243  ExprResult Result = Visit(E->getSubExpr());
17244  if (!Result.isUsable()) return ExprError();
17245 
17246  E->setSubExpr(Result.get());
17247  return E;
17248  } else if (E->getCastKind() == CK_LValueToRValue) {
17249  assert(E->getValueKind() == VK_RValue);
17250  assert(E->getObjectKind() == OK_Ordinary);
17251 
17252  assert(isa<BlockPointerType>(E->getType()));
17253 
17254  E->setType(DestType);
17255 
17256  // The sub-expression has to be a lvalue reference, so rebuild it as such.
17257  DestType = S.Context.getLValueReferenceType(DestType);
17258 
17259  ExprResult Result = Visit(E->getSubExpr());
17260  if (!Result.isUsable()) return ExprError();
17261 
17262  E->setSubExpr(Result.get());
17263  return E;
17264  } else {
17265  llvm_unreachable("Unhandled cast type!");
17266  }
17267 }
17268 
17269 ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
17270  ExprValueKind ValueKind = VK_LValue;
17271  QualType Type = DestType;
17272 
17273  // We know how to make this work for certain kinds of decls:
17274 
17275  // - functions
17276  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) {
17277  if (const PointerType *Ptr = Type->getAs<PointerType>()) {
17278  DestType = Ptr->getPointeeType();
17279  ExprResult Result = resolveDecl(E, VD);
17280  if (Result.isInvalid()) return ExprError();
17281  return S.ImpCastExprToType(Result.get(), Type,
17282  CK_FunctionToPointerDecay, VK_RValue);
17283  }
17284 
17285  if (!Type->isFunctionType()) {
17286  S.Diag(E->getExprLoc(), diag::err_unknown_any_function)
17287  << VD << E->getSourceRange();
17288  return ExprError();
17289  }
17290  if (const FunctionProtoType *FT = Type->getAs<FunctionProtoType>()) {
17291  // We must match the FunctionDecl's type to the hack introduced in
17292  // RebuildUnknownAnyExpr::VisitCallExpr to vararg functions of unknown
17293  // type. See the lengthy commentary in that routine.
17294  QualType FDT = FD->getType();
17295  const FunctionType *FnType = FDT->castAs<FunctionType>();
17296  const FunctionProtoType *Proto = dyn_cast_or_null<FunctionProtoType>(FnType);
17297  DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
17298  if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
17299  SourceLocation Loc = FD->getLocation();
17301  S.Context, FD->getDeclContext(), Loc, Loc,
17302  FD->getNameInfo().getName(), DestType, FD->getTypeSourceInfo(),
17303  SC_None, false /*isInlineSpecified*/, FD->hasPrototype(),
17304  /*ConstexprKind*/ CSK_unspecified);
17305 
17306  if (FD->getQualifier())
17307  NewFD->setQualifierInfo(FD->getQualifierLoc());
17308 
17310  for (const auto &AI : FT->param_types()) {
17311  ParmVarDecl *Param =
17312  S.BuildParmVarDeclForTypedef(FD, Loc, AI);
17313  Param->setScopeInfo(0, Params.size());
17314  Params.push_back(Param);
17315  }
17316  NewFD->setParams(Params);
17317  DRE->setDecl(NewFD);
17318  VD = DRE->getDecl();
17319  }
17320  }
17321 
17322  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
17323  if (MD->isInstance()) {
17324  ValueKind = VK_RValue;
17325  Type = S.Context.BoundMemberTy;
17326  }
17327 
17328  // Function references aren't l-values in C.
17329  if (!S.getLangOpts().CPlusPlus)
17330  ValueKind = VK_RValue;
17331 
17332  // - variables
17333  } else if (isa<VarDecl>(VD)) {
17334  if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) {
17335  Type = RefTy->getPointeeType();
17336  } else if (Type->isFunctionType()) {
17337  S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type)
17338  << VD << E->getSourceRange();
17339  return ExprError();
17340  }
17341 
17342  // - nothing else
17343  } else {
17344  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl)
17345  << VD << E->getSourceRange();
17346  return ExprError();
17347  }
17348 
17349  // Modifying the declaration like this is friendly to IR-gen but
17350  // also really dangerous.
17351  VD->setType(DestType);
17352  E->setType(Type);
17353  E->setValueKind(ValueKind);
17354  return E;
17355 }
17356 
17357 /// Check a cast of an unknown-any type. We intentionally only
17358 /// trigger this for C-style casts.
17361  ExprValueKind &VK, CXXCastPath &Path) {
17362  // The type we're casting to must be either void or complete.
17363  if (!CastType->isVoidType() &&
17364  RequireCompleteType(TypeRange.getBegin(), CastType,
17365  diag::err_typecheck_cast_to_incomplete))
17366  return ExprError();
17367 
17368  // Rewrite the casted expression from scratch.
17369  ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr);
17370  if (!result.isUsable()) return ExprError();
17371 
17372  CastExpr = result.get();
17373  VK = CastExpr->getValueKind();
17374  CastKind = CK_NoOp;
17375 
17376  return CastExpr;
17377 }
17378 
17380  return RebuildUnknownAnyExpr(*this, ToType).Visit(E);
17381 }
17382 
17384  Expr *arg, QualType &paramType) {
17385  // If the syntactic form of the argument is not an explicit cast of
17386  // any sort, just do default argument promotion.
17387  ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
17388  if (!castArg) {
17389  ExprResult result = DefaultArgumentPromotion(arg);
17390  if (result.isInvalid()) return ExprError();
17391  paramType = result.get()->getType();
17392  return result;
17393  }
17394 
17395  // Otherwise, use the type that was written in the explicit cast.
17396  assert(!arg->hasPlaceholderType());
17397  paramType = castArg->getTypeAsWritten();
17398 
17399  // Copy-initialize a parameter of that type.
17400  InitializedEntity entity =
17401  InitializedEntity::InitializeParameter(Context, paramType,
17402  /*consumed*/ false);
17403  return PerformCopyInitialization(entity, callLoc, arg);
17404 }
17405 
17407  Expr *orig = E;
17408  unsigned diagID = diag::err_uncasted_use_of_unknown_any;
17409  while (true) {
17410  E = E->IgnoreParenImpCasts();
17411  if (CallExpr *call = dyn_cast<CallExpr>(E)) {
17412  E = call->getCallee();
17413  diagID = diag::err_uncasted_call_of_unknown_any;
17414  } else {
17415  break;
17416  }
17417  }
17418 
17419  SourceLocation loc;
17420  NamedDecl *d;
17421  if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {
17422  loc = ref->getLocation();
17423  d = ref->getDecl();
17424  } else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
17425  loc = mem->getMemberLoc();
17426  d = mem->getMemberDecl();
17427  } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) {
17428  diagID = diag::err_uncasted_call_of_unknown_any;
17429  loc = msg->getSelectorStartLoc();
17430  d = msg->getMethodDecl();
17431  if (!d) {
17432  S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
17433  << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
17434  << orig->getSourceRange();
17435  return ExprError();
17436  }
17437  } else {
17438  S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
17439  << E->getSourceRange();
17440  return ExprError();
17441  }
17442 
17443  S.Diag(loc, diagID) << d << orig->getSourceRange();
17444 
17445  // Never recoverable.
17446  return ExprError();
17447 }
17448 
17449 /// Check for operands with placeholder types and complain if found.
17450 /// Returns ExprError() if there was an error and no recovery was possible.
17452  if (!getLangOpts().CPlusPlus) {
17453  // C cannot handle TypoExpr nodes on either side of a binop because it
17454  // doesn't handle dependent types properly, so make sure any TypoExprs have
17455  // been dealt with before checking the operands.
17456  ExprResult Result = CorrectDelayedTyposInExpr(E);
17457  if (!Result.isUsable()) return ExprError();
17458  E = Result.get();
17459  }
17460 
17461  const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType();
17462  if (!placeholderType) return E;
17463 
17464  switch (placeholderType->getKind()) {
17465 
17466  // Overloaded expressions.
17467  case BuiltinType::Overload: {
17468  // Try to resolve a single function template specialization.
17469  // This is obligatory.
17470  ExprResult Result = E;
17471  if (ResolveAndFixSingleFunctionTemplateSpecialization(Result, false))
17472  return Result;
17473 
17474  // No guarantees that ResolveAndFixSingleFunctionTemplateSpecialization
17475  // leaves Result unchanged on failure.
17476  Result = E;
17477  if (resolveAndFixAddressOfOnlyViableOverloadCandidate(Result))
17478  return Result;
17479 
17480  // If that failed, try to recover with a call.
17481  tryToRecoverWithCall(Result, PDiag(diag::err_ovl_unresolvable),
17482  /*complain*/ true);
17483  return Result;
17484  }
17485 
17486  // Bound member functions.
17487  case BuiltinType::BoundMember: {
17488  ExprResult result = E;
17489  const Expr *BME = E->IgnoreParens();
17490  PartialDiagnostic PD = PDiag(diag::err_bound_member_function);
17491  // Try to give a nicer diagnostic if it is a bound member that we recognize.
17492  if (isa<CXXPseudoDestructorExpr>(BME)) {
17493  PD = PDiag(diag::err_dtor_expr_without_call) << /*pseudo-destructor*/ 1;
17494  } else if (const auto *ME = dyn_cast<MemberExpr>(BME)) {
17495  if (ME->getMemberNameInfo().getName().getNameKind() ==
17497  PD = PDiag(diag::err_dtor_expr_without_call) << /*destructor*/ 0;
17498  }
17499  tryToRecoverWithCall(result, PD,
17500  /*complain*/ true);
17501  return result;
17502  }
17503 
17504  // ARC unbridged casts.
17505  case BuiltinType::ARCUnbridgedCast: {
17506  Expr *realCast = stripARCUnbridgedCast(E);
17507  diagnoseARCUnbridgedCast(realCast);
17508  return realCast;
17509  }
17510 
17511  // Expressions of unknown type.
17512  case BuiltinType::UnknownAny:
17513  return diagnoseUnknownAnyExpr(*this, E);
17514 
17515  // Pseudo-objects.
17516  case BuiltinType::PseudoObject:
17517  return checkPseudoObjectRValue(E);
17518 
17519  case BuiltinType::BuiltinFn: {
17520  // Accept __noop without parens by implicitly converting it to a call expr.
17521  auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts());
17522  if (DRE) {
17523  auto *FD = cast<FunctionDecl>(DRE->getDecl());
17524  if (FD->getBuiltinID() == Builtin::BI__noop) {
17525  E = ImpCastExprToType(E, Context.getPointerType(FD->getType()),
17526  CK_BuiltinFnToFnPtr)
17527  .get();
17528  return CallExpr::Create(Context, E, /*Args=*/{}, Context.IntTy,
17530  }
17531  }
17532 
17533  Diag(E->getBeginLoc(), diag::err_builtin_fn_use);
17534  return ExprError();
17535  }
17536 
17537  // Expressions of unknown type.
17538  case BuiltinType::OMPArraySection:
17539  Diag(E->getBeginLoc(), diag::err_omp_array_section_use);
17540  return ExprError();
17541 
17542  // Everything else should be impossible.
17543 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
17544  case BuiltinType::Id:
17545 #include "clang/Basic/OpenCLImageTypes.def"
17546 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
17547  case BuiltinType::Id:
17548 #include "clang/Basic/OpenCLExtensionTypes.def"
17549 #define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
17550 #define PLACEHOLDER_TYPE(Id, SingletonId)
17551 #include "clang/AST/BuiltinTypes.def"
17552  break;
17553  }
17554 
17555  llvm_unreachable("invalid placeholder type!");
17556 }
17557 
17559  if (E->isTypeDependent())
17560  return true;
17561  if (E->isValueDependent() || E->isIntegerConstantExpr(Context))
17562  return E->getType()->isIntegralOrEnumerationType();
17563  return false;
17564 }
17565 
17566 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
17567 ExprResult
17569  assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) &&
17570  "Unknown Objective-C Boolean value!");
17571  QualType BoolT = Context.ObjCBuiltinBoolTy;
17572  if (!Context.getBOOLDecl()) {
17573  LookupResult Result(*this, &Context.Idents.get("BOOL"), OpLoc,
17575  if (LookupName(Result, getCurScope()) && Result.isSingleResult()) {
17576  NamedDecl *ND = Result.getFoundDecl();
17577  if (TypedefDecl *TD = dyn_cast<TypedefDecl>(ND))
17578  Context.setBOOLDecl(TD);
17579  }
17580  }
17581  if (Context.getBOOLDecl())
17582  BoolT = Context.getBOOLType();
17583  return new (Context)
17584  ObjCBoolLiteralExpr(Kind == tok::kw___objc_yes, BoolT, OpLoc);
17585 }
17586 
17589  SourceLocation RParen) {
17590 
17591  StringRef Platform = getASTContext().getTargetInfo().getPlatformName();
17592 
17593  auto Spec = llvm::find_if(AvailSpecs, [&](const AvailabilitySpec &Spec) {
17594  return Spec.getPlatform() == Platform;
17595  });
17596 
17597  VersionTuple Version;
17598  if (Spec != AvailSpecs.end())
17599  Version = Spec->getVersion();
17600 
17601  // The use of `@available` in the enclosing function should be analyzed to
17602  // warn when it's used inappropriately (i.e. not if(@available)).
17603  if (getCurFunctionOrMethodDecl())
17604  getEnclosingFunction()->HasPotentialAvailabilityViolations = true;
17605  else if (getCurBlock() || getCurLambda())
17606  getCurFunction()->HasPotentialAvailabilityViolations = true;
17607 
17608  return new (Context)
17609  ObjCAvailabilityCheckExpr(Version, AtLoc, RParen, Context.BoolTy);
17610 }
Abstract class used to diagnose incomplete types.
Definition: Sema.h:1595
static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, Expr *Pointer)
Diagnose invalid arithmetic on a function pointer.
Definition: SemaExpr.cpp:9205
void setTypoName(IdentifierInfo *II)
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:77
ObjCMethodDecl * LookupMethodInQualifiedType(Selector Sel, const ObjCObjectPointerType *OPT, bool IsInstance)
LookupMethodInQualifiedType - Lookups up a method in protocol qualifier list of a qualified objective...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1553
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison operators are mixed in a way t...
Definition: SemaExpr.cpp:12729
Defines the clang::ASTContext interface.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
const BlockDecl * getBlockDecl() const
Definition: Expr.h:5555
bool hasDefinition() const
Determine whether this class has been defined.
Definition: DeclObjC.h:1534
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
Definition: Type.cpp:2273
void MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables=false)
Mark any declarations that appear within this expression or any potentially-evaluated subexpressions ...
Definition: SemaExpr.cpp:16664
VariadicCallType
Definition: Sema.h:9812
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1597
QualType getCurrentThisType()
Try to retrieve the type of the &#39;this&#39; pointer.
QualType withConst() const
Retrieves a version of this type with const applied.
ConditionResult ActOnCondition(Scope *S, SourceLocation Loc, Expr *SubExpr, ConditionKind CK)
Definition: SemaExpr.cpp:16893
const CXXDestructorDecl * getDestructor() const
Definition: ExprCXX.h:1261
bool isClassMethod() const
Definition: DeclObjC.h:429
static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T)
Definition: SemaExpr.cpp:13085
CanQualType LongLongTy
Definition: ASTContext.h:1023
bool RequireNonAbstractType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
bool mightBeUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable&#39;s value might be usable in a constant expression, according to the re...
Definition: Decl.cpp:2248
Represents a function declaration or definition.
Definition: Decl.h:1748
static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI, VarDecl *Var, bool &SubCapturesAreNested, QualType &CaptureType, QualType &DeclRefType)
Definition: SemaExpr.cpp:15297
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
Definition: Type.cpp:1653
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition: Type.h:6690
Expr ** getArgs()
Retrieve the call arguments.
Definition: Expr.h:2663
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=CSK_unspecified)
Definition: Decl.h:1895
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr)
Definition: SemaExpr.cpp:6518
bool isForRedeclaration() const
True if this lookup is just looking for an existing declaration.
Definition: Lookup.h:258
SourceRange getCorrectionRange() const
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc", where we know the signature a priori.
Definition: Builtins.h:140
IncompatibleNestedPointerAddressSpaceMismatch - The assignment changes address spaces in nested point...
Definition: Sema.h:9911
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
Definition: TargetInfo.h:787
bool isSignedOverflowDefined() const
Definition: LangOptions.h:272
CanQualType AccumTy
Definition: ASTContext.h:1027
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
void setKind(UnqualifiedIdKind kind)
Definition: DeclSpec.h:1027
Smart pointer class that efficiently represents Objective-C method names.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1854
ExprResult CheckLValueToRValueConversionOperand(Expr *E)
Definition: SemaExpr.cpp:16220
A class which contains all the information about a particular captured value.
Definition: Decl.h:3921
PtrTy get() const
Definition: Ownership.h:80
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
Definition: SemaExpr.cpp:14715
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2569
EvaluatedExprVisitor - This class visits &#39;Expr *&#39;s.
QualType getPointeeType() const
Definition: Type.h:2582
bool CheckLoopHintExpr(Expr *E, SourceLocation Loc)
Definition: SemaExpr.cpp:3347
A (possibly-)qualified type.
Definition: Type.h:643
int getIntegerTypeOrder(QualType LHS, QualType RHS) const
Return the highest ranked integer type, see C99 6.3.1.8p1.
bool isBlockPointerType() const
Definition: Type.h:6392
static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Checks compatibility between two pointers and return the resulting type.
Definition: SemaExpr.cpp:6789
Simple class containing the result of Sema::CorrectTypo.
QualType CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType)
Definition: SemaExpr.cpp:11548
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2132
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
Definition: Type.h:6279
bool isArrayType() const
Definition: Type.h:6440
SourceRange getExprRange(Expr *E) const
Definition: SemaExpr.cpp:431
bool isMemberPointerType() const
Definition: Type.h:6422
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2890
ImplicitConversionKind
ImplicitConversionKind - The kind of implicit conversion used to convert an argument to a parameter&#39;s...
Definition: Overload.h:78
static bool checkBlockType(Sema &S, const Expr *E)
Return true if the Expr is block type.
Definition: SemaExpr.cpp:7182
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition: Decl.h:2403
unsigned char getFixedPointScale(QualType Ty) const
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2673
bool hasCaptures() const
True if this block (or its nested blocks) captures anything of local storage from its enclosing scope...
Definition: Decl.h:4034
static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr, SourceLocation OpLoc, bool IsBuiltin)
DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
Definition: SemaExpr.cpp:12296
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1143
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2979
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:227
static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS)
Diagnose invalid arithmetic on two function pointers.
Definition: SemaExpr.cpp:9189
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
Definition: ASTContext.h:1909
ExprResult ActOnConditionalOp(SourceLocation QuestionLoc, SourceLocation ColonLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr)
ActOnConditionalOp - Parse a ?: operation.
Definition: SemaExpr.cpp:7647
unsigned getLongWidth() const
getLongWidth/Align - Return the size of &#39;signed long&#39; and &#39;unsigned long&#39; for this target...
Definition: TargetInfo.h:398
DeclContext * getFunctionLevelDeclContext()
Definition: Sema.cpp:1219
ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val)
Definition: SemaExpr.cpp:3309
llvm::APSInt EvaluateKnownConstIntCheckOverflow(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, ExprResult &IntExpr, QualType FloatTy, QualType IntTy, bool ConvertFloat, bool ConvertInt)
Handle arithmetic conversion from integer to float.
Definition: SemaExpr.cpp:1028
llvm::APSInt getValue() const
Definition: FixedPoint.h:110
static bool breakDownVectorType(QualType type, uint64_t &len, QualType &eltType)
Definition: SemaExpr.cpp:6369
CanQualType FractTy
Definition: ASTContext.h:1030
bool isCForbiddenLValueType() const
Determine whether expressions of the given type are forbidden from being lvalues in C...
Definition: Type.h:6340
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3224
ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)
Definition: SemaExpr.cpp:6691
CanQualType Char32Ty
Definition: ASTContext.h:1022
static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, QualType PointerTy)
Return false if the NullExpr can be promoted to PointerTy, true otherwise.
Definition: SemaExpr.cpp:6776
static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E)
Definition: SemaExpr.cpp:17406
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:248
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
SourceLocation TemplateNameLoc
TemplateNameLoc - The location of the template name within the source.
static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source, SmallString< 32 > &Target)
Definition: SemaExpr.cpp:3172
Cannot tell whether this is a narrowing conversion because the expression is value-dependent.
Definition: Overload.h:218
bool isArithmeticType() const
Definition: Type.cpp:1983
Stmt - This represents one statement.
Definition: Stmt.h:66
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2660
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Definition: ASTLambda.h:38
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:314
Kind getKind() const
Definition: Type.h:2450
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3387
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:985
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1968
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:658
ObjCMethodDecl * LookupMethodInObjectType(Selector Sel, QualType Ty, bool IsInstance)
LookupMethodInType - Look up a method in an ObjCObjectType.
bool isVLATypeCaptured(const VariableArrayType *VAT) const
Determine whether the given variable-array type has been captured.
Definition: ScopeInfo.cpp:225
static bool IsReadonlyMessage(Expr *E, Sema &S)
Definition: SemaExpr.cpp:11114
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:481
ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:4306
Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier.
Definition: Decl.h:3051
Defines the SourceManager interface.
bool tryToFixConversion(const Expr *FromExpr, const QualType FromQTy, const QualType ToQTy, Sema &S)
If possible, generates and stores a fix for the given conversion.
void addConst()
Add the const type qualifier to this QualType.
Definition: Type.h:812
ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating the default expr if needed...
Definition: SemaExpr.cpp:4894
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2108
Complex conversions (C99 6.3.1.6)
Definition: Overload.h:113
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:86
static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, BinaryOperator::Opcode Opc)
Definition: SemaExpr.cpp:10041
bool isAscii() const
Definition: Expr.h:1800
bool isRecordType() const
Definition: Type.h:6464
QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
Definition: SemaExpr.cpp:8600
Expr * getBase() const
Definition: Expr.h:2884
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr, SourceLocation Loc, Sema &Sema)
Definition: SemaExpr.cpp:11503
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition: Type.h:6630
static InitializedEntity InitializeParameter(ASTContext &Context, const ParmVarDecl *Parm)
Create the initialization entity for a parameter.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1938
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
const Type * getTypeForDecl() const
Definition: Decl.h:2931
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1362
QualType CheckRemainderOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign=false)
Definition: SemaExpr.cpp:9130
QualType getCaptureType() const
Retrieve the capture type for this capture, which is effectively the type of the non-static data memb...
Definition: ScopeInfo.h:624
bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, SourceLocation QuestionLoc)
Emit a specialized diagnostic when one expression is a null pointer constant and the other is not a p...
Definition: SemaExpr.cpp:6700
void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, Scope *CurScope)
ActOnBlockArguments - This callback allows processing of block arguments.
Definition: SemaExpr.cpp:13755
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD, const RecordType *Ty, SourceLocation Loc, SourceRange Range, OriginalExprKind OEK, bool &DiagnosticEmitted)
Definition: SemaExpr.cpp:11311
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4035
StringRef getPlatform() const
Definition: Availability.h:52
bool isVirtual() const
Definition: DeclCXX.h:2157
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:2124
bool isExtVectorType() const
Definition: Type.h:6480
void setType(QualType t)
Definition: Expr.h:138
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed...
Definition: Sema.h:7947
AssignConvertType
AssignConvertType - All of the &#39;assignment&#39; semantic checks return this enum to indicate whether the ...
Definition: Sema.h:9872
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2943
static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E)
Definition: SemaExpr.cpp:11128
Defines the C++ template declaration subclasses.
Opcode getOpcode() const
Definition: Expr.h:3440
This is a while, do, switch, for, etc that can have break statements embedded into it...
Definition: Scope.h:51
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:877
static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, Expr *PointerExpr, SourceLocation Loc, bool IsIntFirstExpr)
Return false if the first expression is not an integer and the second expression is not a pointer...
Definition: SemaExpr.cpp:6983
void setNumArgsUnsafe(unsigned NewNumArgs)
Bluntly set a new number of arguments without doing any checks whatsoever.
Definition: Expr.h:2703
Not a narrowing conversion.
Definition: Overload.h:204
static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange, UnaryExprOrTypeTrait TraitKind)
Definition: SemaExpr.cpp:3765
ExprResult DefaultArgumentPromotion(Expr *E)
DefaultArgumentPromotion (C99 6.5.2.2p6).
Definition: SemaExpr.cpp:738
bool isCopyCapture() const
Definition: ScopeInfo.h:583
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1964
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6333
bool CheckVecStepExpr(Expr *E)
Definition: SemaExpr.cpp:4005
ExprResult forceUnknownAnyToType(Expr *E, QualType ToType)
Force an expression with unknown-type to an expression of the given type.
Definition: SemaExpr.cpp:17379
ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc)
Definition: SemaExpr.cpp:4579
CanQualType ARCUnbridgedCastTy
Definition: ASTContext.h:1045
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
Definition: Decl.h:2796
ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty, SourceLocation RPLoc)
Definition: SemaExpr.cpp:14069
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
The base class of the type hierarchy.
Definition: Type.h:1433
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CanQualType LongTy
Definition: ASTContext.h:1023
QualType CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, bool IsCompAssign=false)
Definition: SemaExpr.cpp:9800
bool isClkEventT() const
Definition: Type.h:6557
QualType CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, QualType *CompLHSTy=nullptr)
Definition: SemaExpr.cpp:9512
QualType getCorrespondingSignedFixedPointType(QualType Ty) const
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclSpec.h:1900
bool isDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is derived from the class Base.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2844
Declaration of a variable template.
QualType getCorrespondingUnsignedType(QualType T) const
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:63
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:47
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1331
SourceLocation getEndLoc() const LLVM_READONLY
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Definition: Expr.h:404
bool allowsPointerArithmetic() const
Does this runtime allow pointer arithmetic on objects?
Definition: ObjCRuntime.h:323
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:115
QualType withConst() const
Definition: Type.h:815
static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
Returns false if the pointers are converted to a composite type, true otherwise.
Definition: SemaExpr.cpp:9899
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
Definition: Type.h:3653
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:693
TemplateNameKind Kind
The kind of template that Template refers to.
QualType adjustStringLiteralBaseType(QualType StrLTy) const
A container of type source information.
Definition: Decl.h:86
QualType getCallResultType() const
Determine the type of an expression that calls this function.
Definition: Decl.h:2359
static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmetic conversion with complex types.
Definition: SemaExpr.cpp:972
QualType getLogicalOperationType() const
The result type of logical operations, &#39;<&#39;, &#39;>&#39;, &#39;!=&#39;, etc.
Definition: ASTContext.h:1790
Floating point control options.
Definition: LangOptions.h:307
constexpr XRayInstrMask Function
Definition: XRayInstr.h:38
MS property subscript expression.
Definition: ExprCXX.h:846
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:2797
QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Definition: SemaExpr.cpp:10966
static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S)
CheckForModifiableLvalue - Verify that E is a modifiable lvalue.
Definition: SemaExpr.cpp:11375
Wrapper for source info for pointers decayed from arrays and functions.
Definition: TypeLoc.h:1198
bool isImplicitlyInstantiable() const
Determines whether this function is a function template specialization or a member of a class templat...
Definition: Decl.cpp:3454
Abstract base class used for diagnosing integer constant expression violations.
Definition: Sema.h:10341
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy, SourceLocation QuestionLoc)
Return false if the vector condition type and the vector result type are compatible.
Definition: SemaExpr.cpp:7122
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2574
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:554
bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param)
Instantiate or parse a C++ default argument expression as necessary.
Definition: SemaExpr.cpp:4771
CanQualType WideCharTy
Definition: ASTContext.h:1018
static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn, FunctionDecl *FDecl, ArrayRef< Expr *> Args)
Definition: SemaExpr.cpp:4946
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:15013
size_t param_size() const
Definition: Decl.h:2305
bool isQualifiedMemberAccess(Expr *E)
Determine whether the given expression is a qualified member access expression, of a form that could ...
Definition: SemaExpr.cpp:13320
void InstantiateVariableDefinition(SourceLocation PointOfInstantiation, VarDecl *Var, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given variable from its template.
isModifiableLvalueResult
Definition: Expr.h:278
CanQualType HalfTy
Definition: ASTContext.h:1038
ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc)
Definition: SemaExpr.cpp:14190
This name appears in an unevaluated operand.
Definition: Specifiers.h:163
QualType getElementType() const
Definition: Type.h:2879
static InitializedEntity InitializeTemporary(QualType Type)
Create the initialization entity for a temporary.
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:540
ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, TypeSourceInfo *TInfo, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
__builtin_offsetof(type, a.b[123][456].c)
Definition: SemaExpr.cpp:13501
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:97
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1915
This file provides some common utility functions for processing Lambda related AST Constructs...
bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, CastKind &Kind)
Definition: SemaExpr.cpp:6430
static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS)
Definition: SemaExpr.cpp:9953
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:574
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprCXX.cpp:510
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R, bool HasTrailingLParen)
Definition: SemaExpr.cpp:2803
RAII object that enters a new expression evaluation context.
Definition: Sema.h:11259
Represents a variable declaration or definition.
Definition: Decl.h:812
static bool funcHasParameterSizeMangling(Sema &S, FunctionDecl *FD)
Return true if this function has a calling convention that requires mangling in the size of the param...
Definition: SemaExpr.cpp:14885
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
ExpressionKind
Describes whether we are in an expression constext which we have to handle differently.
Definition: Sema.h:1061
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:243
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1775
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC &#39;id&#39; type.
Definition: ExprObjC.h:1492
void removeObjCLifetime()
Definition: Type.h:333
QualType getReturnType() const
Definition: Decl.h:2329
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3048
bool isParamConsumed(unsigned I) const
Definition: Type.h:4125
static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
Definition: SemaExpr.cpp:9930
unsigned getNumParams() const
Definition: Type.h:3921
bool isEnumeralType() const
Definition: Type.h:6468
void setCXXLiteralOperatorNameLoc(SourceLocation Loc)
setCXXLiteralOperatorNameLoc - Sets the location of the literal operator name (not the operator keywo...
APFixedPoint getFixedPointMax(QualType Ty) const
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6851
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
Definition: Type.h:6773
CanQualType Float128Ty
Definition: ASTContext.h:1026
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Extra information about a function prototype.
Definition: Type.h:3799
CanQualType ShortAccumTy
Definition: ASTContext.h:1027
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:25
static bool canConvertIntToOtherIntTy(Sema &S, ExprResult *Int, QualType OtherIntTy)
Test if a (constant) integer Int can be casted to another integer type IntTy without losing precision...
Definition: SemaExpr.cpp:8702
Represents a variable template specialization, which refers to a variable template with a given set o...
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:431
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1184
bool isAmbiguous() const
Definition: Lookup.h:301
NestedNameSpecifier * getCorrectionSpecifier() const
Gets the NestedNameSpecifier needed to use the typo correction.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
DeclClass * getCorrectionDeclAs() const
static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS)
If two different enums are compared, raise a warning.
Definition: SemaExpr.cpp:9859
static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr, ExprResult &ComplexExpr, QualType IntTy, QualType ComplexTy, bool SkipCast)
Converts an integer to complex float type.
Definition: SemaExpr.cpp:950
void ActOnStartStmtExpr()
Definition: SemaExpr.cpp:13419
bool isInvalidDecl() const
Definition: DeclBase.h:553
bool isOverloaded() const
const Expr * getExprStmt() const
Definition: Stmt.cpp:323
static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind)
Definition: SemaExpr.cpp:3948
static ObjCPropertyDecl * findPropertyDecl(const DeclContext *DC, const IdentifierInfo *propertyID, ObjCPropertyQueryKind queryKind)
Lookup a property by name in the specified DeclContext.
Definition: DeclObjC.cpp:176
static InitializationKind CreateDirectList(SourceLocation InitLoc)
CanQualType ShortFractTy
Definition: ASTContext.h:1030
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input)
Definition: SemaExpr.cpp:13357
CharSourceRange getSourceRange(const SourceRange &Range)
Returns the token CharSourceRange corresponding to Range.
Definition: FixIt.h:32
bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind, SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt)
Try to capture the given variable.
Definition: SemaExpr.cpp:15635
static void DiagnoseConstAssignment(Sema &S, const Expr *E, SourceLocation Loc)
Emit the "read-only variable not assignable" error and print notes to give more information about why...
Definition: SemaExpr.cpp:11186
std::vector< FixItHint > Hints
The list of Hints generated so far.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:686
Represents a parameter to a function.
Definition: Decl.h:1564
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind, SourceLocation Loc)
Lookup the specified comparison category types in the standard library, an check the VarDecls possibl...
Defines the clang::Expr interface and subclasses for C++ expressions.
long i
Definition: xmmintrin.h:1456
tok::TokenKind getKind() const
Definition: Token.h:92
bool isAdditiveOp() const
Definition: Expr.h:3482
bool isEqualityOp() const
Definition: Expr.h:3493
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
Definition: ScopeInfo.h:668
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1987
static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Emit error when two pointers are incompatible.
Definition: SemaExpr.cpp:9408
The collection of all-type qualifiers we support.
Definition: Type.h:137
bool isVariableArrayType() const
Definition: Type.h:6452
tok::TokenKind ContextKind
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g., it is a floating-point type or a vector thereof.
Definition: Type.cpp:1961
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable.
Definition: Decl.h:1364
bool isXValue() const
Definition: Expr.h:260
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:3285
void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T)
Mark all of the declarations referenced within a particular AST node as referenced.
Definition: SemaExpr.cpp:16587
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
static Sema::AssignConvertType checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
checkObjCPointerTypesForAssignment - Compares two objective-c pointer types for assignment compatibil...
Definition: SemaExpr.cpp:7945
Represents a struct/union/class.
Definition: Decl.h:3626
static QualType OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType CondTy, SourceLocation QuestionLoc)
Convert scalar operands to a vector that matches the condition in length.
Definition: SemaExpr.cpp:7068
A semantic tree transformation that allows one to transform one abstract syntax tree into another...
Definition: TreeTransform.h:95
QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
FindCompositeObjCPointerType - Helper method to find composite type of two objective-c pointer types ...
Definition: SemaExpr.cpp:7332
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:358
bool isOrdinaryOrBitFieldObject() const
Definition: Expr.h:425
TemplateIdAnnotation * TemplateId
When Kind == IK_TemplateId or IK_ConstructorTemplateId, the template-id annotation that contains the ...
Definition: DeclSpec.h:996
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6...
Definition: SemaExpr.cpp:689
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Kind, Expr *Input)
Definition: SemaExpr.cpp:4264
ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind, SourceLocation BuiltinLoc, SourceLocation RPLoc, DeclContext *ParentContext)
Definition: SemaExpr.cpp:14214
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1152
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition: Decl.h:370
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3800
One of these records is kept for each identifier that is lexed.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:909
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1054
static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle conversions with GCC complex int extension.
Definition: SemaExpr.cpp:1204
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations. ...
Definition: Decl.cpp:1851
static bool needsConversionOfHalfVec(bool OpRequiresConversion, ASTContext &Ctx, QualType SrcType)
Returns true if conversion between vectors of halfs and vectors of floats is needed.
Definition: SemaExpr.cpp:12442
void DiagnoseUnusedExprResult(const Stmt *S)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused...
Definition: SemaStmt.cpp:199
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(), or __builtin_FILE().
Definition: Expr.h:4263
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Represents a class type in Objective C.
Definition: Type.h:5608
A vector component is an element or range of elements on a vector.
Definition: Specifiers.h:146
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:329
static void DiagnoseConditionalPrecedence(Sema &Self, SourceLocation OpLoc, Expr *Condition, Expr *LHSExpr, Expr *RHSExpr)
DiagnoseConditionalPrecedence - Emit a warning when a conditional operator and binary operator are mi...
Definition: SemaExpr.cpp:7565
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
A C++ nested-name-specifier augmented with source location information.
DeclarationName getCorrection() const
Gets the DeclarationName of the typo correction.
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7818
ExprResult ExprEmpty()
Definition: Ownership.h:285
static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, Expr *Operand)
Check the validity of an arithmetic pointer operand.
Definition: SemaExpr.cpp:9240
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3928
LineState State
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:4004
LValueClassification ClassifyLValue(ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.h:2493
ObjCMethodFamily
A family of Objective-C methods.
Used for GCC&#39;s __alignof.
Definition: TypeTraits.h:106
FullExpr - Represents a "full-expression" node.
Definition: Expr.h:920
static bool anyDependentTemplateArguments(ArrayRef< TemplateArgumentLoc > Args, bool &InstantiationDependent)
Determine whether any of the given template arguments are dependent.
Definition: Type.cpp:3356
static FunctionDecl * rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context, FunctionDecl *FDecl, MultiExprArg ArgExprs)
If a builtin function has a pointer argument with no explicit address space, then it should be able t...
Definition: SemaExpr.cpp:5362
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
static Sema::AssignConvertType checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
Definition: SemaExpr.cpp:7756
bool isCharType() const
Definition: Type.cpp:1818
field_range fields() const
Definition: Decl.h:3841
TypeSourceInfo * getTypeSourceInfo(ASTContext &Context, QualType T)
Creates a TypeSourceInfo for the given type.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:263
NameKind getNameKind() const
Determine what kind of name this is.
bool isObjCIdType() const
Definition: Type.h:6517
Represents a member of a struct/union/class.
Definition: Decl.h:2607
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec)
We&#39;ve found a use of a templated declaration that would trigger an implicit instantiation.
The current expression is potentially evaluated at run time, which means that code may be generated t...
void setBOOLDecl(TypedefDecl *TD)
Save declaration of &#39;BOOL&#39; typedef.
Definition: ASTContext.h:1890
Identity conversion (no conversion)
Definition: Overload.h:80
Stmt * getStmtExprResult()
Definition: Stmt.h:1402
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
Definition: TypeTraits.h:96
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:233
CanQualType LongAccumTy
Definition: ASTContext.h:1027
Floating point conversions (C++ [conv.double].
Definition: Overload.h:110
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:4178
bool isReferenceType() const
Definition: Type.h:6396
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: Expr.h:2683
void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE)
Redundant parentheses over an equality comparison can indicate that the user intended an assignment u...
Definition: SemaExpr.cpp:16835
static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, SourceLocation AssignLoc, const Expr *RHS)
Definition: SemaExpr.cpp:497
void shrinkNumArgs(unsigned NewNumArgs)
Reduce the number of arguments in this call expression.
Definition: Expr.h:2694
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
Definition: DeclBase.h:855
CompatiblePointerDiscardsQualifiers - The assignment discards c/v/r qualifiers, which we accept as an...
Definition: Sema.h:9900
static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Diagnose invalid arithmetic on two void pointers.
Definition: SemaExpr.cpp:9155
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6610
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1903
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3677
bool isNull() const
Definition: Diagnostic.h:86
void setKind(tok::TokenKind K)
Definition: Token.h:93
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5480
ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind)
ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
Definition: SemaExpr.cpp:17568
LookupResultKind getResultKind() const
Definition: Lookup.h:321
Expr * getSubExpr()
Definition: Expr.h:3173
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:738
QualType CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc)
Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
Definition: SemaExpr.cpp:7196
bool isObjCQualifiedClassType() const
Definition: Type.h:6511
enum clang::Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
Definition: SemaExpr.cpp:440
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:14778
bool isAtLeastAsQualifiedAs(QualType Other) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Definition: Type.h:6314
bool isAssignmentOp() const
Definition: Expr.h:3534
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6747
No entity found met the criteria within the current instantiation,, but there were dependent base cla...
Definition: Lookup.h:55
IdentifierTable & Idents
Definition: ASTContext.h:569
void NoteDeletedFunction(FunctionDecl *FD)
Emit a note explaining that this function is deleted.
Definition: SemaExpr.cpp:99
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:124
bool isInvalidType() const
Definition: DeclSpec.h:2453
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type, bool NRVO)
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2289
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...
Values of this type can be null.
bool isUnarySelector() const
CanQualType LongFractTy
Definition: ASTContext.h:1030
The controlling scope in a if/switch/while/for statement.
Definition: Scope.h:62
DeclClass * getAsSingle() const
Definition: Lookup.h:507
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2526
StringRef getOpcodeStr() const
Definition: Expr.h:3461
SourceLocation getOpLoc() const
Definition: ExprObjC.h:597
static unsigned GetFixedPointRank(QualType Ty)
Return the rank of a given fixed point or integer type.
Definition: SemaExpr.cpp:1250
static bool checkCondition(Sema &S, Expr *Cond, SourceLocation QuestionLoc)
Return false if the condition expression is valid, true otherwise.
Definition: SemaExpr.cpp:6739
bool isGLValue() const
Definition: Expr.h:261
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:985
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr *> Exprs, SourceLocation RParenLoc)
Create a paren list.
Definition: Expr.cpp:4311
Describes an C or C++ initializer list.
Definition: Expr.h:4371
void CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param, const Expr *ArgExpr)
CheckStaticArrayArgument - If the given argument corresponds to a static array parameter, check that it is non-null, and that if it is formed by array-to-pointer decay, the underlying array is sufficiently large.
Definition: SemaExpr.cpp:5228
static bool IsTypeModifiable(QualType Ty, bool IsDereference)
Definition: SemaExpr.cpp:11164
bool isArrow() const
Definition: ExprObjC.h:584
ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body, Scope *CurScope)
ActOnBlockStmtExpr - This is called when the body of a block statement literal was successfully compl...
Definition: SemaExpr.cpp:13884
bool isThisCapture() const
Definition: ScopeInfo.h:578
static bool CheckVecStepTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange)
Definition: SemaExpr.cpp:3717
BinaryOperatorKind
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:944
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
Definition: Expr.cpp:941
bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid)
Determine whether the use of this declaration is valid, without emitting diagnostics.
Definition: SemaExpr.cpp:53
static QualType checkArithmeticOrEnumeralThreeWayCompare(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Definition: SemaExpr.cpp:10331
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2685
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
Definition: Expr.h:567
unsigned getLength() const
Definition: Expr.h:1793
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:523
Represents the results of name lookup.
Definition: Lookup.h:46
static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Simple conversion between integer and floating point types.
Definition: SemaExpr.cpp:7013
PtrTy get() const
Definition: Ownership.h:170
ExprResult CallExprUnaryConversions(Expr *E)
CallExprUnaryConversions - a special case of an unary conversion performed on a function designator o...
Definition: SemaExpr.cpp:667
static bool canConvertIntTyToFloatTy(Sema &S, ExprResult *Int, QualType FloatTy)
Test if a (constant) integer Int can be casted to floating point type FloatTy without losing precisio...
Definition: SemaExpr.cpp:8740
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Definition: Expr.h:446
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2808
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2305
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME)
This is not an AltiVec-style cast or or C++ direct-initialization, so turn the ParenListExpr into a s...
Definition: SemaExpr.cpp:6675
static bool isVariableCapturable(CapturingScopeInfo *CSI, VarDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
Definition: SemaExpr.cpp:15343
void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockStart - This callback is invoked when a block literal is started.
Definition: SemaExpr.cpp:13727
QualType getOriginalType() const
Definition: Decl.cpp:2625
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1244
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:37
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Definition: SemaExpr.cpp:1771
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5542
APValue Val
Val - This is the value the expression can be folded to.
Definition: Expr.h:582
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
static void DiagnoseDivisionSizeofPointer(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc)
Definition: SemaExpr.cpp:9066
bool ValidateCandidate(const TypoCorrection &candidate) override
Simple predicate used by the default RankCandidate to determine whether to return an edit distance of...
const FormatToken & Tok
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprCXX.h:1309
bool hasAddressSpace() const
Definition: Type.h:352
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type...
Definition: Type.h:6902
AssignConvertType CheckAssignmentConstraints(SourceLocation Loc, QualType LHSType, QualType RHSType)
CheckAssignmentConstraints - Perform type checking for assignment, argument passing, variable initialization, and function return values.
Definition: SemaExpr.cpp:7979
This is a while, do, for, which can have continue statements embedded into it.
Definition: Scope.h:55
void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS)
Check for comparisons of floating point operands using != and ==.
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
Definition: Decl.h:2081
Whether values of this type can be null is (explicitly) unspecified.
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:133
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:414
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit=false, bool BuildAndDiagnose=true, const unsigned *const FunctionScopeIndexToStopAt=nullptr, bool ByCopy=false)
Make sure the value of &#39;this&#39; is actually available in the current context, if it is a potentially ev...
static void checkDirectCallValidity(Sema &S, const Expr *Fn, FunctionDecl *Callee, MultiExprArg ArgExprs)
Definition: SemaExpr.cpp:5435
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:2934
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base=nullptr)
Perform reference-marking and odr-use handling for a DeclRefExpr.
Definition: SemaExpr.cpp:16493
TemplateDecl * getAsTypeTemplateDecl(Decl *D)
static Expr * recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context, DeclarationNameInfo &NameInfo, SourceLocation TemplateKWLoc, const TemplateArgumentListInfo *TemplateArgs)
In Microsoft mode, if we are inside a template class whose parent class has dependent base classes...
Definition: SemaExpr.cpp:2128
QualType FunctionType
BlockType - The function type of the block, if one was given.
Definition: ScopeInfo.h:725
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2505
Represents a declaration of a type.
Definition: Decl.h:2907
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3405
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6212
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:752
CanQualType PseudoObjectTy
Definition: ASTContext.h:1045
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Definition: Type.h:6273
LangAS getAddressSpace() const
Definition: Type.h:353
static QualType checkConditionalBlockPointerCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both block pointers.
Definition: SemaExpr.cpp:6918
ImplicitConversionKind Second
Second - The second conversion can be an integral promotion, floating point promotion, integral conversion, floating point conversion, floating-integral conversion, pointer conversion, pointer-to-member conversion, or boolean conversion.
Definition: Overload.h:240
ExprResult ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef< AvailabilitySpec > AvailSpecs, SourceLocation AtLoc, SourceLocation RParen)
Definition: SemaExpr.cpp:17587
ParsedTemplateArgument * getTemplateArgs()
Retrieves a pointer to the template arguments.
void setTypoNNS(NestedNameSpecifier *NNS)
bool isArrow() const
Definition: Expr.h:2991
A narrowing conversion, because a constant expression got narrowed.
Definition: Overload.h:210
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
Definition: ASTContext.h:1654
CanQualType LongDoubleTy
Definition: ASTContext.h:1026
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2947
Values of this type can never be null.
QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc)
Given a variable, determine the type that a reference to that variable will have in the given scope...
Definition: SemaExpr.cpp:15858
DeclContext * getLambdaAwareParentOfDeclContext(DeclContext *DC)
Definition: ASTLambda.h:70
Expr * getSizeExpr() const
Definition: Type.h:3023
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
ExprResult Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType=nullptr)
Perform the actual initialization of the given entity based on the computed initialization sequence...
Definition: SemaInit.cpp:7379
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6142
TypedefDecl * getBOOLDecl() const
Retrieve declaration of &#39;BOOL&#39; typedef.
Definition: ASTContext.h:1885
static bool CheckExtensionTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange, UnaryExprOrTypeTrait TraitKind)
Definition: SemaExpr.cpp:3735
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:730
StringKind
StringLiteral is followed by several trailing objects.
Definition: Expr.h:1703
ExprResult BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef< Expr *> Arg, SourceLocation RParenLoc, Expr *Config=nullptr, bool IsExecConfig=false, ADLCallKind UsesADL=ADLCallKind::NotADL)
BuildResolvedCallExpr - Build a call to a resolved expression, i.e.
Definition: SemaExpr.cpp:5745
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1166
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1674
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:5926
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand, CorrectionCandidateCallback *CCC=nullptr, bool IsInlineAsmIdentifier=false, Token *KeywordReplacement=nullptr)
Definition: SemaExpr.cpp:2169
void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec)
Emit a warning for all pending noderef expressions that we recorded.
Definition: SemaExpr.cpp:14762
bool isInt() const
Definition: APValue.h:317
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Characters, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token...
Definition: Lexer.h:348
bool isRelationalOp() const
Definition: Expr.h:3490
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
static void captureVariablyModifiedType(ASTContext &Context, QualType T, CapturingScopeInfo *CSI)
Definition: SemaExpr.cpp:4015
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3121
static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, SourceLocation OpLoc)
CheckIndirectionOperand - Type check unary indirection (prefix &#39;*&#39;).
Definition: SemaExpr.cpp:12172
Helper class for OffsetOfExpr.
Definition: Expr.h:2133
The current expression occurs within a discarded statement.
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2063
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1282
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1301
bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const
Definition: Type.cpp:3907
static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc)
Returns true if we can take the address of the function.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1727
const LangOptions & getLangOpts() const
Definition: Sema.h:1285
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:919
bool isInstance() const
Definition: DeclCXX.h:2140
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:176
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
Definition: SemaExpr.cpp:655
bool isScalarType() const
Definition: Type.h:6732
ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope=nullptr)
Definition: SemaExpr.cpp:3375
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
Definition: SemaExpr.cpp:8401
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Definition: Type.h:508
An ordinary object is located at an address in memory.
Definition: Specifiers.h:140
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:27
MaybeODRUseExprSet MaybeODRUseExprs
Definition: Sema.h:596
static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Look for &#39;&&&#39; in the right hand of a &#39;||&#39; expr.
Definition: SemaExpr.cpp:12822
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:7847
Represents an ObjC class declaration.
Definition: DeclObjC.h:1171
This is an odr-use.
Definition: Specifiers.h:161
SmallVector< LambdaExpr *, 2 > Lambdas
The lambdas that are present within this context, if it is indeed an unevaluated context.
Definition: Sema.h:1035
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Definition: Expr.h:2050
QualType getReturnType() const
Definition: DeclObjC.h:322
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:426
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:3077
CastKind PrepareScalarCast(ExprResult &src, QualType destType)
Prepares for a scalar cast, performing all the necessary stages except the final cast and returning t...
Definition: SemaExpr.cpp:6160
static bool enclosingClassIsRelatedToClassInWhichMembersWereFound(const UnresolvedMemberExpr *const UME, Sema &S)
Definition: SemaExpr.cpp:5461
IncompatiblePointerSign - The assignment is between two pointers types which point to integers which ...
Definition: Sema.h:9896
ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS, LookupResult &R, bool NeedsADL, bool AcceptInvalidDecl=false)
Definition: SemaExpr.cpp:2892
static OdrUseContext isOdrUseContext(Sema &SemaRef)
Are we within a context in which references to resolved functions or to variables result in odr-use...
Definition: SemaExpr.cpp:14974
static UnresolvedLookupExpr * Create(const ASTContext &Context, CXXRecordDecl *NamingClass, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.cpp:327
QualType getBOOLType() const
type of &#39;BOOL&#39; type.
Definition: ASTContext.h:1895
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:3423
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:142
ExprResult checkUnknownAnyArg(SourceLocation callLoc, Expr *result, QualType &paramType)
Type-check an expression that&#39;s being passed to an __unknown_anytype parameter.
Definition: SemaExpr.cpp:17383
void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var)
Mark a variable referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3).
Definition: SemaExpr.cpp:16454
IdentifierInfo * getIdentifier() const
Definition: DeclSpec.h:2137
CanQualType UnsignedCharTy
Definition: ASTContext.h:1024
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1111
const LangOptions & LangOpts
Definition: Sema.h:372
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:877
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169...
Definition: Type.h:6728
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2926
static void CheckForNullPointerDereference(Sema &S, Expr *E)
Definition: SemaExpr.cpp:478
bool hasUnsignedIntegerRepresentation() const
Determine whether this type has an unsigned integer representation of some sort, e.g., it is an unsigned integer type or a vector.
Definition: Type.cpp:1945
TypeSpecTypeLoc pushTypeSpec(QualType T)
Pushes space for a typespec TypeLoc.
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
Definition: Expr.cpp:1653
void ActOnStmtExprError()
Definition: SemaExpr.cpp:13423
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:576
Qualifiers withoutObjCGCAttr() const
Definition: Type.h:310
unsigned NumCleanupObjects
The number of active cleanup objects when we entered this expression evaluation context.
Definition: Sema.h:1025
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc, Expr *LHS, Expr *RHS)
Definition: Expr.cpp:2096
static ExprResult rebuildPotentialResultsAsNonOdrUsed(Sema &S, Expr *E, NonOdrUseReason NOUR)
Walk the set of potential results of an expression and mark them all as non-odr-uses if they satisfy ...
Definition: SemaExpr.cpp:15902
ImplicitCaptureStyle ImpCaptureStyle
Definition: ScopeInfo.h:637
SourceLocation LAngleLoc
The location of the &#39;<&#39; before the template argument list.
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1289
bool isIntegralOrUnscopedEnumerationType() const
Determine whether this type is an integral or unscoped enumeration type.
Definition: Type.cpp:1803
void addPotentialCapture(Expr *VarExpr)
Add a variable that might potentially be captured by the lambda and therefore the enclosing lambdas...
Definition: ScopeInfo.h:916
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1221
bool isHalfType() const
Definition: Type.h:6649
NodeId Parent
Definition: ASTDiff.cpp:191
NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D)
If D cannot be odr-used in the current expression evaluation context, return a reason explaining why...
Definition: SemaExpr.cpp:1790
OverloadFixItKind Kind
The type of fix applied.
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:3331
OpenMP 4.0 [2.4, Array Sections].
Definition: ExprOpenMP.h:44
ExprResult BuildPredefinedExpr(SourceLocation Loc, PredefinedExpr::IdentKind IK)
Definition: SemaExpr.cpp:3184
bool hasAttr() const
Definition: DeclBase.h:542
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3703
QualType getCorrespondingSaturatedType(QualType Ty) const
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky precedence.
Definition: SemaExpr.cpp:12896
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2498
void setNamingClass(CXXRecordDecl *Record)
Sets the &#39;naming class&#39; for this lookup.
Definition: Lookup.h:408
NamedDecl * getFoundDecl() const
Get the correction declaration found by name lookup (before we looked through using shadow declaratio...
static bool ExprLooksBoolean(Expr *E)
ExprLooksBoolean - Returns true if E looks boolean, i.e.
Definition: SemaExpr.cpp:7544
bool Mutable
Whether this is a mutable lambda.
Definition: ScopeInfo.h:809
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1310
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1636
void checkVariadicArgument(const Expr *E, VariadicCallType CT)
Check to see if the given expression is a valid argument to a variadic function, issuing a diagnostic...
Definition: SemaExpr.cpp:840
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3719
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
Definition: DeclSpec.cpp:118
static QualType computeConditionalNullability(QualType ResTy, bool IsBin, QualType LHSTy, QualType RHSTy, ASTContext &Ctx)
Compute the nullability of a conditional expression.
Definition: SemaExpr.cpp:7597
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:573
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:16534
bool isUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable&#39;s value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2279
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:487
static NamedDecl * getDeclFromExpr(Expr *E)
Definition: SemaExpr.cpp:12373
ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
CreateBuiltinBinOp - Creates a new built-in binary operation with operator Opc at location TokLoc...
Definition: SemaExpr.cpp:12452
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Definition: Decl.cpp:3384
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:481
void CheckShadowingDeclModification(Expr *E, SourceLocation Loc)
Warn if &#39;E&#39;, which is an expression that is about to be modified, refers to a shadowing declaration...
Definition: SemaDecl.cpp:7247
Retains information about a captured region.
Definition: ScopeInfo.h:741
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1403
static void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *SubExpr)
Look for bitwise op in the left or right hand of a bitwise op with lower precedence and emit a diagno...
Definition: SemaExpr.cpp:12839
CastKind
CastKind - The kind of operation required for a conversion.
SourceRange getLocalSourceRange() const
Get the local source range.
Definition: TypeLoc.h:156
static void emitEmptyLookupTypoDiagnostic(const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS, DeclarationName Typo, SourceLocation TypoLoc, ArrayRef< Expr *> Args, unsigned DiagnosticID, unsigned DiagnosticSuggestID)
Definition: SemaExpr.cpp:1884
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1975
static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, ExprResult &RHS)
Handle when one or both operands are void type.
Definition: SemaExpr.cpp:6758
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:572
Specifies that the expression should never be value-dependent.
Definition: Expr.h:729
QualType CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, QualType *CompLHSTy=nullptr)
Definition: SemaExpr.cpp:9418
FunctionVoidPointer - The assignment is between a function pointer and void*, which the standard does...
Definition: Sema.h:9886
void setSubExpr(Expr *E)
Definition: Expr.h:2047
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2342
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
Definition: Type.h:6637
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to...
Definition: Expr.cpp:2024
OdrUseContext
Definition: SemaExpr.cpp:14959
bool isObjCSelType(QualType T) const
Definition: ASTContext.h:2576
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:6217
static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Emit a warning when adding a char literal to a string.
Definition: SemaExpr.cpp:9357
llvm::SmallPtrSet< Expr *, 2 > MaybeODRUseExprSet
Store a set of either DeclRefExprs or MemberExprs that contain a reference to a variable (constant) t...
Definition: Sema.h:595
SourceLocation getLocation() const
Definition: Expr.h:1225
SourceRange getRange() const
Definition: DeclSpec.h:68
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:178
QualType getUsageType(QualType objectType) const
Retrieve the type of this instance variable when viewed as a member of a specific object type...
Definition: DeclObjC.cpp:1813
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:4212
A narrowing conversion by virtue of the source and destination types.
Definition: Overload.h:207
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:263
bool isSaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169...
Definition: Type.h:6702
static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle integer arithmetic conversions.
Definition: SemaExpr.cpp:1154
static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, IdentifierInfo *UDSuffix, SourceLocation UDSuffixLoc, ArrayRef< Expr *> Args, SourceLocation LitEndLoc)
BuildCookedLiteralOperatorCall - A user-defined literal was found.
Definition: SemaExpr.cpp:1600
static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, Expr *Pointer)
Diagnose invalid arithmetic on a void pointer.
Definition: SemaExpr.cpp:9165
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
std::string getAsString(const LangOptions &LO) const
QualType CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
Definition: SemaExpr.cpp:11023
unsigned Offset
Definition: Format.cpp:1713
__v2du d
Definition: emmintrin.h:413
unsigned getValue() const
Definition: Expr.h:1534
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:3319
ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, SourceLocation RParenLoc, Expr *InitExpr)
Definition: SemaExpr.cpp:5991
const ArgList & getInnermost() const
Retrieve the innermost template argument list.
Definition: Template.h:154
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:150
void DiagnoseAssignmentAsCondition(Expr *E)
DiagnoseAssignmentAsCondition - Given that an expression is being used as a boolean condition...
Definition: SemaExpr.cpp:16777
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:189
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:12931
ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool RequiresADL=true)
Create a binary operation that may resolve to an overloaded operator.
static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumConcatenated)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
Definition: Expr.cpp:1075
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:715
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1795
CXXMethodDecl * CallOperator
The lambda&#39;s compiler-generated operator().
Definition: ScopeInfo.h:795
QualType getElementType() const
Definition: Type.h:2522
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
Definition: Expr.cpp:1375
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr...
Definition: Decl.cpp:4551
static bool isPotentiallyConstantEvaluatedContext(Sema &SemaRef)
Are we in a context that is potentially constant evaluated per C++20 [expr.const]p12?
Definition: SemaExpr.cpp:14856
QualType getCXXNameType() const
If this name is one of the C++ names (of a constructor, destructor, or conversion function)...
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3915
bool isInvalid() const
Definition: ScopeInfo.h:590
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
This represents one expression.
Definition: Expr.h:108
SourceLocation End
Represents a character-granular source range.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:121
static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Look for &#39;&&&#39; in the left hand of a &#39;||&#39; expr.
Definition: SemaExpr.cpp:12800
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2766
void setCallee(Expr *F)
Definition: Expr.h:2636
static DeclContext * getParentOfCapturingContextOrNull(DeclContext *DC, VarDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S)
Definition: SemaExpr.cpp:15328
int Id
Definition: ASTDiff.cpp:190
ivar_iterator ivar_begin() const
Definition: DeclObjC.h:1459
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1035
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Definition: Type.h:4549
unsigned getIntWidth() const
getIntWidth/Align - Return the size of &#39;signed int&#39; and &#39;unsigned int&#39; for this target, in bits.
Definition: TargetInfo.h:393
static bool EvaluatesAsTrue(Sema &S, Expr *E)
Returns true if the given expression can be evaluated as a constant &#39;true&#39;.
Definition: SemaExpr.cpp:12785
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
Definition: DeclBase.cpp:1391
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2810
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
Definition: ExprCXX.cpp:1449
bool allowsSizeofAlignof() const
Does this runtime allow sizeof or alignof on object types?
Definition: ObjCRuntime.h:315
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5568
This file defines the classes used to store parsed information about declaration-specifiers and decla...
bool isObjCBuiltinType() const
Definition: Type.h:6535
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6916
static bool maybeDiagnoseAssignmentToFunction(Sema &S, QualType DstType, const Expr *SrcExpr)
Definition: SemaExpr.cpp:14257
QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2, bool ConvertArgs=true)
Find a merged pointer type and convert the two expressions to it.
ExprResult ActOnStmtExprResult(ExprResult E)
Definition: SemaExpr.cpp:13470
This name appears as a potential result of an lvalue-to-rvalue conversion that is a constant expressi...
Definition: Specifiers.h:166
#define V(N, I)
Definition: ASTContext.h:2907
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5541
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2838
CanQualType OMPArraySectionTy
Definition: ASTContext.h:1053
Expr * getCallee()
Definition: Expr.h:2634
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:131
VarDecl * isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo=false, unsigned StopAt=0)
Check if the specified variable is used in one of the private clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP constructs.
std::string getAsString() const
Retrieve the human-readable string for this name.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:126
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
Definition: Type.h:6668
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, bool AllowFold=true)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Definition: SemaExpr.cpp:14526
CharLiteralParser - Perform interpretation and semantic analysis of a character literal.
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
#define bool
Definition: stdbool.h:15
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
Definition: Expr.h:3025
ObjCLifetime getObjCLifetime() const
Definition: Type.h:327
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Definition: Expr.cpp:285
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
bool isObjCClassType() const
Definition: Type.h:6523
static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:12868
SourceLocation getBeginLoc() const
Definition: DeclSpec.h:72
DeclContext * getDeclContext()
Definition: DeclBase.h:438
SourceLocation getLParenLoc() const
Definition: Expr.h:5150
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1779
Overload resolution succeeded.
Definition: Overload.h:53
bool isObjCIdType() const
True if this is equivalent to the &#39;id&#39; type, i.e.
Definition: Type.h:5926
bool isAnyComplexType() const
Definition: Type.h:6472
static bool isVector(QualType QT, QualType ElementType)
This helper function returns true if QT is a vector type that has element type ElementType.
Definition: SemaExpr.cpp:7994
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode. ...
Definition: Expr.cpp:1309
static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHS, Expr *RHS)
Build an overloaded binary operator expression in the given scope.
Definition: SemaExpr.cpp:12945
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:337
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:1364
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
Definition: SemaExpr.cpp:14276
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation...
Definition: DeclCXX.cpp:525
CanQualType ShortTy
Definition: ASTContext.h:1023
static ValueDecl * getCompareDecl(Expr *E)
Definition: SemaExpr.cpp:10134
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:5590
static void diagnoseUncapturableValueReference(Sema &S, SourceLocation loc, ValueDecl *var, DeclContext *DC)
Definition: SemaExpr.cpp:15255
IncompatiblePointerDiscardsQualifiers - The assignment discards qualifiers that we don&#39;t permit to be...
Definition: Sema.h:9905
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:17451
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:1998
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
Definition: Expr.h:2652
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Definition: Expr.h:1347
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
Definition: Expr.cpp:975
Represents a C++ template name within the type system.
Definition: TemplateName.h:187
static bool isMSPropertySubscriptExpr(Sema &S, Expr *Base)
Definition: SemaExpr.cpp:4298
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7826
Defines the clang::TypeLoc interface and its subclasses.
Floating-integral conversions (C++ [conv.fpint])
Definition: Overload.h:116
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1026
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:14836
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn&#39;t...
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:733
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition: Decl.cpp:2772
QualType getType() const
Definition: Expr.h:137
bool isFunctionOrMethod() const
Definition: DeclBase.h:1831
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
Definition: Decl.cpp:2175
CleanupInfo ParentCleanup
Whether the enclosing context needed a cleanup.
Definition: Sema.h:1018
Capture & getCapture(VarDecl *Var)
Retrieve the capture of the given variable, if it has been captured already.
Definition: ScopeInfo.h:696
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
Definition: DeclObjC.cpp:620
static bool TooManyArguments(size_t NumParams, size_t NumArgs, bool PartialOverloading=false)
To be used for checking whether the arguments being passed to function exceeds the number of paramete...
Definition: Sema.h:11157
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
Definition: Expr.h:431
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:308
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:207
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1779
ExprResult BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef< Expr *> Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr)
BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to a literal operator descri...
void setAddressSpace(LangAS space)
Definition: Type.h:373
static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, IdentKind IK, StringLiteral *SL)
Create a PredefinedExpr.
Definition: Expr.cpp:624
bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef< Expr *> Args, SourceLocation RParenLoc, bool ExecConfig=false)
ConvertArgumentsForCall - Converts the arguments specified in Args/NumArgs to the parameter types of ...
Definition: SemaExpr.cpp:4991
ScalarTypeKind
Definition: Type.h:2090
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:950
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:64
llvm::SmallPtrSet< const Expr *, 8 > PossibleDerefs
Definition: Sema.h:1057
bool isInvalid() const
Definition: Ownership.h:166
static UnaryOperatorKind ConvertTokenKindToUnaryOpcode(tok::TokenKind Kind)
Definition: SemaExpr.cpp:12274
SourceLocation getEnd() const
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2016
bool isInstanceMethod() const
Definition: DeclObjC.h:421
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1382
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of &#39;F&#39;...
Definition: Expr.h:2996
Represents a GCC generic vector type.
Definition: Type.h:3200
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2881
ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr, SourceLocation RPLoc)
Definition: SemaExpr.cpp:13683
bool isLambdaToBlockPointerConversion() const
Determine whether this conversion function is a conversion from a lambda closure type to a block poin...
Definition: DeclCXX.cpp:2616
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1082
void CleanupVarDeclMarking()
Definition: SemaExpr.cpp:16256
const BuiltinType * getAsPlaceholderType() const
Definition: Type.h:6623
ValueDecl * getDecl()
Definition: Expr.h:1217
bool isUsable() const
Definition: Ownership.h:167
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2899
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1398
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:180
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
Definition: Type.h:6267
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
QualType getDestroyedType() const
Retrieve the type being destroyed.
Definition: ExprCXX.cpp:224
const Expr * getSubExpr() const
Definition: Expr.h:1980
const Expr * getSubExpr() const
Definition: ExprCXX.h:1305
unsigned short CapRegionKind
The kind of captured region.
Definition: ScopeInfo.h:756
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
Definition: ScopeInfo.h:615
ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, SourceLocation RParenLoc, Expr *LiteralExpr)
Definition: SemaExpr.cpp:6005
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:708
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:413
void setBlockMangling(unsigned Number, Decl *Ctx)
Definition: Decl.h:4089
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:277
void checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, SourceLocation IdLoc=SourceLocation())
Check declaration inside target region.
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:198
static bool checkArgsForPlaceholders(Sema &S, MultiExprArg args)
Check an argument list for placeholders that we won&#39;t try to handle later.
Definition: SemaExpr.cpp:5335
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:264
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:2317
static bool hasAnyExplicitStorageClass(const FunctionDecl *D)
Determine whether a FunctionDecl was ever declared with an explicit storage class.
Definition: SemaExpr.cpp:128
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2060
static std::pair< ExprResult, ExprResult > CorrectDelayedTyposInBinOp(Sema &S, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:12421
SourceRange getSourceRange() const
Definition: ExprCXX.h:140
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1...
Definition: Expr.h:1632
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:215
ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind, SourceLocation BuiltinLoc, SourceLocation RPLoc)
Definition: SemaExpr.cpp:14208
CXXDestructorDecl * LookupDestructor(CXXRecordDecl *Class)
Look for the destructor of the given class.
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:276
bool hasPtrArgsOrResult(unsigned ID) const
Determines whether this builtin has a result or any arguments which are pointer types.
Definition: Builtins.h:165
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD)
Definition: SemaExpr.cpp:5210
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:421
A narrowing conversion, because a non-constant-expression variable might have got narrowed...
Definition: Overload.h:214
static bool isPlaceholderToRemoveAsArg(QualType type)
Is the given type a placeholder that we need to lower out immediately during argument processing...
Definition: SemaExpr.cpp:5286
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169...
Definition: Type.h:6714
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
bool isUnresolvableResult() const
Definition: Lookup.h:317
static CharSourceRange getCharRange(SourceRange R)
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType)
ExtInfo withNoReturn(bool noReturn) const
Definition: Type.h:3569
Lvalue-to-rvalue conversion (C++ [conv.lval])
Definition: Overload.h:83
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6201
bool isVoidPointerType() const
Definition: Type.cpp:469
ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E)
Definition: SemaExpr.cpp:3712
bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType)
Are the two types lax-compatible vector types? That is, given that one of them is a vector...
Definition: SemaExpr.cpp:6395
bool isComparisonOp() const
Definition: Expr.h:3496
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted, APValue &ConstantValue, QualType &ConstantType, bool IgnoreFloatToIntegralConversion=false) const
Check if this standard conversion sequence represents a narrowing conversion, according to C++11 [dcl...
static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, Expr *E, unsigned Type)
Diagnose invalid operand for address of operations.
Definition: SemaExpr.cpp:11925
RecordDecl * getDecl() const
Definition: Type.h:4448
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
Definition: ExprCXX.h:128
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E, bool MightBeOdrUse)
Definition: SemaExpr.cpp:16458
static bool isBitwiseOp(Opcode Opc)
Definition: Expr.h:3486
virtual bool useFP16ConversionIntrinsics() const
Check whether llvm intrinsics such as llvm.convert.to.fp16 should be used to convert to and from __fp...
Definition: TargetInfo.h:751
QualType getWideCharType() const
Return the type of wide characters.
Definition: ASTContext.h:1570
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
Definition: Expr.cpp:2033
static QualType checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Return the resulting type when the operands are both pointers.
Definition: SemaExpr.cpp:6944
Wrapper for source info for arrays.
Definition: TypeLoc.h:1495
static bool captureInLambda(LambdaScopeInfo *LSI, VarDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, const Sema::TryCaptureKind Kind, SourceLocation EllipsisLoc, const bool IsTopScope, Sema &S, bool Invalid)
Capture the given variable in the lambda.
Definition: SemaExpr.cpp:15537
Expr * IgnoreConversionOperator() LLVM_READONLY
Skip conversion operators.
Definition: Expr.cpp:2951
unsigned getIntMaxTWidth() const
Return the size of intmax_t and uintmax_t for this target, in bits.
Definition: TargetInfo.h:658
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
CanQualType OverloadTy
Definition: ASTContext.h:1043
static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, Expr *Operand)
Emit error if Operand is incomplete pointer type.
Definition: SemaExpr.cpp:9219
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:1045
QualType getBuiltinMSVaListType() const
Retrieve the type of the __builtin_ms_va_list type.
Definition: ASTContext.h:1923
Integral conversions (C++ [conv.integral])
Definition: Overload.h:107
SmallVectorImpl< OverloadCandidate >::iterator iterator
Definition: Overload.h:936
QualType getObjCIdRedefinitionType() const
Retrieve the type that id has been defined to, which may be different from the built-in id if id has ...
Definition: ASTContext.h:1641
ExprResult MaybeBindToTemporary(Expr *E)
MaybeBindToTemporary - If the passed in expression has a record type with a non-trivial destructor...
CanQualType BuiltinFnTy
Definition: ASTContext.h:1044
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:165
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2750
ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conv...
Definition: Overload.h:486
QualType getCanonicalType() const
Definition: Type.h:6181
bool CheckCaseExpression(Expr *E)
Definition: SemaExpr.cpp:17558
not a target-specific vector type
Definition: Type.h:3204
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S, IdentifierInfo *II, bool AllowBuiltinCreation=false)
LookupInObjCMethod - The parser has read a name in, and Sema has detected that we&#39;re currently inside...
Definition: SemaExpr.cpp:2503
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5663
param_type_range param_types() const
Definition: Type.h:4063
A stack object to be created when performing template instantiation.
Definition: Sema.h:7692
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:4111
VarDecl * getVariable() const
Definition: ScopeInfo.h:604
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3932
ASTContext & getASTContext() const
Definition: Sema.h:1292
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:294
unsigned getNumExprs() const
Return the number of expressions in this paren list.
Definition: Expr.h:5131
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3658
Encodes a location in the source.
ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_convertvector(...)
Definition: SemaExpr.cpp:5731
QualType getReturnType() const
Definition: Type.h:3645
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
llvm::APFloat::opStatus GetFloatValue(llvm::APFloat &Result)
GetFloatValue - Convert this numeric literal to a floating value, using the specified APFloat fltSema...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4464
SourceLocation getOperatorLoc() const
Definition: Expr.h:3437
CastKind PrepareCastToObjCObjectPointer(ExprResult &E)
Prepare a conversion of the given expression to an ObjC object pointer type.
Definition: SemaExpr.cpp:6145
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6258
This represents &#39;#pragma omp declare reduction ...&#39; directive.
Definition: DeclOpenMP.h:102
static DependentScopeDeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:479
Expression is not a Null pointer constant.
Definition: Expr.h:706
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition: Type.h:956
VarArgKind isValidVarArgType(const QualType &Ty)
Determine the degree of POD-ness for an expression.
Definition: SemaExpr.cpp:790
Expr * getSubExpr() const
Definition: Expr.h:2046
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5808
static void SuggestParentheses(Sema &Self, SourceLocation Loc, const PartialDiagnostic &Note, SourceRange ParenRange)
SuggestParentheses - Emit a note with a fixit hint that wraps ParenRange in parentheses.
Definition: SemaExpr.cpp:7473
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2124
CXXRecordDecl * Lambda
The class that describes the lambda.
Definition: ScopeInfo.h:792
QualType getObjCSelRedefinitionType() const
Retrieve the type that &#39;SEL&#39; has been defined to, which may be different from the built-in &#39;SEL&#39; if &#39;...
Definition: ASTContext.h:1667
static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc)
Definition: SemaExpr.cpp:11736
static QualType checkArithmeticOrEnumeralCompare(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
Definition: SemaExpr.cpp:10421
bool ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&SrcExpr, bool Diagnose=true)
Definition: SemaExpr.cpp:14222
static bool captureInCapturedRegion(CapturedRegionScopeInfo *RSI, VarDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, Sema &S, bool Invalid)
Capture the given variable in the captured region.
Definition: SemaExpr.cpp:15501
const ComplexType * getAsComplexIntegerType() const
Definition: Type.cpp:498
CastKind getCastKind() const
Definition: Expr.h:3167
static void MarkVarDeclODRUsed(VarDecl *Var, SourceLocation Loc, Sema &SemaRef, const unsigned *const FunctionScopeIndexToStopAt=nullptr)
Directly mark a variable odr-used.
Definition: SemaExpr.cpp:15224
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:2005
SourceLocation getBeginLoc() const
Definition: ExprCXX.h:2245
static ValueDecl * getPrimaryDecl(Expr *E)
getPrimaryDecl - Helper function for CheckAddressOfOperand().
Definition: SemaExpr.cpp:11868
static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T, Expr *E)
Check whether E is a pointer from a decayed array type (the decayed pointer type is equal to T) and e...
Definition: SemaExpr.cpp:3783
DeclarationName getName() const
getName - Returns the embedded declaration name.
static bool IgnoreCommaOperand(const Expr *E)
Definition: SemaExpr.cpp:11666
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of &#39;signed long long&#39; and &#39;unsigned long long&#39; for this targ...
Definition: TargetInfo.h:403
QualType getElementType() const
Definition: Type.h:3235
void setReferenced(bool R=true)
Definition: DeclBase.h:588
Represents the declaration of a label.
Definition: Decl.h:468
IncompatiblePointer - The assignment is between two pointers types that are not compatible, but we accept them as an extension.
Definition: Sema.h:9890
ExprResult ActOnCharacterConstant(const Token &Tok, Scope *UDLScope=nullptr)
Definition: SemaExpr.cpp:3252
bool isOverloadedResult() const
Determines if the results are overloaded.
Definition: Lookup.h:313
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:138
bool isExternalWithNoLinkageType(ValueDecl *VD)
Determine if VD, which must be a variable or function, is an external symbol that nonetheless can&#39;t b...
Definition: Sema.cpp:627
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr *> exprs, SourceLocation RParenLoc)
Definition: Expr.cpp:1541
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1790
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2114
static ExprResult convertVector(Expr *E, QualType ElementType, Sema &S)
Convert vector E to a vector with the same number of elements but different element type...
Definition: SemaExpr.cpp:8683
void setIdentifierInfo(IdentifierInfo *II)
Definition: Token.h:188
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2441
ExprResult TransformToPotentiallyEvaluated(Expr *E)
Definition: SemaExpr.cpp:14704
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
static std::string ComputeName(IdentKind IK, const Decl *CurrentDecl)
Definition: Expr.cpp:664
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:182
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:554
static InitializedEntity InitializeCompoundLiteralInit(TypeSourceInfo *TSI)
Create the entity for a compound literal initializer.
CanQualType FloatTy
Definition: ASTContext.h:1026
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2312
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
ExprResult ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, SourceLocation RBraceLoc)
Definition: SemaExpr.cpp:6104
Specifies that a value-dependent expression should be considered to never be a null pointer constant...
Definition: Expr.h:737
OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc, OverloadCandidateSet::iterator &Best)
Find the best viable function on this overload set, if it exists.
CanQualType VoidTy
Definition: ASTContext.h:1014
static void CheckBoolLikeConversion(Sema &S, Expr *E, SourceLocation CC)
Check conversion of given expression to boolean.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:24
Expr * getExpr(unsigned Init)
Definition: Expr.h:5133
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
Describes the kind of initialization being performed, along with location information for tokens rela...
bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level) const
Return true if the provided declaration VD should be captured by reference.
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:158
const TemplateArgumentListInfo & getTemplateArgsInfo() const
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.h:1856
Qualifiers withoutObjCLifetime() const
Definition: Type.h:315
AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType, ExprResult &RHS)
Definition: SemaExpr.cpp:8349
CanQualType Float16Ty
Definition: ASTContext.h:1039
bool isKnownToHaveBooleanValue() const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
Definition: Expr.cpp:134
bool isAnyPointerType() const
Definition: Type.h:6388
bool isObjCObjectPointerType() const
Definition: Type.h:6488
void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E)
Perform reference-marking and odr-use handling for a FunctionParmPackExpr.
Definition: SemaExpr.cpp:16525
This declaration is only a declaration.
Definition: Decl.h:1146
is AltiVec &#39;vector bool ...&#39;
Definition: Type.h:3213
SmallVector< Capture, 4 > Captures
Captures - The captures.
Definition: ScopeInfo.h:650
void setAsIdentityConversion()
StandardConversionSequence - Set the standard conversion sequence to the identity conversion...
void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc, unsigned CapturingScopeIndex)
Definition: SemaExpr.cpp:15248
virtual BuiltinVaListKind getBuiltinVaListKind() const =0
Returns the kind of __builtin_va_list type that should be used with this target.
unsigned NumTypos
The number of typos encountered during this expression evaluation context (i.e.
Definition: Sema.h:1029
void tryCaptureOpenMPLambdas(ValueDecl *V)
Function tries to capture lambda&#39;s captured variables in the OpenMP region before the original lambda...
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:728
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3245
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1157
static QualType findBoundMemberType(const Expr *expr)
Given an expression of bound-member type, find the type of the member.
Definition: Expr.cpp:2758
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Definition: Expr.h:258
isModifiableLvalueResult isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, does not have an incomplet...
is AltiVec vector
Definition: Type.h:3207
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1678
virtual void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR)
Definition: SemaExpr.cpp:14520
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:211
ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLoc, Expr *Length, SourceLocation RBLoc)
Definition: SemaExpr.cpp:4431
bool isAddressSpaceOverlapping(const PointerType &other) const
Returns true if address spaces of pointers overlap.
Definition: Type.h:2592
void addPotentialThisCapture(SourceLocation Loc)
Definition: ScopeInfo.h:922
bool isFixedPointOrIntegerType() const
Return true if this is a fixed point or integer type.
Definition: Type.h:6698
TypeClass getTypeClass() const
Definition: Type.h:1839
Used for C&#39;s _Alignof and C++&#39;s alignof.
Definition: TypeTraits.h:100
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:3159
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:397
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:177
bool typesAreBlockPointerCompatible(QualType, QualType)
bool isAnyCharacterType() const
Determine whether this type is any of the built-in character types.
Definition: Type.cpp:1854
EnumDecl * getDecl() const
Definition: Type.h:4471
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1356
bool isVectorType() const
Definition: Type.h:6476
Complex-real conversions (C99 6.3.1.7)
Definition: Overload.h:140
Assigning into this object requires a lifetime extension.
Definition: Type.h:171
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3922
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:846
unsigned getFullDataSize() const
Returns the size of the type source info data block.
Definition: TypeLoc.h:161
CXXRecordDecl * getNamingClass()
Retrieve the naming class of this lookup.
Definition: ExprCXX.cpp:1487
ExprResult HandleExprEvaluationContextForTypeof(Expr *E)
Definition: SemaExpr.cpp:14844
bool isCanonical() const
Definition: Type.h:6186
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:573
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2320
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:594
static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign)
Return the resulting type when a vector is shifted by a scalar or vector shift amount.
Definition: SemaExpr.cpp:9714
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2126
static unsigned isEnabled(DiagnosticsEngine &D, unsigned diag)
Defines the fixed point number interface.
ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, SourceLocation RPLoc)
Definition: SemaExpr.cpp:13432
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3955
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:215
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat &#39;semantics&#39; for the specified scalar floating point type.
static void DiagnoseBadShiftValues(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc, QualType LHSType)
Definition: SemaExpr.cpp:9628
ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType)
Definition: SemaExpr.cpp:1136
static ExprResult convertHalfVecBinOp(Sema &S, ExprResult LHS, ExprResult RHS, BinaryOperatorKind Opc, QualType ResultTy, ExprValueKind VK, ExprObjectKind OK, bool IsCompAssign, SourceLocation OpLoc, FPOptions FPFeatures)
Definition: SemaExpr.cpp:12388
ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, Expr *CastExpr, CastKind &CastKind, ExprValueKind &VK, CXXCastPath &Path)
Check a cast of an unknown-any type.
Definition: SemaExpr.cpp:17359
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3625
A POD class for pairing a NamedDecl* with an access specifier.
bool isRealType() const
Definition: Type.cpp:1974
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
Definition: Type.h:6617
VersionTuple getVersion() const
Definition: Availability.h:51
void maybeExtendBlockObject(ExprResult &E)
Do an explicit extend of the given block pointer if we&#39;re in ARC.
Definition: SemaExpr.cpp:6130
ReuseLambdaContextDecl_t
Definition: Sema.h:4206
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template...
Definition: Decl.cpp:2577
Represents an element in a path from a derived class to a base class.
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3878
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
void MarkMemberReferenced(MemberExpr *E)
Perform reference-marking and odr-use handling for a MemberExpr.
Definition: SemaExpr.cpp:16506
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
Definition: ExprCXX.h:4243
CanQualType CharTy
Definition: ASTContext.h:1016
Represents a template argument.
Definition: TemplateBase.h:50
bool isPipeType() const
Definition: Type.h:6576
void DecomposeUnqualifiedId(const UnqualifiedId &Id, TemplateArgumentListInfo &Buffer, DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *&TemplateArgs)
Decomposes the given name into a DeclarationNameInfo, its location, and possibly a list of template a...
Definition: SemaExpr.cpp:1862
static bool isInvalid(LocType Loc, bool *Invalid)
This name appears as a potential result of a discarded value expression.
Definition: Specifiers.h:169
NonConstCaptureKind
Is the given expression (which must be &#39;const&#39;) a reference to a variable which was originally non-co...
Definition: SemaExpr.cpp:11127
static void ConstructTransparentUnion(Sema &S, ASTContext &C, ExprResult &EResult, QualType UnionType, FieldDecl *Field)
Constructs a transparent union from an expression that is used to initialize the transparent union...
Definition: SemaExpr.cpp:8330
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2616
Dataflow Directional Tag Classes.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i...
bool isValid() const
Return true if this is a valid SourceLocation object.
ExtInfo getExtInfo() const
Definition: Type.h:3656
ParmVarDecl * BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T)
Synthesizes a variable for a parameter arising from a typedef.
Definition: SemaDecl.cpp:12910
static bool isScopedEnumerationType(QualType T)
Definition: SemaExpr.cpp:9622
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false)
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:2568
UnaryOperatorKind
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input)
Definition: SemaExpr.cpp:13405
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:580
const DeclContext * getCurObjCLexicalContext() const
Definition: Sema.h:11147
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2265
static ImplicitConversionSequence TryImplicitConversion(Sema &S, Expr *From, QualType ToType, bool SuppressUserConversions, bool AllowExplicit, bool InOverloadResolution, bool CStyle, bool AllowObjCWritebackConversion, bool AllowObjCConversionOnExplicit)
TryImplicitConversion - Attempt to perform an implicit conversion from the given expression (Expr) to...
ArrayRef< Capture > captures() const
Definition: Decl.h:4042
static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, Expr *LHSExpr, Expr *RHSExpr)
diagnoseStringPlusInt - Emit a warning when adding an integer to a string literal.
Definition: SemaExpr.cpp:9327
bool isSentinelNullExpr(const Expr *E)
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:403
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
QualType GetSignedVectorType(QualType V)
Definition: SemaExpr.cpp:10891
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:484
typedef char* __builtin_va_list;
Definition: TargetInfo.h:225
static bool unsupportedTypeConversion(const Sema &S, QualType LHSType, QualType RHSType)
Diagnose attempts to convert between __float128 and long double if there is no support for such conve...
Definition: SemaExpr.cpp:1098
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:130
QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
CheckVectorCompareOperands - vector comparisons are a clang extension that operates on extended vecto...
Definition: SemaExpr.cpp:10931
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3639
bool isShiftOp() const
Definition: Expr.h:3484
bool isRecord() const
Definition: DeclBase.h:1858
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
SourceLocation RAngleLoc
The location of the &#39;>&#39; after the template argument list.
ObjCLiteralKind CheckLiteralKind(Expr *FromE)
Definition: SemaExpr.cpp:9999
bool isCXX98PODType(const ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Definition: Type.cpp:2140
void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef< Expr *> Args, OverloadCandidateSet &CandidateSet, bool SuppressUserConversions=false, bool PartialOverloading=false, bool AllowExplicit=true, bool AllowExplicitConversion=false, ADLCallKind IsADLCandidate=ADLCallKind::NotADL, ConversionSequenceList EarlyConversions=None)
AddOverloadCandidate - Adds the given function to the set of candidate functions, using the given fun...
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2858
static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar, QualType scalarTy, QualType vectorEltTy, QualType vectorTy, unsigned &DiagID)
Try to convert a value of non-vector type to a vector type by converting the type to the element type...
Definition: SemaExpr.cpp:8636
void setSubExpr(Expr *E)
Definition: Expr.h:3175
ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
__builtin_astype(...)
Definition: SemaExpr.cpp:5710
bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the current evaluation context.
Definition: SemaExpr.cpp:16728
static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompare)
Definition: SemaExpr.cpp:9030
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1025
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:118
void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, bool IsDereference, SourceRange Range)
Definition: SemaCast.cpp:1805
static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opc)
Diagnose some forms of syntactically-obvious tautological comparison.
Definition: SemaExpr.cpp:10149
const Expr * getInit() const
Definition: Decl.h:1219
bool hasCvrSimilarType(QualType T1, QualType T2)
Determine if two types are similar, ignoring only CVR qualifiers.
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:595
A runtime availability query.
Definition: ExprObjC.h:1699
static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo *> AssocTypes, ArrayRef< Expr *> AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Create a non-result-dependent generic selection expression.
Definition: Expr.cpp:4052
Array-to-pointer conversion (C++ [conv.array])
Definition: Overload.h:86
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:188
static bool ShouldLookupResultBeMultiVersionOverload(const LookupResult &R)
Definition: SemaExpr.cpp:2885
unsigned CXXThisCaptureIndex
CXXThisCaptureIndex - The (index+1) of the capture of &#39;this&#39;; zero if &#39;this&#39; is not captured...
Definition: ScopeInfo.h:647
bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind)
Check the constraints on expression operands to unary type expression and type traits.
Definition: SemaExpr.cpp:3806
The name of a declaration.
StmtClass getStmtClass() const
Definition: Stmt.h:1087
VectorKind getVectorKind() const
Definition: Type.h:3245
const char * getCastKindName() const
Definition: Expr.h:3171
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:517
Expr * getDefaultArg()
Definition: Decl.cpp:2654
void setInstantiationIsPending(bool IC)
State that the instantiation of this function is pending.
Definition: Decl.h:2136
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:976
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:345
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2237
const Expr * getExpr() const
Definition: ExprCXX.h:1150
bool isBooleanType() const
Definition: Type.h:6760
Kind getKind() const
Definition: DeclBase.h:432
static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn)
Given a function expression of unknown-any type, try to rebuild it to have a function type...
Definition: SemaExpr.cpp:17005
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like &#39;int()&#39;.
Expression is a Null pointer constant built from a zero integer expression that is not a simple...
Definition: Expr.h:713
ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr)
Prepare SplattedExpr for a vector splat operation, adding implicit casts if necessary.
Definition: SemaExpr.cpp:6450
A set of unresolved declarations.
virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR)=0
IncompatibleBlockPointer - The assignment is between two block pointers types that are not compatible...
Definition: Sema.h:9929
Expression is a C++11 nullptr.
Definition: Expr.h:719
static void diagnoseLogicalNotOnLHSofCheck(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
Warns on !x < y, !x & y where !(x < y), !(x & y) was probably intended.
Definition: SemaExpr.cpp:10091
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
Definition: Type.h:3668
static void EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, BinaryOperator *Bop)
It accepts a &#39;&&&#39; expr that is inside a &#39;||&#39; one.
Definition: SemaExpr.cpp:12772
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:174
static InitializationKind CreateCStyleCast(SourceLocation StartLoc, SourceRange TypeRange, bool InitList)
Create a direct initialization for a C-style cast.
Expr * get() const
Definition: Sema.h:3844
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1395
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration...
Definition: DeclCXX.h:2215
ExplicitCastExpr - An explicit cast written in the source code.
Definition: Expr.h:3308
static bool checkArithmeticOnObjCPointer(Sema &S, SourceLocation opLoc, Expr *op)
Diagnose if arithmetic on the given ObjC pointer is illegal.
Definition: SemaExpr.cpp:4284
ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind)
Definition: SemaExpr.cpp:3235
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
void setInitializedFieldInUnion(FieldDecl *FD)
Definition: Expr.h:4489
ExprResult ActOnConstantExpression(ExprResult Res)
Definition: SemaExpr.cpp:16243
unsigned getLength() const
Definition: Token.h:129
IdentifierInfo * getCorrectionAsIdentifierInfo() const
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
Definition: TargetInfo.h:1117
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, const FunctionProtoType *Proto, unsigned FirstParam, ArrayRef< Expr *> Args, SmallVectorImpl< Expr *> &AllArgs, VariadicCallType CallType=VariadicDoesNotApply, bool AllowExplicit=false, bool IsListInitialization=false)
GatherArgumentsForCall - Collector argument expressions for various form of call prototypes.
Definition: SemaExpr.cpp:5107
ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo *> Types, ArrayRef< Expr *> Exprs)
Definition: SemaExpr.cpp:1446
bool isValid() const
A scope specifier is present, and it refers to a real scope.
Definition: DeclSpec.h:196
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2942
void addConst()
Definition: Type.h:257
bool isMacroID() const
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression&#39;s result is syntactically ignored, perform any conversions that are required.
void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S, QualType T1, QualType T2, UnresolvedSetImpl &Functions)
Represents a pointer to an Objective C object.
Definition: Type.h:5864
static QualType handleFixedPointConversion(Sema &S, QualType LHSTy, QualType RHSTy)
handleFixedPointConversion - Fixed point operations between fixed point types and integers or other f...
Definition: SemaExpr.cpp:1297
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:150
Pointer to a block type.
Definition: Type.h:2671
CanQualType ObjCBuiltinBoolTy
Definition: ASTContext.h:1047
The standard open() call: int open(const char *path, int oflag, ...);.
ObjCMethodDecl * LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R, bool receiverIdOrClass=false)
LookupInstanceMethodInGlobalPool - Returns the method and warns if there are multiple signatures...
Definition: Sema.h:3807
static bool EvaluatesAsFalse(Sema &S, Expr *E)
Returns true if the given expression can be evaluated as a constant &#39;false&#39;.
Definition: SemaExpr.cpp:12793
SourceLocation getBeginLoc() const
Definition: ExprCXX.h:2316
unsigned getIntWidth(QualType T) const
static void DiagnoseBadDivideOrRemainderValues(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsDiv)
Definition: SemaExpr.cpp:9092
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2934
Not an overloaded operator.
Definition: OperatorKinds.h:22
ExprResult ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, bool IsType, void *TyOrEx, SourceRange ArgRange)
ActOnUnaryExprOrTypeTraitExpr - Handle sizeof(type) and sizeof expr and the same for alignof and __al...
Definition: SemaExpr.cpp:4210
bool HasSideEffects
Whether the evaluated expression has side effects.
Definition: Expr.h:553
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4438
Complex values, per C99 6.2.5p11.
Definition: Type.h:2509
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2696
QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const
Return a type for a constant array for a string literal of the specified element type and length...
CanQualType UnknownAnyTy
Definition: ASTContext.h:1043
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3689
bool body_empty() const
Definition: Stmt.h:1337
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface...
Definition: Type.h:5920
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2432
CXXMethodDecl * getDevirtualizedMethod(const Expr *Base, bool IsAppleKext)
If it&#39;s possible to devirtualize a call to this method, return the called function.
Definition: DeclCXX.cpp:2027
ObjCLiteralKind
Definition: Sema.h:2910
static QualType OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond, ExprResult &LHS, ExprResult &RHS, SourceLocation QuestionLoc)
Return the resulting type for the conditional operator in OpenCL (aka "ternary selection operator"...
Definition: SemaExpr.cpp:7150
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6677
ExprResult BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, bool IsAddressOfOperand, const Scope *S, TypeSourceInfo **RecoveryTSI=nullptr)
BuildQualifiedDeclarationNameExpr - Build a C++ qualified declaration name, generally during template...
Definition: SemaExpr.cpp:2420
CanQualType UnsignedLongTy
Definition: ASTContext.h:1024
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1805
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
T * getAttr() const
Definition: DeclBase.h:538
ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr, CastKind &Kind)
Definition: SemaExpr.cpp:6483
SourceLocation getLocation() const
Definition: ExprObjC.h:589
static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, Expr *SubExpr, StringRef Shift)
Definition: SemaExpr.cpp:12854
const llvm::APInt & getSize() const
Definition: Type.h:2922
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2083
CanQualType DependentTy
Definition: ASTContext.h:1043
bool isImageType() const
Definition: Type.h:6569
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1239
static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr)
Check the validity of a binary arithmetic operation w.r.t.
Definition: SemaExpr.cpp:9272
bool isAtomicType() const
Definition: Type.h:6501
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
Definition: Expr.cpp:536
static bool checkThreeWayNarrowingConversion(Sema &S, QualType ToType, Expr *E, QualType FromType, SourceLocation Loc)
Definition: SemaExpr.cpp:10288
bool isFunctionType() const
Definition: Type.h:6380
bool isObjCQualifiedIdType() const
Definition: Type.h:6505
static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, unsigned Offset)
getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the location of the token and the off...
Definition: SemaExpr.cpp:1592
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:715
ExtVectorType - Extended vector type.
Definition: Type.h:3319
Opcode getOpcode() const
Definition: Expr.h:2041
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2705
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1737
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2296
CanQualType BoundMemberTy
Definition: ASTContext.h:1043
LValueClassification
Definition: Expr.h:263
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1090
static Sema::AssignConvertType checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType)
checkBlockPointerTypesForAssignment - This routine determines whether two block pointer types are com...
Definition: SemaExpr.cpp:7894
bool isInOpenMPDeclareTargetContext() const
Return true inside OpenMP declare target region.
Definition: Sema.h:9172
ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr)
Definition: SemaExpr.cpp:13095
static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation OpLoc, bool IsInc, bool IsPrefix)
CheckIncrementDecrementOperand - unlike most "Check" methods, this routine doesn&#39;t need to call Usual...
Definition: SemaExpr.cpp:11772
qual_range quals() const
Definition: Type.h:5987
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D)
Diagnoses obvious problems with the use of the given declaration as an expression.
Definition: SemaExpr.cpp:2861
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:253
const Expr * getBase() const
Definition: ExprObjC.h:580
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3755
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Determine the kind of template specialization this function represents for the purpose of template in...
Definition: Decl.cpp:3655
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type...
Definition: Type.cpp:2849
bool isConstantArrayType() const
Definition: Type.h:6444
llvm::DenseMap< VarDecl *, unsigned > CaptureMap
CaptureMap - A map of captured variables to (index+1) into Captures.
Definition: ScopeInfo.h:643
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:76
ExprResult ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc, SourceLocation TypeLoc, ParsedType ParsedArgTy, ArrayRef< OffsetOfComponent > Components, SourceLocation RParenLoc)
Definition: SemaExpr.cpp:13664
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:143
static bool tryGCCVectorConvertAndSplat(Sema &S, ExprResult *Scalar, ExprResult *Vector)
Attempt to convert and splat Scalar into a vector whose types matches Vector following GCC conversion...
Definition: SemaExpr.cpp:8784
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:412
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2079
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:546
This is a scope that can contain a declaration.
Definition: Scope.h:59
static InitializedEntity InitializeStmtExprResult(SourceLocation ReturnLoc, QualType Type)
static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, ExprResult &RHS, bool IsError)
Diagnose bad pointer comparisons.
Definition: SemaExpr.cpp:9888
QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS, ExprResult &RHS)
the following "Check" methods will return a valid/converted QualType or a null QualType (indicating a...
Definition: SemaExpr.cpp:8573
bool isObjCObjectType() const
Definition: Type.h:6492
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2062
CanQualType Char8Ty
Definition: ASTContext.h:1020
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2391
bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function, bool Complain=false, SourceLocation Loc=SourceLocation())
Returns whether the given function&#39;s address can be taken or not, optionally emitting a diagnostic if...
QualType withCVRQualifiers(unsigned CVR) const
Definition: Type.h:835
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:1580
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2280
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:240
bool isArithmeticOp() const
Definition: Expr.h:2097
CXXRecordDecl * getNamingClass() const
Returns the &#39;naming class&#39; for this lookup, i.e.
Definition: Lookup.h:403
static BlockDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:4598
Reading or writing from this object requires a barrier call.
Definition: Type.h:168
bool isQueueT() const
Definition: Type.h:6561
ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, SourceRange R)
Build a sizeof or alignof expression given a type operand.
Definition: SemaExpr.cpp:4121
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:234
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4493
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
Get the name of the literal operator function with II as the identifier.
QualType getParamType(unsigned i) const
Definition: Type.h:3923
ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, FunctionDecl *FDecl)
DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but will create a trap if the resul...
Definition: SemaExpr.cpp:887
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
Expression is a Null pointer constant built from a literal zero.
Definition: Expr.h:716
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc, VarDecl *Var, Expr *E)
Definition: SemaExpr.cpp:16281
Function-to-pointer (C++ [conv.array])
Definition: Overload.h:89
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1007
ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, Expr *ControllingExpr, ArrayRef< ParsedType > ArgTypes, ArrayRef< Expr *> ArgExprs)
Definition: SemaExpr.cpp:1420
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2807
Data structure used to record current or nested expression evaluation contexts.
Definition: Sema.h:1013
QualType CheckBitwiseOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
Definition: SemaExpr.cpp:10988
void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Definition: ScopeInfo.h:660
Describes the sequence of initializations required to initialize a given object or reference with a s...
ActionResult< Expr * > ExprResult
Definition: Ownership.h:263
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6222
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3307
static QualType handleFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)
Handle arithmethic conversion with floating point types.
Definition: SemaExpr.cpp:1059
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:2666
static bool isObjCObjectLiteral(ExprResult &E)
Definition: SemaExpr.cpp:9940
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g., it is an signed integer type or a vector.
Definition: Type.cpp:1905
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
Compatible - the types are compatible according to the standard.
Definition: Sema.h:9874
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6643
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
CUDAFunctionTarget
Definition: Sema.h:10551
void markUsed(bool IsODRUse)
Definition: ScopeInfo.h:597
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1439
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
Definition: Expr.cpp:4517
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.h:1984
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4098
static bool hasAnyTypeDependentArguments(ArrayRef< Expr *> Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
Definition: Expr.cpp:3100
bool isNested() const
Definition: ScopeInfo.h:588
static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, Expr **RHSExprs)
IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary expression, either using a built-i...
Definition: SemaExpr.cpp:7498
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3776
bool hasIntegerRepresentation() const
Determine whether this type has an integer representation of some sort, e.g., it is an integer type o...
Definition: Type.cpp:1764
SourceLocation getRParenLoc() const
Definition: Expr.h:5151
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6169
LiteralOperatorLookupResult LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef< QualType > ArgTys, bool AllowRaw, bool AllowTemplate, bool AllowStringTemplate, bool DiagnoseMissing)
LookupLiteralOperator - Determine which literal operator should be used for a user-defined literal...
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1944
CanQualType Char16Ty
Definition: ASTContext.h:1021
bool isMultiplicativeOp() const
Definition: Expr.h:3480
bool isLaxVectorConversion(QualType srcType, QualType destType)
Is this a legal conversion between two types, one of which is known to be a vector type...
Definition: SemaExpr.cpp:6422
TryCaptureKind
Definition: Sema.h:4245
bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc)
Checks if the variable must be captured.
Definition: SemaExpr.cpp:15850
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
Definition: Sema.h:1432
QualType CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, BinaryOperatorKind Opc)
Definition: SemaExpr.cpp:10450
QualType CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool IsDivide)
Definition: SemaExpr.cpp:9105
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:571
Location information for a TemplateArgument.
Definition: TemplateBase.h:392
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:386
bool isSamplerT() const
Definition: Type.h:6549
bool isCXXThisCaptured() const
Determine whether the C++ &#39;this&#39; is captured.
Definition: ScopeInfo.h:678
void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D)
Definition: SemaExpr.cpp:188
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:223
bool isRValue() const
Definition: Expr.h:259
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B)
Returns true if address space A is equal to or a superset of B.
Definition: Type.h:470
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2423
bool DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs=nullptr, ArrayRef< Expr *> Args=None, TypoExpr **Out=nullptr)
Diagnose an empty lookup.
Definition: SemaExpr.cpp:1920
SourceManager & getSourceManager() const
Definition: Sema.h:1290
iterator end() const
Definition: Lookup.h:336
A template-id, e.g., f<int>.
static CXXDefaultArgExpr * Create(const ASTContext &C, SourceLocation Loc, ParmVarDecl *Param, DeclContext *UsedContext)
Definition: ExprCXX.h:1138
This represents &#39;#pragma omp declare mapper ...&#39; directive.
Definition: DeclOpenMP.h:217
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:251
void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)
Definition: SemaExpr.cpp:11687
ExpressionEvaluationContext
Describes how the expressions currently being parsed are evaluated at run-time, if at all...
Definition: Sema.h:966
static Expr * BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, QualType Ty, SourceLocation Loc)
Definition: SemaExpr.cpp:3315
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1681
Defines the clang::TargetInfo interface.
bool isComplexIntegerType() const
Definition: Type.cpp:487
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2516
static ImplicitConversionKind castKindToImplicitConversionKind(CastKind CK)
Definition: SemaExpr.cpp:10251
QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign, bool AllowBothBool, bool AllowBoolConversion)
type checking for vector binary operators.
Definition: SemaExpr.cpp:8859
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:153
static CUDAKernelCallExpr * Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation RP, unsigned MinNumArgs=0)
Definition: ExprCXX.cpp:1653
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3751
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
unsigned getCVRQualifiers() const
Definition: Type.h:270
ExprResult ExprError()
Definition: Ownership.h:279
NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber...
ExprResult PerformObjectMemberConversion(Expr *From, NestedNameSpecifier *Qualifier, NamedDecl *FoundDecl, NamedDecl *Member)
Cast a base object to a member&#39;s actual type.
Definition: SemaExpr.cpp:2650
uint64_t Width
Definition: ASTContext.h:143
CanQualType IntTy
Definition: ASTContext.h:1023
NonOdrUseReason
The reason why a DeclRefExpr does not constitute an odr-use.
Definition: Specifiers.h:159
unsigned getNumElements() const
Definition: Type.h:3236
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:85
AssumedTemplateKind
Definition: Sema.h:6415
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:225
The name refers to a variable template whose specialization produces a variable.
Definition: TemplateKinds.h:33
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2108
static void tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(Sema &S, const UnresolvedMemberExpr *const UME, SourceLocation CallLoc)
Definition: SemaExpr.cpp:5503
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:1728
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1141
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:821
result[0]
Definition: emmintrin.h:120
The class facilities generation and storage of conversion FixIts.
Expr * getRHS() const
Definition: Expr.h:3447
ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc)
Definition: SemaExpr.cpp:14076
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2163
bool isPointerType() const
Definition: Type.h:6384
bool isBitwiseOp() const
Definition: Expr.h:3487
bool isIncrementDecrementOp() const
Definition: Expr.h:2090
ExprResult ActOnStringLiteral(ArrayRef< Token > StringToks, Scope *UDLScope=nullptr)
ActOnStringLiteral - The specified tokens were lexed as pasted string fragments (e.g.
Definition: SemaExpr.cpp:1636
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
Definition: Expr.cpp:2071
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
void initializeFullCopy(TypeLoc Other)
Initializes this by copying its information from another TypeLoc of the same type.
Definition: TypeLoc.h:198
DeclaratorContext getContext() const
Definition: DeclSpec.h:1889
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1134
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:583
void setLocation(SourceLocation L)
Definition: Token.h:134
QualType getType() const
Definition: Decl.h:647
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:128
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:339
bool isFloatingType() const
Definition: Type.cpp:1952
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:374
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3062
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Expr.cpp:1522
IncompatibleObjCQualifiedId - The assignment is between a qualified id type and something else (that ...
Definition: Sema.h:9934
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
Definition: SemaExpr.cpp:16862
This represents a decl that may have a name.
Definition: Decl.h:248
void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc)
Specify that this unqualified-id was parsed as an identifier.
Definition: DeclSpec.h:1033
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
bool hasCustomTypechecking(unsigned ID) const
Determines whether this builtin has custom typechecking.
Definition: Builtins.h:159
ExprResult BuildVectorLiteral(SourceLocation LParenLoc, SourceLocation RParenLoc, Expr *E, TypeSourceInfo *TInfo)
Build an altivec or OpenCL literal.
Definition: SemaExpr.cpp:6592
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Definition: Expr.h:1244
CanQualType BoolTy
Definition: ASTContext.h:1015
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3003
bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc, CallExpr *CE, FunctionDecl *FD)
CheckCallReturnType - Checks that a call expression&#39;s return type is complete.
Definition: SemaExpr.cpp:16734
No keyword precedes the qualified type name.
Definition: Type.h:5141
bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1794
ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr)
Definition: SemaExpr.cpp:12979
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1368
APSInt & getInt()
Definition: APValue.h:336
AccessControl getAccessControl() const
Definition: DeclObjC.h:1983
iterator begin() const
Definition: Lookup.h:335
CanQualType DoubleTy
Definition: ASTContext.h:1026
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parenthese and casts which do not change the value (including ptr->int casts of the sam...
Definition: Expr.cpp:2969
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:606
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
Definition: ASTContext.h:2059
Describes an entity that is being initialized.
bool isFunctionPointerType() const
Definition: Type.h:6408
unsigned NumArgs
NumArgs - The number of template arguments.
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:524
ComparisonCategoryType
An enumeration representing the different comparison categories types.
void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, ArrayRef< Expr *> Args)
DiagnoseSentinelCalls - This routine checks whether a call or message-send is to a declaration with t...
Definition: SemaExpr.cpp:340
void setToType(unsigned Idx, QualType T)
Definition: Overload.h:305
EnableIfAttr * CheckEnableIf(FunctionDecl *Function, ArrayRef< Expr *> Args, bool MissingImplicitThis=false)
Check the enable_if expressions on the given function.
static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc)
Definition: SemaExpr.cpp:84
static bool checkOpenCLConditionVector(Sema &S, Expr *Cond, SourceLocation QuestionLoc)
Return false if this is a valid OpenCL condition vector.
Definition: SemaExpr.cpp:7102
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3138
void setType(QualType newType)
Definition: Decl.h:648
void removeAddressSpace()
Definition: Type.h:378
static void CheckCompleteParameterTypesForMangler(Sema &S, FunctionDecl *FD, SourceLocation Loc)
Require that all of the parameter types of function be complete.
Definition: SemaExpr.cpp:14920
static bool isComparisonOp(Opcode Opc)
Definition: Expr.h:3495
static OpaquePtr getFromOpaquePtr(void *P)
Definition: Ownership.h:91
bool hasInit() const
Definition: Decl.cpp:2198
SourceLocation getBegin() const
AssignmentAction
Definition: Sema.h:2703
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:107
const LangOptions & getLangOpts() const
Definition: ASTContext.h:710
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
Definition: DeclBase.cpp:1049
void WillReplaceSpecifier(bool ForceReplacement)
static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool Nested, Sema &S, bool Invalid)
Definition: SemaExpr.cpp:15411
bool isBlockCapture() const
Definition: ScopeInfo.h:585
An implicit &#39;self&#39; parameter.
The lookup resulted in an error.
Definition: Sema.h:3298
static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, SourceLocation OpLoc)
Check if a bitwise-& is performed on an Objective-C pointer.
Definition: SemaExpr.cpp:12332
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2904
static bool IsArithmeticOp(BinaryOperatorKind Opc)
Definition: SemaExpr.cpp:7488
IncompatibleNestedPointerQualifiers - The assignment is between two nested pointer types...
Definition: Sema.h:9917
QualType isPromotableBitField(Expr *E) const
Whether this is a promotable bitfield reference according to C99 6.3.1.1p2, bullet 2 (and GCC extensi...
Declaration of a template function.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:592
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3498
static bool isImplicitlyDefinableConstexprFunction(FunctionDecl *Func)
Definition: SemaExpr.cpp:15005
The current expression occurs within a braced-init-list within an unevaluated operand.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant()...
Definition: Expr.h:704
One specifier in an expression.
Definition: Availability.h:30
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1978
Attr - This represents one attribute.
Definition: Attr.h:43
SourceLocation getLocation() const
Definition: DeclBase.h:429
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type...
Definition: Type.h:1889
CastType
Definition: SemaCast.cpp:45
QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, bool IsCompAssign=false)
UsualArithmeticConversions - Performs various conversions that are common to binary operators (C99 6...
Definition: SemaExpr.cpp:1338
void startToken()
Reset all flags to cleared.
Definition: Token.h:171
ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, LabelDecl *TheDecl)
ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Definition: SemaExpr.cpp:13411
bool isExternallyVisible() const
Definition: Decl.h:379
QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc)
CheckAddressOfOperand - The operand of & must be either a function designator or an lvalue designatin...
Definition: SemaExpr.cpp:11937
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
bool isEditorPlaceholder() const
Return true if this identifier is an editor placeholder.
ParsedTemplateTy Template
The declaration of the template corresponding to the template-name.
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:366
static void diagnoseArithmeticOnNullPointer(Sema &S, SourceLocation Loc, Expr *Pointer, bool IsGNUIdiom)
Diagnose invalid arithmetic on a null pointer.
Definition: SemaExpr.cpp:9178
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth, signed/unsigned.
void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope)
ActOnBlockError - If there is an error parsing a block, this callback is invoked to pop the informati...
Definition: SemaExpr.cpp:13872
static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, const NamedDecl *D, SourceLocation Loc)
Check whether we&#39;re in an extern inline function and referring to a variable or function with interna...
Definition: SemaExpr.cpp:144
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1315
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2938
OriginalExprKind
Definition: SemaExpr.cpp:11305
CanQualType UnsignedIntTy
Definition: ASTContext.h:1024
SourceLocation getPointOfInstantiation() const
Retrieve the (first) point of instantiation of a function template specialization or a member of a cl...
Definition: Decl.cpp:3716
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1063
static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp)
Definition: SemaExpr.cpp:12153
A RAII object to temporarily push a declaration context.
Definition: Sema.h:768
VariadicCallType getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, Expr *Fn)
Definition: SemaExpr.cpp:4902
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5880
StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1).
Definition: Overload.h:229
static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, bool IsReal)
Definition: SemaExpr.cpp:4227