clang 20.0.0git
Expr.h
Go to the documentation of this file.
1//===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===//
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 defines the Expr interface and subclasses.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_EXPR_H
14#define LLVM_CLANG_AST_EXPR_H
15
17#include "clang/AST/APValue.h"
18#include "clang/AST/ASTVector.h"
20#include "clang/AST/Decl.h"
24#include "clang/AST/Stmt.h"
26#include "clang/AST/Type.h"
31#include "llvm/ADT/APFloat.h"
32#include "llvm/ADT/APSInt.h"
33#include "llvm/ADT/SmallVector.h"
34#include "llvm/ADT/StringRef.h"
35#include "llvm/ADT/iterator.h"
36#include "llvm/ADT/iterator_range.h"
37#include "llvm/Support/AtomicOrdering.h"
38#include "llvm/Support/Compiler.h"
39#include "llvm/Support/TrailingObjects.h"
40#include <optional>
41
42namespace clang {
43 class APValue;
44 class ASTContext;
45 class BlockDecl;
46 class CXXBaseSpecifier;
47 class CXXMemberCallExpr;
48 class CXXOperatorCallExpr;
49 class CastExpr;
50 class Decl;
51 class IdentifierInfo;
52 class MaterializeTemporaryExpr;
53 class NamedDecl;
54 class ObjCPropertyRefExpr;
55 class OpaqueValueExpr;
56 class ParmVarDecl;
57 class StringLiteral;
58 class TargetInfo;
59 class ValueDecl;
60
61/// A simple array of base specifiers.
62typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
63
64/// An adjustment to be made to the temporary created when emitting a
65/// reference binding, which accesses a particular subobject of that temporary.
67 enum {
72
73 struct DTB {
76 };
77
78 struct P {
81 };
82
83 union {
86 struct P Ptr;
87 };
88
90 const CXXRecordDecl *DerivedClass)
92 DerivedToBase.BasePath = BasePath;
93 DerivedToBase.DerivedClass = DerivedClass;
94 }
95
97 this->Field = Field;
98 }
99
102 this->Ptr.MPT = MPT;
103 this->Ptr.RHS = RHS;
104 }
105};
106
107/// This represents one expression. Note that Expr's are subclasses of Stmt.
108/// This allows an expression to be transparently used any place a Stmt is
109/// required.
110class Expr : public ValueStmt {
111 QualType TR;
112
113public:
114 Expr() = delete;
115 Expr(const Expr&) = delete;
116 Expr(Expr &&) = delete;
117 Expr &operator=(const Expr&) = delete;
118 Expr &operator=(Expr&&) = delete;
119
120protected:
122 : ValueStmt(SC) {
123 ExprBits.Dependent = 0;
124 ExprBits.ValueKind = VK;
125 ExprBits.ObjectKind = OK;
126 assert(ExprBits.ObjectKind == OK && "truncated kind");
127 setType(T);
128 }
129
130 /// Construct an empty expression.
131 explicit Expr(StmtClass SC, EmptyShell) : ValueStmt(SC) { }
132
133 /// Each concrete expr subclass is expected to compute its dependence and call
134 /// this in the constructor.
136 ExprBits.Dependent = static_cast<unsigned>(Deps);
137 }
138 friend class ASTImporter; // Sets dependence directly.
139 friend class ASTStmtReader; // Sets dependence directly.
140
141public:
142 QualType getType() const { return TR; }
144 // In C++, the type of an expression is always adjusted so that it
145 // will not have reference type (C++ [expr]p6). Use
146 // QualType::getNonReferenceType() to retrieve the non-reference
147 // type. Additionally, inspect Expr::isLvalue to determine whether
148 // an expression that is adjusted in this manner should be
149 // considered an lvalue.
150 assert((t.isNull() || !t->isReferenceType()) &&
151 "Expressions can't have reference type");
152
153 TR = t;
154 }
155
156 /// If this expression is an enumeration constant, return the
157 /// enumeration type under which said constant was declared.
158 /// Otherwise return the expression's type.
159 /// Note this effectively circumvents the weak typing of C's enum constants
160 QualType getEnumCoercedType(const ASTContext &Ctx) const;
161
163 return static_cast<ExprDependence>(ExprBits.Dependent);
164 }
165
166 /// Determines whether the value of this expression depends on
167 /// - a template parameter (C++ [temp.dep.constexpr])
168 /// - or an error, whose resolution is unknown
169 ///
170 /// For example, the array bound of "Chars" in the following example is
171 /// value-dependent.
172 /// @code
173 /// template<int Size, char (&Chars)[Size]> struct meta_string;
174 /// @endcode
175 bool isValueDependent() const {
176 return static_cast<bool>(getDependence() & ExprDependence::Value);
177 }
178
179 /// Determines whether the type of this expression depends on
180 /// - a template parameter (C++ [temp.dep.expr], which means that its type
181 /// could change from one template instantiation to the next)
182 /// - or an error
183 ///
184 /// For example, the expressions "x" and "x + y" are type-dependent in
185 /// the following code, but "y" is not type-dependent:
186 /// @code
187 /// template<typename T>
188 /// void add(T x, int y) {
189 /// x + y;
190 /// }
191 /// @endcode
192 bool isTypeDependent() const {
193 return static_cast<bool>(getDependence() & ExprDependence::Type);
194 }
195
196 /// Whether this expression is instantiation-dependent, meaning that
197 /// it depends in some way on
198 /// - a template parameter (even if neither its type nor (constant) value
199 /// can change due to the template instantiation)
200 /// - or an error
201 ///
202 /// In the following example, the expression \c sizeof(sizeof(T() + T())) is
203 /// instantiation-dependent (since it involves a template parameter \c T), but
204 /// is neither type- nor value-dependent, since the type of the inner
205 /// \c sizeof is known (\c std::size_t) and therefore the size of the outer
206 /// \c sizeof is known.
207 ///
208 /// \code
209 /// template<typename T>
210 /// void f(T x, T y) {
211 /// sizeof(sizeof(T() + T());
212 /// }
213 /// \endcode
214 ///
215 /// \code
216 /// void func(int) {
217 /// func(); // the expression is instantiation-dependent, because it depends
218 /// // on an error.
219 /// }
220 /// \endcode
222 return static_cast<bool>(getDependence() & ExprDependence::Instantiation);
223 }
224
225 /// Whether this expression contains an unexpanded parameter
226 /// pack (for C++11 variadic templates).
227 ///
228 /// Given the following function template:
229 ///
230 /// \code
231 /// template<typename F, typename ...Types>
232 /// void forward(const F &f, Types &&...args) {
233 /// f(static_cast<Types&&>(args)...);
234 /// }
235 /// \endcode
236 ///
237 /// The expressions \c args and \c static_cast<Types&&>(args) both
238 /// contain parameter packs.
240 return static_cast<bool>(getDependence() & ExprDependence::UnexpandedPack);
241 }
242
243 /// Whether this expression contains subexpressions which had errors, e.g. a
244 /// TypoExpr.
245 bool containsErrors() const {
246 return static_cast<bool>(getDependence() & ExprDependence::Error);
247 }
248
249 /// getExprLoc - Return the preferred location for the arrow when diagnosing
250 /// a problem with a generic expression.
251 SourceLocation getExprLoc() const LLVM_READONLY;
252
253 /// Determine whether an lvalue-to-rvalue conversion should implicitly be
254 /// applied to this expression if it appears as a discarded-value expression
255 /// in C++11 onwards. This applies to certain forms of volatile glvalues.
257
258 /// isUnusedResultAWarning - Return true if this immediate expression should
259 /// be warned about if the result is unused. If so, fill in expr, location,
260 /// and ranges with expr to warn on and source locations/ranges appropriate
261 /// for a warning.
262 bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc,
263 SourceRange &R1, SourceRange &R2,
264 ASTContext &Ctx) const;
265
266 /// isLValue - True if this expression is an "l-value" according to
267 /// the rules of the current language. C and C++ give somewhat
268 /// different rules for this concept, but in general, the result of
269 /// an l-value expression identifies a specific object whereas the
270 /// result of an r-value expression is a value detached from any
271 /// specific storage.
272 ///
273 /// C++11 divides the concept of "r-value" into pure r-values
274 /// ("pr-values") and so-called expiring values ("x-values"), which
275 /// identify specific objects that can be safely cannibalized for
276 /// their resources.
277 bool isLValue() const { return getValueKind() == VK_LValue; }
278 bool isPRValue() const { return getValueKind() == VK_PRValue; }
279 bool isXValue() const { return getValueKind() == VK_XValue; }
280 bool isGLValue() const { return getValueKind() != VK_PRValue; }
281
293 };
294 /// Reasons why an expression might not be an l-value.
296
303 MLV_LValueCast, // Specialized form of MLV_InvalidExpression.
315 };
316 /// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
317 /// does not have an incomplete type, does not have a const-qualified type,
318 /// and if it is a structure or union, does not have any member (including,
319 /// recursively, any member or element of all contained aggregates or unions)
320 /// with a const-qualified type.
321 ///
322 /// \param Loc [in,out] - A source location which *may* be filled
323 /// in with the location of the expression making this a
324 /// non-modifiable lvalue, if specified.
326 isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc = nullptr) const;
327
328 /// The return type of classify(). Represents the C++11 expression
329 /// taxonomy.
331 public:
332 /// The various classification results. Most of these mean prvalue.
333 enum Kinds {
336 CL_Function, // Functions cannot be lvalues in C.
337 CL_Void, // Void cannot be an lvalue in C.
338 CL_AddressableVoid, // Void expression whose address can be taken in C.
339 CL_DuplicateVectorComponents, // A vector shuffle with dupes.
340 CL_MemberFunction, // An expression referring to a member function
342 CL_ClassTemporary, // A temporary of class type, or subobject thereof.
343 CL_ArrayTemporary, // A temporary of array type.
344 CL_ObjCMessageRValue, // ObjC message is an rvalue
345 CL_PRValue // A prvalue for any other reason, of any other type
346 };
347 /// The results of modification testing.
349 CM_Untested, // testModifiable was false.
351 CM_RValue, // Not modifiable because it's an rvalue
352 CM_Function, // Not modifiable because it's a function; C++ only
353 CM_LValueCast, // Same as CM_RValue, but indicates GCC cast-as-lvalue ext
354 CM_NoSetterProperty,// Implicit assignment to ObjC property without setter
360 };
361
362 private:
363 friend class Expr;
364
365 unsigned short Kind;
366 unsigned short Modifiable;
367
368 explicit Classification(Kinds k, ModifiableType m)
369 : Kind(k), Modifiable(m)
370 {}
371
372 public:
374
375 Kinds getKind() const { return static_cast<Kinds>(Kind); }
377 assert(Modifiable != CM_Untested && "Did not test for modifiability.");
378 return static_cast<ModifiableType>(Modifiable);
379 }
380 bool isLValue() const { return Kind == CL_LValue; }
381 bool isXValue() const { return Kind == CL_XValue; }
382 bool isGLValue() const { return Kind <= CL_XValue; }
383 bool isPRValue() const { return Kind >= CL_Function; }
384 bool isRValue() const { return Kind >= CL_XValue; }
385 bool isModifiable() const { return getModifiable() == CM_Modifiable; }
386
387 /// Create a simple, modifiable lvalue
390 }
391
392 };
393 /// Classify - Classify this expression according to the C++11
394 /// expression taxonomy.
395 ///
396 /// C++11 defines ([basic.lval]) a new taxonomy of expressions to replace the
397 /// old lvalue vs rvalue. This function determines the type of expression this
398 /// is. There are three expression types:
399 /// - lvalues are classical lvalues as in C++03.
400 /// - prvalues are equivalent to rvalues in C++03.
401 /// - xvalues are expressions yielding unnamed rvalue references, e.g. a
402 /// function returning an rvalue reference.
403 /// lvalues and xvalues are collectively referred to as glvalues, while
404 /// prvalues and xvalues together form rvalues.
406 return ClassifyImpl(Ctx, nullptr);
407 }
408
409 /// ClassifyModifiable - Classify this expression according to the
410 /// C++11 expression taxonomy, and see if it is valid on the left side
411 /// of an assignment.
412 ///
413 /// This function extends classify in that it also tests whether the
414 /// expression is modifiable (C99 6.3.2.1p1).
415 /// \param Loc A source location that might be filled with a relevant location
416 /// if the expression is not modifiable.
418 return ClassifyImpl(Ctx, &Loc);
419 }
420
421 /// Returns the set of floating point options that apply to this expression.
422 /// Only meaningful for operations on floating point values.
424
425 /// getValueKindForType - Given a formal return or parameter type,
426 /// give its value kind.
428 if (const ReferenceType *RT = T->getAs<ReferenceType>())
429 return (isa<LValueReferenceType>(RT)
430 ? VK_LValue
431 : (RT->getPointeeType()->isFunctionType()
432 ? VK_LValue : VK_XValue));
433 return VK_PRValue;
434 }
435
436 /// getValueKind - The value kind that this expression produces.
438 return static_cast<ExprValueKind>(ExprBits.ValueKind);
439 }
440
441 /// getObjectKind - The object kind that this expression produces.
442 /// Object kinds are meaningful only for expressions that yield an
443 /// l-value or x-value.
445 return static_cast<ExprObjectKind>(ExprBits.ObjectKind);
446 }
447
450 return (OK == OK_Ordinary || OK == OK_BitField);
451 }
452
453 /// setValueKind - Set the value kind produced by this expression.
454 void setValueKind(ExprValueKind Cat) { ExprBits.ValueKind = Cat; }
455
456 /// setObjectKind - Set the object kind produced by this expression.
457 void setObjectKind(ExprObjectKind Cat) { ExprBits.ObjectKind = Cat; }
458
459private:
460 Classification ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const;
461
462public:
463
464 /// Returns true if this expression is a gl-value that
465 /// potentially refers to a bit-field.
466 ///
467 /// In C++, whether a gl-value refers to a bitfield is essentially
468 /// an aspect of the value-kind type system.
469 bool refersToBitField() const { return getObjectKind() == OK_BitField; }
470
471 /// If this expression refers to a bit-field, retrieve the
472 /// declaration of that bit-field.
473 ///
474 /// Note that this returns a non-null pointer in subtly different
475 /// places than refersToBitField returns true. In particular, this can
476 /// return a non-null pointer even for r-values loaded from
477 /// bit-fields, but it will return null for a conditional bit-field.
479
480 /// If this expression refers to an enum constant, retrieve its declaration
482
484 return const_cast<Expr *>(this)->getEnumConstantDecl();
485 }
486
488 return const_cast<Expr*>(this)->getSourceBitField();
489 }
490
493 return const_cast<Expr*>(this)->getReferencedDeclOfCallee();
494 }
495
496 /// If this expression is an l-value for an Objective C
497 /// property, find the underlying property reference expression.
499
500 /// Check if this expression is the ObjC 'self' implicit parameter.
501 bool isObjCSelfExpr() const;
502
503 /// Returns whether this expression refers to a vector element.
504 bool refersToVectorElement() const;
505
506 /// Returns whether this expression refers to a matrix element.
509 }
510
511 /// Returns whether this expression refers to a global register
512 /// variable.
513 bool refersToGlobalRegisterVar() const;
514
515 /// Returns whether this expression has a placeholder type.
516 bool hasPlaceholderType() const {
517 return getType()->isPlaceholderType();
518 }
519
520 /// Returns whether this expression has a specific placeholder type.
523 if (const BuiltinType *BT = dyn_cast<BuiltinType>(getType()))
524 return BT->getKind() == K;
525 return false;
526 }
527
528 /// isKnownToHaveBooleanValue - Return true if this is an integer expression
529 /// that is known to return 0 or 1. This happens for _Bool/bool expressions
530 /// but also int expressions which are produced by things like comparisons in
531 /// C.
532 ///
533 /// \param Semantic If true, only return true for expressions that are known
534 /// to be semantically boolean, which might not be true even for expressions
535 /// that are known to evaluate to 0/1. For instance, reading an unsigned
536 /// bit-field with width '1' will evaluate to 0/1, but doesn't necessarily
537 /// semantically correspond to a bool.
538 bool isKnownToHaveBooleanValue(bool Semantic = true) const;
539
540 /// Check whether this array fits the idiom of a flexible array member,
541 /// depending on the value of -fstrict-flex-array.
542 /// When IgnoreTemplateOrMacroSubstitution is set, it doesn't consider sizes
543 /// resulting from the substitution of a macro or a template as special sizes.
545 ASTContext &Context,
546 LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel,
547 bool IgnoreTemplateOrMacroSubstitution = false) const;
548
549 /// isIntegerConstantExpr - Return the value if this expression is a valid
550 /// integer constant expression. If not a valid i-c-e, return std::nullopt
551 /// and fill in Loc (if specified) with the location of the invalid
552 /// expression.
553 ///
554 /// Note: This does not perform the implicit conversions required by C++11
555 /// [expr.const]p5.
556 std::optional<llvm::APSInt>
558 SourceLocation *Loc = nullptr) const;
559 bool isIntegerConstantExpr(const ASTContext &Ctx,
560 SourceLocation *Loc = nullptr) const;
561
562 /// isCXX98IntegralConstantExpr - Return true if this expression is an
563 /// integral constant expression in C++98. Can only be used in C++.
564 bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const;
565
566 /// isCXX11ConstantExpr - Return true if this expression is a constant
567 /// expression in C++11. Can only be used in C++.
568 ///
569 /// Note: This does not perform the implicit conversions required by C++11
570 /// [expr.const]p5.
571 bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result = nullptr,
572 SourceLocation *Loc = nullptr) const;
573
574 /// isPotentialConstantExpr - Return true if this function's definition
575 /// might be usable in a constant expression in C++11, if it were marked
576 /// constexpr. Return false if the function can never produce a constant
577 /// expression, along with diagnostics describing why not.
578 static bool isPotentialConstantExpr(const FunctionDecl *FD,
580 PartialDiagnosticAt> &Diags);
581
582 /// isPotentialConstantExprUnevaluated - Return true if this expression might
583 /// be usable in a constant expression in C++11 in an unevaluated context, if
584 /// it were in function FD marked constexpr. Return false if the function can
585 /// never produce a constant expression, along with diagnostics describing
586 /// why not.
588 const FunctionDecl *FD,
590 PartialDiagnosticAt> &Diags);
591
592 /// isConstantInitializer - Returns true if this expression can be emitted to
593 /// IR as a constant, and thus can be used as a constant initializer in C.
594 /// If this expression is not constant and Culprit is non-null,
595 /// it is used to store the address of first non constant expr.
596 bool isConstantInitializer(ASTContext &Ctx, bool ForRef,
597 const Expr **Culprit = nullptr) const;
598
599 /// If this expression is an unambiguous reference to a single declaration,
600 /// in the style of __builtin_function_start, return that declaration. Note
601 /// that this may return a non-static member function or field in C++ if this
602 /// expression is a member pointer constant.
603 const ValueDecl *getAsBuiltinConstantDeclRef(const ASTContext &Context) const;
604
605 /// EvalStatus is a struct with detailed info about an evaluation in progress.
606 struct EvalStatus {
607 /// Whether the evaluated expression has side effects.
608 /// For example, (f() && 0) can be folded, but it still has side effects.
609 bool HasSideEffects = false;
610
611 /// Whether the evaluation hit undefined behavior.
612 /// For example, 1.0 / 0.0 can be folded to Inf, but has undefined behavior.
613 /// Likewise, INT_MAX + 1 can be folded to INT_MIN, but has UB.
615
616 /// Diag - If this is non-null, it will be filled in with a stack of notes
617 /// indicating why evaluation failed (or why it failed to produce a constant
618 /// expression).
619 /// If the expression is unfoldable, the notes will indicate why it's not
620 /// foldable. If the expression is foldable, but not a constant expression,
621 /// the notes will describes why it isn't a constant expression. If the
622 /// expression *is* a constant expression, no notes will be produced.
623 ///
624 /// FIXME: this causes significant performance concerns and should be
625 /// refactored at some point. Not all evaluations of the constant
626 /// expression interpreter will display the given diagnostics, this means
627 /// those kinds of uses are paying the expense of generating a diagnostic
628 /// (which may include expensive operations like converting APValue objects
629 /// to a string representation).
631
632 EvalStatus() = default;
633
634 // hasSideEffects - Return true if the evaluated expression has
635 // side effects.
636 bool hasSideEffects() const {
637 return HasSideEffects;
638 }
639 };
640
641 /// EvalResult is a struct with detailed info about an evaluated expression.
643 /// Val - This is the value the expression can be folded to.
645
646 // isGlobalLValue - Return true if the evaluated lvalue expression
647 // is global.
648 bool isGlobalLValue() const;
649 };
650
651 /// EvaluateAsRValue - Return true if this is a constant which we can fold to
652 /// an rvalue using any crazy technique (that has nothing to do with language
653 /// standards) that we want to, even if the expression has side-effects. If
654 /// this function returns true, it returns the folded constant in Result. If
655 /// the expression is a glvalue, an lvalue-to-rvalue conversion will be
656 /// applied.
658 bool InConstantContext = false) const;
659
660 /// EvaluateAsBooleanCondition - Return true if this is a constant
661 /// which we can fold and convert to a boolean condition using
662 /// any crazy technique that we want to, even if the expression has
663 /// side-effects.
664 bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx,
665 bool InConstantContext = false) const;
666
668 SE_NoSideEffects, ///< Strictly evaluate the expression.
669 SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not
670 ///< arbitrary unmodeled side effects.
671 SE_AllowSideEffects ///< Allow any unmodeled side effect.
672 };
673
674 /// EvaluateAsInt - Return true if this is a constant which we can fold and
675 /// convert to an integer, using any crazy technique that we want to.
676 bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
677 SideEffectsKind AllowSideEffects = SE_NoSideEffects,
678 bool InConstantContext = false) const;
679
680 /// EvaluateAsFloat - Return true if this is a constant which we can fold and
681 /// convert to a floating point value, using any crazy technique that we
682 /// want to.
683 bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx,
684 SideEffectsKind AllowSideEffects = SE_NoSideEffects,
685 bool InConstantContext = false) const;
686
687 /// EvaluateAsFixedPoint - Return true if this is a constant which we can fold
688 /// and convert to a fixed point value.
689 bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx,
690 SideEffectsKind AllowSideEffects = SE_NoSideEffects,
691 bool InConstantContext = false) const;
692
693 /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
694 /// constant folded without side-effects, but discard the result.
695 bool isEvaluatable(const ASTContext &Ctx,
696 SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;
697
698 /// HasSideEffects - This routine returns true for all those expressions
699 /// which have any effect other than producing a value. Example is a function
700 /// call, volatile variable read, or throwing an exception. If
701 /// IncludePossibleEffects is false, this call treats certain expressions with
702 /// potential side effects (such as function call-like expressions,
703 /// instantiation-dependent expressions, or invocations from a macro) as not
704 /// having side effects.
705 bool HasSideEffects(const ASTContext &Ctx,
706 bool IncludePossibleEffects = true) const;
707
708 /// Determine whether this expression involves a call to any function
709 /// that is not trivial.
710 bool hasNonTrivialCall(const ASTContext &Ctx) const;
711
712 /// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded
713 /// integer. This must be called on an expression that constant folds to an
714 /// integer.
715 llvm::APSInt EvaluateKnownConstInt(
716 const ASTContext &Ctx,
718
720 const ASTContext &Ctx,
722
723 void EvaluateForOverflow(const ASTContext &Ctx) const;
724
725 /// EvaluateAsLValue - Evaluate an expression to see if we can fold it to an
726 /// lvalue with link time known address, with no side-effects.
727 bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,
728 bool InConstantContext = false) const;
729
730 /// EvaluateAsInitializer - Evaluate an expression as if it were the
731 /// initializer of the given declaration. Returns true if the initializer
732 /// can be folded to a constant, and produces any relevant notes. In C++11,
733 /// notes will be produced if the expression is not a constant expression.
735 const VarDecl *VD,
737 bool IsConstantInitializer) const;
738
739 /// EvaluateWithSubstitution - Evaluate an expression as if from the context
740 /// of a call to the given function with the given arguments, inside an
741 /// unevaluated context. Returns true if the expression could be folded to a
742 /// constant.
744 const FunctionDecl *Callee,
746 const Expr *This = nullptr) const;
747
748 enum class ConstantExprKind {
749 /// An integer constant expression (an array bound, enumerator, case value,
750 /// bit-field width, or similar) or similar.
751 Normal,
752 /// A non-class template argument. Such a value is only used for mangling,
753 /// not for code generation, so can refer to dllimported functions.
755 /// A class template argument. Such a value is used for code generation.
757 /// An immediate invocation. The destruction of the end result of this
758 /// evaluation is not part of the evaluation, but all other temporaries
759 /// are destroyed.
761 };
762
763 /// Evaluate an expression that is required to be a constant expression. Does
764 /// not check the syntactic constraints for C and C++98 constant expressions.
766 EvalResult &Result, const ASTContext &Ctx,
767 ConstantExprKind Kind = ConstantExprKind::Normal) const;
768
769 /// If the current Expr is a pointer, this will try to statically
770 /// determine the number of bytes available where the pointer is pointing.
771 /// Returns true if all of the above holds and we were able to figure out the
772 /// size, false otherwise.
773 ///
774 /// \param Type - How to evaluate the size of the Expr, as defined by the
775 /// "type" parameter of __builtin_object_size
776 bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
777 unsigned Type) const;
778
779 /// If the current Expr is a pointer, this will try to statically
780 /// determine the strlen of the string pointed to.
781 /// Returns true if all of the above holds and we were able to figure out the
782 /// strlen, false otherwise.
783 bool tryEvaluateStrLen(uint64_t &Result, ASTContext &Ctx) const;
784
785 bool EvaluateCharRangeAsString(std::string &Result,
786 const Expr *SizeExpression,
787 const Expr *PtrExpression, ASTContext &Ctx,
788 EvalResult &Status) const;
789
790 /// If the current Expr can be evaluated to a pointer to a null-terminated
791 /// constant string, return the constant string (without the terminating
792 /// null).
793 std::optional<std::string> tryEvaluateString(ASTContext &Ctx) const;
794
795 /// Enumeration used to describe the kind of Null pointer constant
796 /// returned from \c isNullPointerConstant().
798 /// Expression is not a Null pointer constant.
800
801 /// Expression is a Null pointer constant built from a zero integer
802 /// expression that is not a simple, possibly parenthesized, zero literal.
803 /// C++ Core Issue 903 will classify these expressions as "not pointers"
804 /// once it is adopted.
805 /// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
807
808 /// Expression is a Null pointer constant built from a literal zero.
810
811 /// Expression is a C++11 nullptr.
813
814 /// Expression is a GNU-style __null constant.
816 };
817
818 /// Enumeration used to describe how \c isNullPointerConstant()
819 /// should cope with value-dependent expressions.
821 /// Specifies that the expression should never be value-dependent.
823
824 /// Specifies that a value-dependent expression of integral or
825 /// dependent type should be considered a null pointer constant.
827
828 /// Specifies that a value-dependent expression should be considered
829 /// to never be a null pointer constant.
831 };
832
833 /// isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to
834 /// a Null pointer constant. The return value can further distinguish the
835 /// kind of NULL pointer constant that was detected.
837 ASTContext &Ctx,
839
840 /// isOBJCGCCandidate - Return true if this expression may be used in a read/
841 /// write barrier.
842 bool isOBJCGCCandidate(ASTContext &Ctx) const;
843
844 /// Returns true if this expression is a bound member function.
845 bool isBoundMemberFunction(ASTContext &Ctx) const;
846
847 /// Given an expression of bound-member type, find the type
848 /// of the member. Returns null if this is an *overloaded* bound
849 /// member expression.
850 static QualType findBoundMemberType(const Expr *expr);
851
852 /// Skip past any invisible AST nodes which might surround this
853 /// statement, such as ExprWithCleanups or ImplicitCastExpr nodes,
854 /// but also injected CXXMemberExpr and CXXConstructExpr which represent
855 /// implicit conversions.
858 return const_cast<Expr *>(this)->IgnoreUnlessSpelledInSource();
859 }
860
861 /// Skip past any implicit casts which might surround this expression until
862 /// reaching a fixed point. Skips:
863 /// * ImplicitCastExpr
864 /// * FullExpr
865 Expr *IgnoreImpCasts() LLVM_READONLY;
866 const Expr *IgnoreImpCasts() const {
867 return const_cast<Expr *>(this)->IgnoreImpCasts();
868 }
869
870 /// Skip past any casts which might surround this expression until reaching
871 /// a fixed point. Skips:
872 /// * CastExpr
873 /// * FullExpr
874 /// * MaterializeTemporaryExpr
875 /// * SubstNonTypeTemplateParmExpr
876 Expr *IgnoreCasts() LLVM_READONLY;
877 const Expr *IgnoreCasts() const {
878 return const_cast<Expr *>(this)->IgnoreCasts();
879 }
880
881 /// Skip past any implicit AST nodes which might surround this expression
882 /// until reaching a fixed point. Skips:
883 /// * What IgnoreImpCasts() skips
884 /// * MaterializeTemporaryExpr
885 /// * CXXBindTemporaryExpr
886 Expr *IgnoreImplicit() LLVM_READONLY;
887 const Expr *IgnoreImplicit() const {
888 return const_cast<Expr *>(this)->IgnoreImplicit();
889 }
890
891 /// Skip past any implicit AST nodes which might surround this expression
892 /// until reaching a fixed point. Same as IgnoreImplicit, except that it
893 /// also skips over implicit calls to constructors and conversion functions.
894 ///
895 /// FIXME: Should IgnoreImplicit do this?
896 Expr *IgnoreImplicitAsWritten() LLVM_READONLY;
898 return const_cast<Expr *>(this)->IgnoreImplicitAsWritten();
899 }
900
901 /// Skip past any parentheses which might surround this expression until
902 /// reaching a fixed point. Skips:
903 /// * ParenExpr
904 /// * UnaryOperator if `UO_Extension`
905 /// * GenericSelectionExpr if `!isResultDependent()`
906 /// * ChooseExpr if `!isConditionDependent()`
907 /// * ConstantExpr
908 Expr *IgnoreParens() LLVM_READONLY;
909 const Expr *IgnoreParens() const {
910 return const_cast<Expr *>(this)->IgnoreParens();
911 }
912
913 /// Skip past any parentheses and implicit casts which might surround this
914 /// expression until reaching a fixed point.
915 /// FIXME: IgnoreParenImpCasts really ought to be equivalent to
916 /// IgnoreParens() + IgnoreImpCasts() until reaching a fixed point. However
917 /// this is currently not the case. Instead IgnoreParenImpCasts() skips:
918 /// * What IgnoreParens() skips
919 /// * What IgnoreImpCasts() skips
920 /// * MaterializeTemporaryExpr
921 /// * SubstNonTypeTemplateParmExpr
922 Expr *IgnoreParenImpCasts() LLVM_READONLY;
923 const Expr *IgnoreParenImpCasts() const {
924 return const_cast<Expr *>(this)->IgnoreParenImpCasts();
925 }
926
927 /// Skip past any parentheses and casts which might surround this expression
928 /// until reaching a fixed point. Skips:
929 /// * What IgnoreParens() skips
930 /// * What IgnoreCasts() skips
931 Expr *IgnoreParenCasts() LLVM_READONLY;
932 const Expr *IgnoreParenCasts() const {
933 return const_cast<Expr *>(this)->IgnoreParenCasts();
934 }
935
936 /// Skip conversion operators. If this Expr is a call to a conversion
937 /// operator, return the argument.
940 return const_cast<Expr *>(this)->IgnoreConversionOperatorSingleStep();
941 }
942
943 /// Skip past any parentheses and lvalue casts which might surround this
944 /// expression until reaching a fixed point. Skips:
945 /// * What IgnoreParens() skips
946 /// * What IgnoreCasts() skips, except that only lvalue-to-rvalue
947 /// casts are skipped
948 /// FIXME: This is intended purely as a temporary workaround for code
949 /// that hasn't yet been rewritten to do the right thing about those
950 /// casts, and may disappear along with the last internal use.
951 Expr *IgnoreParenLValueCasts() LLVM_READONLY;
953 return const_cast<Expr *>(this)->IgnoreParenLValueCasts();
954 }
955
956 /// Skip past any parentheses and casts which do not change the value
957 /// (including ptr->int casts of the same size) until reaching a fixed point.
958 /// Skips:
959 /// * What IgnoreParens() skips
960 /// * CastExpr which do not change the value
961 /// * SubstNonTypeTemplateParmExpr
962 Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY;
963 const Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) const {
964 return const_cast<Expr *>(this)->IgnoreParenNoopCasts(Ctx);
965 }
966
967 /// Skip past any parentheses and derived-to-base casts until reaching a
968 /// fixed point. Skips:
969 /// * What IgnoreParens() skips
970 /// * CastExpr which represent a derived-to-base cast (CK_DerivedToBase,
971 /// CK_UncheckedDerivedToBase and CK_NoOp)
972 Expr *IgnoreParenBaseCasts() LLVM_READONLY;
973 const Expr *IgnoreParenBaseCasts() const {
974 return const_cast<Expr *>(this)->IgnoreParenBaseCasts();
975 }
976
977 /// Determine whether this expression is a default function argument.
978 ///
979 /// Default arguments are implicitly generated in the abstract syntax tree
980 /// by semantic analysis for function calls, object constructions, etc. in
981 /// C++. Default arguments are represented by \c CXXDefaultArgExpr nodes;
982 /// this routine also looks through any implicit casts to determine whether
983 /// the expression is a default argument.
984 bool isDefaultArgument() const;
985
986 /// Determine whether the result of this expression is a
987 /// temporary object of the given class type.
988 bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const;
989
990 /// Whether this expression is an implicit reference to 'this' in C++.
991 bool isImplicitCXXThis() const;
992
994
995 /// For an expression of class type or pointer to class type,
996 /// return the most derived class decl the expression is known to refer to.
997 ///
998 /// If this expression is a cast, this method looks through it to find the
999 /// most derived decl that can be inferred from the expression.
1000 /// This is valid because derived-to-base conversions have undefined
1001 /// behavior if the object isn't dynamically of the derived type.
1003
1004 /// Get the inner expression that determines the best dynamic class.
1005 /// If this is a prvalue, we guarantee that it is of the most-derived type
1006 /// for the object itself.
1007 const Expr *getBestDynamicClassTypeExpr() const;
1008
1009 /// Walk outwards from an expression we want to bind a reference to and
1010 /// find the expression whose lifetime needs to be extended. Record
1011 /// the LHSs of comma expressions and adjustments needed along the path.
1014 SmallVectorImpl<SubobjectAdjustment> &Adjustments) const;
1018 return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
1019 }
1020
1021 /// Checks that the two Expr's will refer to the same value as a comparison
1022 /// operand. The caller must ensure that the values referenced by the Expr's
1023 /// are not modified between E1 and E2 or the result my be invalid.
1024 static bool isSameComparisonOperand(const Expr* E1, const Expr* E2);
1025
1026 static bool classof(const Stmt *T) {
1027 return T->getStmtClass() >= firstExprConstant &&
1028 T->getStmtClass() <= lastExprConstant;
1029 }
1030};
1031// PointerLikeTypeTraits is specialized so it can be used with a forward-decl of
1032// Expr. Verify that we got it right.
1034 llvm::detail::ConstantLog2<alignof(Expr)>::value,
1035 "PointerLikeTypeTraits<Expr*> assumes too much alignment.");
1036
1038
1039//===----------------------------------------------------------------------===//
1040// Wrapper Expressions.
1041//===----------------------------------------------------------------------===//
1042
1043/// FullExpr - Represents a "full-expression" node.
1044class FullExpr : public Expr {
1045protected:
1047
1049 : Expr(SC, subexpr->getType(), subexpr->getValueKind(),
1050 subexpr->getObjectKind()),
1051 SubExpr(subexpr) {
1053 }
1055 : Expr(SC, Empty) {}
1056public:
1057 const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
1058 Expr *getSubExpr() { return cast<Expr>(SubExpr); }
1059
1060 /// As with any mutator of the AST, be very careful when modifying an
1061 /// existing AST to preserve its invariants.
1062 void setSubExpr(Expr *E) { SubExpr = E; }
1063
1064 static bool classof(const Stmt *T) {
1065 return T->getStmtClass() >= firstFullExprConstant &&
1066 T->getStmtClass() <= lastFullExprConstant;
1067 }
1068};
1069
1070/// Describes the kind of result that can be tail-allocated.
1072
1073/// ConstantExpr - An expression that occurs in a constant context and
1074/// optionally the result of evaluating the expression.
1075class ConstantExpr final
1076 : public FullExpr,
1077 private llvm::TrailingObjects<ConstantExpr, APValue, uint64_t> {
1078 static_assert(std::is_same<uint64_t, llvm::APInt::WordType>::value,
1079 "ConstantExpr assumes that llvm::APInt::WordType is uint64_t "
1080 "for tail-allocated storage");
1081 friend TrailingObjects;
1082 friend class ASTStmtReader;
1083 friend class ASTStmtWriter;
1084
1085 size_t numTrailingObjects(OverloadToken<APValue>) const {
1087 }
1088 size_t numTrailingObjects(OverloadToken<uint64_t>) const {
1090 }
1091
1092 uint64_t &Int64Result() {
1094 "invalid accessor");
1095 return *getTrailingObjects<uint64_t>();
1096 }
1097 const uint64_t &Int64Result() const {
1098 return const_cast<ConstantExpr *>(this)->Int64Result();
1099 }
1100 APValue &APValueResult() {
1102 "invalid accessor");
1103 return *getTrailingObjects<APValue>();
1104 }
1105 APValue &APValueResult() const {
1106 return const_cast<ConstantExpr *>(this)->APValueResult();
1107 }
1108
1109 ConstantExpr(Expr *SubExpr, ConstantResultStorageKind StorageKind,
1110 bool IsImmediateInvocation);
1111 ConstantExpr(EmptyShell Empty, ConstantResultStorageKind StorageKind);
1112
1113public:
1114 static ConstantExpr *Create(const ASTContext &Context, Expr *E,
1115 const APValue &Result);
1116 static ConstantExpr *
1117 Create(const ASTContext &Context, Expr *E,
1119 bool IsImmediateInvocation = false);
1120 static ConstantExpr *CreateEmpty(const ASTContext &Context,
1121 ConstantResultStorageKind StorageKind);
1122
1123 static ConstantResultStorageKind getStorageKind(const APValue &Value);
1125 const ASTContext &Context);
1126
1127 SourceLocation getBeginLoc() const LLVM_READONLY {
1128 return SubExpr->getBeginLoc();
1129 }
1130 SourceLocation getEndLoc() const LLVM_READONLY {
1131 return SubExpr->getEndLoc();
1132 }
1133
1134 static bool classof(const Stmt *T) {
1135 return T->getStmtClass() == ConstantExprClass;
1136 }
1137
1138 void SetResult(APValue Value, const ASTContext &Context) {
1139 MoveIntoResult(Value, Context);
1140 }
1141 void MoveIntoResult(APValue &Value, const ASTContext &Context);
1142
1144 return static_cast<APValue::ValueKind>(ConstantExprBits.APValueKind);
1145 }
1147 return static_cast<ConstantResultStorageKind>(ConstantExprBits.ResultKind);
1148 }
1150 return ConstantExprBits.IsImmediateInvocation;
1151 }
1152 bool hasAPValueResult() const {
1153 return ConstantExprBits.APValueKind != APValue::None;
1154 }
1155 APValue getAPValueResult() const;
1156 llvm::APSInt getResultAsAPSInt() const;
1157 // Iterators
1160 return const_child_range(&SubExpr, &SubExpr + 1);
1161 }
1162};
1163
1164//===----------------------------------------------------------------------===//
1165// Primary Expressions.
1166//===----------------------------------------------------------------------===//
1167
1168/// OpaqueValueExpr - An expression referring to an opaque object of a
1169/// fixed type and value class. These don't correspond to concrete
1170/// syntax; instead they're used to express operations (usually copy
1171/// operations) on values whose source is generally obvious from
1172/// context.
1173class OpaqueValueExpr : public Expr {
1174 friend class ASTStmtReader;
1175 Expr *SourceExpr;
1176
1177public:
1179 ExprObjectKind OK = OK_Ordinary, Expr *SourceExpr = nullptr)
1180 : Expr(OpaqueValueExprClass, T, VK, OK), SourceExpr(SourceExpr) {
1181 setIsUnique(false);
1184 }
1185
1186 /// Given an expression which invokes a copy constructor --- i.e. a
1187 /// CXXConstructExpr, possibly wrapped in an ExprWithCleanups ---
1188 /// find the OpaqueValueExpr that's the source of the construction.
1189 static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr);
1190
1192 : Expr(OpaqueValueExprClass, Empty) {}
1193
1194 /// Retrieve the location of this expression.
1196
1197 SourceLocation getBeginLoc() const LLVM_READONLY {
1198 return SourceExpr ? SourceExpr->getBeginLoc() : getLocation();
1199 }
1200 SourceLocation getEndLoc() const LLVM_READONLY {
1201 return SourceExpr ? SourceExpr->getEndLoc() : getLocation();
1202 }
1203 SourceLocation getExprLoc() const LLVM_READONLY {
1204 return SourceExpr ? SourceExpr->getExprLoc() : getLocation();
1205 }
1206
1209 }
1210
1213 }
1214
1215 /// The source expression of an opaque value expression is the
1216 /// expression which originally generated the value. This is
1217 /// provided as a convenience for analyses that don't wish to
1218 /// precisely model the execution behavior of the program.
1219 ///
1220 /// The source expression is typically set when building the
1221 /// expression which binds the opaque value expression in the first
1222 /// place.
1223 Expr *getSourceExpr() const { return SourceExpr; }
1224
1225 void setIsUnique(bool V) {
1226 assert((!V || SourceExpr) &&
1227 "unique OVEs are expected to have source expressions");
1228 OpaqueValueExprBits.IsUnique = V;
1229 }
1230
1231 bool isUnique() const { return OpaqueValueExprBits.IsUnique; }
1232
1233 static bool classof(const Stmt *T) {
1234 return T->getStmtClass() == OpaqueValueExprClass;
1235 }
1236};
1237
1238/// A reference to a declared variable, function, enum, etc.
1239/// [C99 6.5.1p2]
1240///
1241/// This encodes all the information about how a declaration is referenced
1242/// within an expression.
1243///
1244/// There are several optional constructs attached to DeclRefExprs only when
1245/// they apply in order to conserve memory. These are laid out past the end of
1246/// the object, and flags in the DeclRefExprBitfield track whether they exist:
1247///
1248/// DeclRefExprBits.HasQualifier:
1249/// Specifies when this declaration reference expression has a C++
1250/// nested-name-specifier.
1251/// DeclRefExprBits.HasFoundDecl:
1252/// Specifies when this declaration reference expression has a record of
1253/// a NamedDecl (different from the referenced ValueDecl) which was found
1254/// during name lookup and/or overload resolution.
1255/// DeclRefExprBits.HasTemplateKWAndArgsInfo:
1256/// Specifies when this declaration reference expression has an explicit
1257/// C++ template keyword and/or template argument list.
1258/// DeclRefExprBits.RefersToEnclosingVariableOrCapture
1259/// Specifies when this declaration reference expression (validly)
1260/// refers to an enclosed local or a captured variable.
1261class DeclRefExpr final
1262 : public Expr,
1263 private llvm::TrailingObjects<DeclRefExpr, NestedNameSpecifierLoc,
1264 NamedDecl *, ASTTemplateKWAndArgsInfo,
1265 TemplateArgumentLoc> {
1266 friend class ASTStmtReader;
1267 friend class ASTStmtWriter;
1268 friend TrailingObjects;
1269
1270 /// The declaration that we are referencing.
1271 ValueDecl *D;
1272
1273 /// Provides source/type location info for the declaration name
1274 /// embedded in D.
1275 DeclarationNameLoc DNLoc;
1276
1277 size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>) const {
1278 return hasQualifier();
1279 }
1280
1281 size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
1282 return hasFoundDecl();
1283 }
1284
1285 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
1286 return hasTemplateKWAndArgsInfo();
1287 }
1288
1289 /// Test whether there is a distinct FoundDecl attached to the end of
1290 /// this DRE.
1291 bool hasFoundDecl() const { return DeclRefExprBits.HasFoundDecl; }
1292
1293 DeclRefExpr(const ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc,
1294 SourceLocation TemplateKWLoc, ValueDecl *D,
1295 bool RefersToEnclosingVariableOrCapture,
1296 const DeclarationNameInfo &NameInfo, NamedDecl *FoundD,
1297 const TemplateArgumentListInfo *TemplateArgs, QualType T,
1299
1300 /// Construct an empty declaration reference expression.
1301 explicit DeclRefExpr(EmptyShell Empty) : Expr(DeclRefExprClass, Empty) {}
1302
1303public:
1304 DeclRefExpr(const ASTContext &Ctx, ValueDecl *D,
1305 bool RefersToEnclosingVariableOrCapture, QualType T,
1306 ExprValueKind VK, SourceLocation L,
1307 const DeclarationNameLoc &LocInfo = DeclarationNameLoc(),
1308 NonOdrUseReason NOUR = NOUR_None);
1309
1310 static DeclRefExpr *
1311 Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
1312 SourceLocation TemplateKWLoc, ValueDecl *D,
1313 bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc,
1314 QualType T, ExprValueKind VK, NamedDecl *FoundD = nullptr,
1315 const TemplateArgumentListInfo *TemplateArgs = nullptr,
1316 NonOdrUseReason NOUR = NOUR_None);
1317
1318 static DeclRefExpr *
1319 Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
1320 SourceLocation TemplateKWLoc, ValueDecl *D,
1321 bool RefersToEnclosingVariableOrCapture,
1322 const DeclarationNameInfo &NameInfo, QualType T, ExprValueKind VK,
1323 NamedDecl *FoundD = nullptr,
1324 const TemplateArgumentListInfo *TemplateArgs = nullptr,
1325 NonOdrUseReason NOUR = NOUR_None);
1326
1327 /// Construct an empty declaration reference expression.
1328 static DeclRefExpr *CreateEmpty(const ASTContext &Context, bool HasQualifier,
1329 bool HasFoundDecl,
1330 bool HasTemplateKWAndArgsInfo,
1331 unsigned NumTemplateArgs);
1332
1333 ValueDecl *getDecl() { return D; }
1334 const ValueDecl *getDecl() const { return D; }
1335 void setDecl(ValueDecl *NewD);
1336
1338 return DeclarationNameInfo(getDecl()->getDeclName(), getLocation(), DNLoc);
1339 }
1340
1343 SourceLocation getBeginLoc() const LLVM_READONLY;
1344 SourceLocation getEndLoc() const LLVM_READONLY;
1345
1346 /// Determine whether this declaration reference was preceded by a
1347 /// C++ nested-name-specifier, e.g., \c N::foo.
1348 bool hasQualifier() const { return DeclRefExprBits.HasQualifier; }
1349
1350 /// If the name was qualified, retrieves the nested-name-specifier
1351 /// that precedes the name, with source-location information.
1353 if (!hasQualifier())
1354 return NestedNameSpecifierLoc();
1355 return *getTrailingObjects<NestedNameSpecifierLoc>();
1356 }
1357
1358 /// If the name was qualified, retrieves the nested-name-specifier
1359 /// that precedes the name. Otherwise, returns NULL.
1362 }
1363
1364 /// Get the NamedDecl through which this reference occurred.
1365 ///
1366 /// This Decl may be different from the ValueDecl actually referred to in the
1367 /// presence of using declarations, etc. It always returns non-NULL, and may
1368 /// simple return the ValueDecl when appropriate.
1369
1371 return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
1372 }
1373
1374 /// Get the NamedDecl through which this reference occurred.
1375 /// See non-const variant.
1376 const NamedDecl *getFoundDecl() const {
1377 return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
1378 }
1379
1381 return DeclRefExprBits.HasTemplateKWAndArgsInfo;
1382 }
1383
1384 /// Retrieve the location of the template keyword preceding
1385 /// this name, if any.
1388 return SourceLocation();
1389 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
1390 }
1391
1392 /// Retrieve the location of the left angle bracket starting the
1393 /// explicit template argument list following the name, if any.
1396 return SourceLocation();
1397 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
1398 }
1399
1400 /// Retrieve the location of the right angle bracket ending the
1401 /// explicit template argument list following the name, if any.
1404 return SourceLocation();
1405 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
1406 }
1407
1408 /// Determines whether the name in this declaration reference
1409 /// was preceded by the template keyword.
1411
1412 /// Determines whether this declaration reference was followed by an
1413 /// explicit template argument list.
1414 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
1415
1416 /// Copies the template arguments (if present) into the given
1417 /// structure.
1420 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
1421 getTrailingObjects<TemplateArgumentLoc>(), List);
1422 }
1423
1424 /// Retrieve the template arguments provided as part of this
1425 /// template-id.
1428 return nullptr;
1429 return getTrailingObjects<TemplateArgumentLoc>();
1430 }
1431
1432 /// Retrieve the number of template arguments provided as part of this
1433 /// template-id.
1434 unsigned getNumTemplateArgs() const {
1436 return 0;
1437 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
1438 }
1439
1441 return {getTemplateArgs(), getNumTemplateArgs()};
1442 }
1443
1444 /// Returns true if this expression refers to a function that
1445 /// was resolved from an overloaded set having size greater than 1.
1447 return DeclRefExprBits.HadMultipleCandidates;
1448 }
1449 /// Sets the flag telling whether this expression refers to
1450 /// a function that was resolved from an overloaded set having size
1451 /// greater than 1.
1452 void setHadMultipleCandidates(bool V = true) {
1453 DeclRefExprBits.HadMultipleCandidates = V;
1454 }
1455
1456 /// Is this expression a non-odr-use reference, and if so, why?
1458 return static_cast<NonOdrUseReason>(DeclRefExprBits.NonOdrUseReason);
1459 }
1460
1461 /// Does this DeclRefExpr refer to an enclosing local or a captured
1462 /// variable?
1464 return DeclRefExprBits.RefersToEnclosingVariableOrCapture;
1465 }
1466
1468 return DeclRefExprBits.IsImmediateEscalating;
1469 }
1470
1472 DeclRefExprBits.IsImmediateEscalating = Set;
1473 }
1474
1476 return DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter;
1477 }
1478
1480 bool Set, const ASTContext &Context) {
1481 DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter = Set;
1482 setDependence(computeDependence(this, Context));
1483 }
1484
1485 static bool classof(const Stmt *T) {
1486 return T->getStmtClass() == DeclRefExprClass;
1487 }
1488
1489 // Iterators
1492 }
1493
1496 }
1497};
1498
1499class IntegerLiteral : public Expr, public APIntStorage {
1500 SourceLocation Loc;
1501
1502 /// Construct an empty integer literal.
1504 : Expr(IntegerLiteralClass, Empty) { }
1505
1506public:
1507 // type should be IntTy, LongTy, LongLongTy, UnsignedIntTy, UnsignedLongTy,
1508 // or UnsignedLongLongTy
1509 IntegerLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
1510 SourceLocation l);
1511
1512 /// Returns a new integer literal with value 'V' and type 'type'.
1513 /// \param type - either IntTy, LongTy, LongLongTy, UnsignedIntTy,
1514 /// UnsignedLongTy, or UnsignedLongLongTy which should match the size of V
1515 /// \param V - the value that the returned integer literal contains.
1516 static IntegerLiteral *Create(const ASTContext &C, const llvm::APInt &V,
1518 /// Returns a new empty integer literal.
1520
1521 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
1522 SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
1523
1524 /// Retrieve the location of the literal.
1525 SourceLocation getLocation() const { return Loc; }
1526
1527 void setLocation(SourceLocation Location) { Loc = Location; }
1528
1529 static bool classof(const Stmt *T) {
1530 return T->getStmtClass() == IntegerLiteralClass;
1531 }
1532
1533 // Iterators
1536 }
1539 }
1540};
1541
1542class FixedPointLiteral : public Expr, public APIntStorage {
1543 SourceLocation Loc;
1544 unsigned Scale;
1545
1546 /// \brief Construct an empty fixed-point literal.
1548 : Expr(FixedPointLiteralClass, Empty) {}
1549
1550 public:
1551 FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
1552 SourceLocation l, unsigned Scale);
1553
1554 // Store the int as is without any bit shifting.
1556 const llvm::APInt &V,
1558 unsigned Scale);
1559
1560 /// Returns an empty fixed-point literal.
1562
1563 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
1564 SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
1565
1566 /// \brief Retrieve the location of the literal.
1567 SourceLocation getLocation() const { return Loc; }
1568
1569 void setLocation(SourceLocation Location) { Loc = Location; }
1570
1571 unsigned getScale() const { return Scale; }
1572 void setScale(unsigned S) { Scale = S; }
1573
1574 static bool classof(const Stmt *T) {
1575 return T->getStmtClass() == FixedPointLiteralClass;
1576 }
1577
1578 std::string getValueAsString(unsigned Radix) const;
1579
1580 // Iterators
1583 }
1586 }
1587};
1588
1590
1591class CharacterLiteral : public Expr {
1592 unsigned Value;
1593 SourceLocation Loc;
1594public:
1595 // type should be IntTy
1598 : Expr(CharacterLiteralClass, type, VK_PRValue, OK_Ordinary),
1599 Value(value), Loc(l) {
1600 CharacterLiteralBits.Kind = llvm::to_underlying(kind);
1601 setDependence(ExprDependence::None);
1602 }
1603
1604 /// Construct an empty character literal.
1605 CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { }
1606
1607 SourceLocation getLocation() const { return Loc; }
1609 return static_cast<CharacterLiteralKind>(CharacterLiteralBits.Kind);
1610 }
1611
1612 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
1613 SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
1614
1615 unsigned getValue() const { return Value; }
1616
1617 void setLocation(SourceLocation Location) { Loc = Location; }
1619 CharacterLiteralBits.Kind = llvm::to_underlying(kind);
1620 }
1621 void setValue(unsigned Val) { Value = Val; }
1622
1623 static bool classof(const Stmt *T) {
1624 return T->getStmtClass() == CharacterLiteralClass;
1625 }
1626
1627 static void print(unsigned val, CharacterLiteralKind Kind, raw_ostream &OS);
1628
1629 // Iterators
1632 }
1635 }
1636};
1637
1638class FloatingLiteral : public Expr, private APFloatStorage {
1639 SourceLocation Loc;
1640
1641 FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact,
1643
1644 /// Construct an empty floating-point literal.
1645 explicit FloatingLiteral(const ASTContext &C, EmptyShell Empty);
1646
1647public:
1648 static FloatingLiteral *Create(const ASTContext &C, const llvm::APFloat &V,
1649 bool isexact, QualType Type, SourceLocation L);
1651
1652 llvm::APFloat getValue() const {
1654 }
1655 void setValue(const ASTContext &C, const llvm::APFloat &Val) {
1656 assert(&getSemantics() == &Val.getSemantics() && "Inconsistent semantics");
1658 }
1659
1660 /// Get a raw enumeration value representing the floating-point semantics of
1661 /// this literal (32-bit IEEE, x87, ...), suitable for serialization.
1662 llvm::APFloatBase::Semantics getRawSemantics() const {
1663 return static_cast<llvm::APFloatBase::Semantics>(
1664 FloatingLiteralBits.Semantics);
1665 }
1666
1667 /// Set the raw enumeration value representing the floating-point semantics of
1668 /// this literal (32-bit IEEE, x87, ...), suitable for serialization.
1669 void setRawSemantics(llvm::APFloatBase::Semantics Sem) {
1670 FloatingLiteralBits.Semantics = Sem;
1671 }
1672
1673 /// Return the APFloat semantics this literal uses.
1674 const llvm::fltSemantics &getSemantics() const {
1675 return llvm::APFloatBase::EnumToSemantics(
1676 static_cast<llvm::APFloatBase::Semantics>(
1677 FloatingLiteralBits.Semantics));
1678 }
1679
1680 /// Set the APFloat semantics this literal uses.
1681 void setSemantics(const llvm::fltSemantics &Sem) {
1682 FloatingLiteralBits.Semantics = llvm::APFloatBase::SemanticsToEnum(Sem);
1683 }
1684
1685 bool isExact() const { return FloatingLiteralBits.IsExact; }
1686 void setExact(bool E) { FloatingLiteralBits.IsExact = E; }
1687
1688 /// getValueAsApproximateDouble - This returns the value as an inaccurate
1689 /// double. Note that this may cause loss of precision, but is useful for
1690 /// debugging dumps, etc.
1691 double getValueAsApproximateDouble() const;
1692
1693 SourceLocation getLocation() const { return Loc; }
1695
1696 SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
1697 SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
1698
1699 static bool classof(const Stmt *T) {
1700 return T->getStmtClass() == FloatingLiteralClass;
1701 }
1702
1703 // Iterators
1706 }
1709 }
1710};
1711
1712/// ImaginaryLiteral - We support imaginary integer and floating point literals,
1713/// like "1.0i". We represent these as a wrapper around FloatingLiteral and
1714/// IntegerLiteral classes. Instances of this class always have a Complex type
1715/// whose element type matches the subexpression.
1716///
1717class ImaginaryLiteral : public Expr {
1718 Stmt *Val;
1719public:
1721 : Expr(ImaginaryLiteralClass, Ty, VK_PRValue, OK_Ordinary), Val(val) {
1722 setDependence(ExprDependence::None);
1723 }
1724
1725 /// Build an empty imaginary literal.
1727 : Expr(ImaginaryLiteralClass, Empty) { }
1728
1729 const Expr *getSubExpr() const { return cast<Expr>(Val); }
1730 Expr *getSubExpr() { return cast<Expr>(Val); }
1731 void setSubExpr(Expr *E) { Val = E; }
1732
1733 SourceLocation getBeginLoc() const LLVM_READONLY {
1734 return Val->getBeginLoc();
1735 }
1736 SourceLocation getEndLoc() const LLVM_READONLY { return Val->getEndLoc(); }
1737
1738 static bool classof(const Stmt *T) {
1739 return T->getStmtClass() == ImaginaryLiteralClass;
1740 }
1741
1742 // Iterators
1743 child_range children() { return child_range(&Val, &Val+1); }
1745 return const_child_range(&Val, &Val + 1);
1746 }
1747};
1748
1750 Ordinary,
1751 Wide,
1752 UTF8,
1753 UTF16,
1754 UTF32,
1756};
1757
1758/// StringLiteral - This represents a string literal expression, e.g. "foo"
1759/// or L"bar" (wide strings). The actual string data can be obtained with
1760/// getBytes() and is NOT null-terminated. The length of the string data is
1761/// determined by calling getByteLength().
1762///
1763/// The C type for a string is always a ConstantArrayType. In C++, the char
1764/// type is const qualified, in C it is not.
1765///
1766/// Note that strings in C can be formed by concatenation of multiple string
1767/// literal pptokens in translation phase #6. This keeps track of the locations
1768/// of each of these pieces.
1769///
1770/// Strings in C can also be truncated and extended by assigning into arrays,
1771/// e.g. with constructs like:
1772/// char X[2] = "foobar";
1773/// In this case, getByteLength() will return 6, but the string literal will
1774/// have type "char[2]".
1775class StringLiteral final
1776 : public Expr,
1777 private llvm::TrailingObjects<StringLiteral, unsigned, SourceLocation,
1778 char> {
1779 friend class ASTStmtReader;
1780 friend TrailingObjects;
1781
1782 /// StringLiteral is followed by several trailing objects. They are in order:
1783 ///
1784 /// * A single unsigned storing the length in characters of this string. The
1785 /// length in bytes is this length times the width of a single character.
1786 /// Always present and stored as a trailing objects because storing it in
1787 /// StringLiteral would increase the size of StringLiteral by sizeof(void *)
1788 /// due to alignment requirements. If you add some data to StringLiteral,
1789 /// consider moving it inside StringLiteral.
1790 ///
1791 /// * An array of getNumConcatenated() SourceLocation, one for each of the
1792 /// token this string is made of.
1793 ///
1794 /// * An array of getByteLength() char used to store the string data.
1795
1796 unsigned numTrailingObjects(OverloadToken<unsigned>) const { return 1; }
1797 unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
1798 return getNumConcatenated();
1799 }
1800
1801 unsigned numTrailingObjects(OverloadToken<char>) const {
1802 return getByteLength();
1803 }
1804
1805 char *getStrDataAsChar() { return getTrailingObjects<char>(); }
1806 const char *getStrDataAsChar() const { return getTrailingObjects<char>(); }
1807
1808 const uint16_t *getStrDataAsUInt16() const {
1809 return reinterpret_cast<const uint16_t *>(getTrailingObjects<char>());
1810 }
1811
1812 const uint32_t *getStrDataAsUInt32() const {
1813 return reinterpret_cast<const uint32_t *>(getTrailingObjects<char>());
1814 }
1815
1816 /// Build a string literal.
1817 StringLiteral(const ASTContext &Ctx, StringRef Str, StringLiteralKind Kind,
1818 bool Pascal, QualType Ty, const SourceLocation *Loc,
1819 unsigned NumConcatenated);
1820
1821 /// Build an empty string literal.
1822 StringLiteral(EmptyShell Empty, unsigned NumConcatenated, unsigned Length,
1823 unsigned CharByteWidth);
1824
1825 /// Map a target and string kind to the appropriate character width.
1826 static unsigned mapCharByteWidth(TargetInfo const &Target,
1828
1829 /// Set one of the string literal token.
1830 void setStrTokenLoc(unsigned TokNum, SourceLocation L) {
1831 assert(TokNum < getNumConcatenated() && "Invalid tok number");
1832 getTrailingObjects<SourceLocation>()[TokNum] = L;
1833 }
1834
1835public:
1836 /// This is the "fully general" constructor that allows representation of
1837 /// strings formed from multiple concatenated tokens.
1838 static StringLiteral *Create(const ASTContext &Ctx, StringRef Str,
1839 StringLiteralKind Kind, bool Pascal, QualType Ty,
1840 const SourceLocation *Loc,
1841 unsigned NumConcatenated);
1842
1843 /// Simple constructor for string literals made from one token.
1844 static StringLiteral *Create(const ASTContext &Ctx, StringRef Str,
1845 StringLiteralKind Kind, bool Pascal, QualType Ty,
1847 return Create(Ctx, Str, Kind, Pascal, Ty, &Loc, 1);
1848 }
1849
1850 /// Construct an empty string literal.
1851 static StringLiteral *CreateEmpty(const ASTContext &Ctx,
1852 unsigned NumConcatenated, unsigned Length,
1853 unsigned CharByteWidth);
1854
1855 StringRef getString() const {
1856 assert((isUnevaluated() || getCharByteWidth() == 1) &&
1857 "This function is used in places that assume strings use char");
1858 return StringRef(getStrDataAsChar(), getByteLength());
1859 }
1860
1861 /// Allow access to clients that need the byte representation, such as
1862 /// ASTWriterStmt::VisitStringLiteral().
1863 StringRef getBytes() const {
1864 // FIXME: StringRef may not be the right type to use as a result for this.
1865 return StringRef(getStrDataAsChar(), getByteLength());
1866 }
1867
1868 void outputString(raw_ostream &OS) const;
1869
1870 uint32_t getCodeUnit(size_t i) const {
1871 assert(i < getLength() && "out of bounds access");
1872 switch (getCharByteWidth()) {
1873 case 1:
1874 return static_cast<unsigned char>(getStrDataAsChar()[i]);
1875 case 2:
1876 return getStrDataAsUInt16()[i];
1877 case 4:
1878 return getStrDataAsUInt32()[i];
1879 }
1880 llvm_unreachable("Unsupported character width!");
1881 }
1882
1883 // Get code unit but preserve sign info.
1884 int64_t getCodeUnitS(size_t I, uint64_t BitWidth) const {
1885 int64_t V = getCodeUnit(I);
1886 if (isOrdinary() || isWide()) {
1887 unsigned Width = getCharByteWidth() * BitWidth;
1888 llvm::APInt AInt(Width, (uint64_t)V);
1889 V = AInt.getSExtValue();
1890 }
1891 return V;
1892 }
1893
1894 unsigned getByteLength() const { return getCharByteWidth() * getLength(); }
1895 unsigned getLength() const { return *getTrailingObjects<unsigned>(); }
1896 unsigned getCharByteWidth() const { return StringLiteralBits.CharByteWidth; }
1897
1899 return static_cast<StringLiteralKind>(StringLiteralBits.Kind);
1900 }
1901
1902 bool isOrdinary() const { return getKind() == StringLiteralKind::Ordinary; }
1903 bool isWide() const { return getKind() == StringLiteralKind::Wide; }
1904 bool isUTF8() const { return getKind() == StringLiteralKind::UTF8; }
1905 bool isUTF16() const { return getKind() == StringLiteralKind::UTF16; }
1906 bool isUTF32() const { return getKind() == StringLiteralKind::UTF32; }
1908 bool isPascal() const { return StringLiteralBits.IsPascal; }
1909
1910 bool containsNonAscii() const {
1911 for (auto c : getString())
1912 if (!isASCII(c))
1913 return true;
1914 return false;
1915 }
1916
1918 for (auto c : getString())
1919 if (!isASCII(c) || !c)
1920 return true;
1921 return false;
1922 }
1923
1924 /// getNumConcatenated - Get the number of string literal tokens that were
1925 /// concatenated in translation phase #6 to form this string literal.
1926 unsigned getNumConcatenated() const {
1927 return StringLiteralBits.NumConcatenated;
1928 }
1929
1930 /// Get one of the string literal token.
1931 SourceLocation getStrTokenLoc(unsigned TokNum) const {
1932 assert(TokNum < getNumConcatenated() && "Invalid tok number");
1933 return getTrailingObjects<SourceLocation>()[TokNum];
1934 }
1935
1936 /// getLocationOfByte - Return a source location that points to the specified
1937 /// byte of this string literal.
1938 ///
1939 /// Strings are amazingly complex. They can be formed from multiple tokens
1940 /// and can have escape sequences in them in addition to the usual trigraph
1941 /// and escaped newline business. This routine handles this complexity.
1942 ///
1944 getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
1945 const LangOptions &Features, const TargetInfo &Target,
1946 unsigned *StartToken = nullptr,
1947 unsigned *StartTokenByteOffset = nullptr) const;
1948
1950
1952 return getTrailingObjects<SourceLocation>();
1953 }
1954
1956 return getTrailingObjects<SourceLocation>() + getNumConcatenated();
1957 }
1958
1959 SourceLocation getBeginLoc() const LLVM_READONLY { return *tokloc_begin(); }
1960 SourceLocation getEndLoc() const LLVM_READONLY { return *(tokloc_end() - 1); }
1961
1962 static bool classof(const Stmt *T) {
1963 return T->getStmtClass() == StringLiteralClass;
1964 }
1965
1966 // Iterators
1969 }
1972 }
1973};
1974
1976 Func,
1977 Function,
1978 LFunction, // Same as Function, but as wide string.
1979 FuncDName,
1980 FuncSig,
1981 LFuncSig, // Same as FuncSig, but as wide string
1983 /// The same as PrettyFunction, except that the
1984 /// 'virtual' keyword is omitted for virtual member functions.
1986};
1987
1988/// [C99 6.4.2.2] - A predefined identifier such as __func__.
1990 : public Expr,
1991 private llvm::TrailingObjects<PredefinedExpr, Stmt *> {
1992 friend class ASTStmtReader;
1993 friend TrailingObjects;
1994
1995 // PredefinedExpr is optionally followed by a single trailing
1996 // "Stmt *" for the predefined identifier. It is present if and only if
1997 // hasFunctionName() is true and is always a "StringLiteral *".
1998
2000 bool IsTransparent, StringLiteral *SL);
2001
2002 explicit PredefinedExpr(EmptyShell Empty, bool HasFunctionName);
2003
2004 /// True if this PredefinedExpr has storage for a function name.
2005 bool hasFunctionName() const { return PredefinedExprBits.HasFunctionName; }
2006
2007 void setFunctionName(StringLiteral *SL) {
2008 assert(hasFunctionName() &&
2009 "This PredefinedExpr has no storage for a function name!");
2010 *getTrailingObjects<Stmt *>() = SL;
2011 }
2012
2013public:
2014 /// Create a PredefinedExpr.
2015 ///
2016 /// If IsTransparent, the PredefinedExpr is transparently handled as a
2017 /// StringLiteral.
2018 static PredefinedExpr *Create(const ASTContext &Ctx, SourceLocation L,
2019 QualType FNTy, PredefinedIdentKind IK,
2020 bool IsTransparent, StringLiteral *SL);
2021
2022 /// Create an empty PredefinedExpr.
2023 static PredefinedExpr *CreateEmpty(const ASTContext &Ctx,
2024 bool HasFunctionName);
2025
2027 return static_cast<PredefinedIdentKind>(PredefinedExprBits.Kind);
2028 }
2029
2030 bool isTransparent() const { return PredefinedExprBits.IsTransparent; }
2031
2034
2036 return hasFunctionName()
2037 ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
2038 : nullptr;
2039 }
2040
2042 return hasFunctionName()
2043 ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
2044 : nullptr;
2045 }
2046
2047 static StringRef getIdentKindName(PredefinedIdentKind IK);
2048 StringRef getIdentKindName() const {
2050 }
2051
2052 static std::string ComputeName(PredefinedIdentKind IK,
2053 const Decl *CurrentDecl,
2054 bool ForceElaboratedPrinting = false);
2055
2058
2059 static bool classof(const Stmt *T) {
2060 return T->getStmtClass() == PredefinedExprClass;
2061 }
2062
2063 // Iterators
2065 return child_range(getTrailingObjects<Stmt *>(),
2066 getTrailingObjects<Stmt *>() + hasFunctionName());
2067 }
2068
2070 return const_child_range(getTrailingObjects<Stmt *>(),
2071 getTrailingObjects<Stmt *>() + hasFunctionName());
2072 }
2073};
2074
2075// This represents a use of the __builtin_sycl_unique_stable_name, which takes a
2076// type-id, and at CodeGen time emits a unique string representation of the
2077// type in a way that permits us to properly encode information about the SYCL
2078// kernels.
2079class SYCLUniqueStableNameExpr final : public Expr {
2080 friend class ASTStmtReader;
2081 SourceLocation OpLoc, LParen, RParen;
2083
2086 SourceLocation RParen, QualType ResultTy,
2087 TypeSourceInfo *TSI);
2088
2089 void setTypeSourceInfo(TypeSourceInfo *Ty) { TypeInfo = Ty; }
2090
2091 void setLocation(SourceLocation L) { OpLoc = L; }
2092 void setLParenLocation(SourceLocation L) { LParen = L; }
2093 void setRParenLocation(SourceLocation L) { RParen = L; }
2094
2095public:
2097
2098 const TypeSourceInfo *getTypeSourceInfo() const { return TypeInfo; }
2099
2101 Create(const ASTContext &Ctx, SourceLocation OpLoc, SourceLocation LParen,
2102 SourceLocation RParen, TypeSourceInfo *TSI);
2103
2105
2107 SourceLocation getEndLoc() const { return RParen; }
2108 SourceLocation getLocation() const { return OpLoc; }
2109 SourceLocation getLParenLocation() const { return LParen; }
2110 SourceLocation getRParenLocation() const { return RParen; }
2111
2112 static bool classof(const Stmt *T) {
2113 return T->getStmtClass() == SYCLUniqueStableNameExprClass;
2114 }
2115
2116 // Iterators
2119 }
2120
2123 }
2124
2125 // Convenience function to generate the name of the currently stored type.
2126 std::string ComputeName(ASTContext &Context) const;
2127
2128 // Get the generated name of the type. Note that this only works after all
2129 // kernels have been instantiated.
2130 static std::string ComputeName(ASTContext &Context, QualType Ty);
2131};
2132
2133/// ParenExpr - This represents a parenthesized expression, e.g. "(1)". This
2134/// AST node is only formed if full location information is requested.
2135class ParenExpr : public Expr {
2136 SourceLocation L, R;
2137 Stmt *Val;
2138public:
2140 : Expr(ParenExprClass, val->getType(), val->getValueKind(),
2141 val->getObjectKind()),
2142 L(l), R(r), Val(val) {
2144 }
2145
2146 /// Construct an empty parenthesized expression.
2148 : Expr(ParenExprClass, Empty) { }
2149
2150 const Expr *getSubExpr() const { return cast<Expr>(Val); }
2151 Expr *getSubExpr() { return cast<Expr>(Val); }
2152 void setSubExpr(Expr *E) { Val = E; }
2153
2154 SourceLocation getBeginLoc() const LLVM_READONLY { return L; }
2155 SourceLocation getEndLoc() const LLVM_READONLY { return R; }
2156
2157 /// Get the location of the left parentheses '('.
2158 SourceLocation getLParen() const { return L; }
2160
2161 /// Get the location of the right parentheses ')'.
2162 SourceLocation getRParen() const { return R; }
2164
2165 static bool classof(const Stmt *T) {
2166 return T->getStmtClass() == ParenExprClass;
2167 }
2168
2169 // Iterators
2170 child_range children() { return child_range(&Val, &Val+1); }
2172 return const_child_range(&Val, &Val + 1);
2173 }
2174};
2175
2176/// UnaryOperator - This represents the unary-expression's (except sizeof and
2177/// alignof), the postinc/postdec operators from postfix-expression, and various
2178/// extensions.
2179///
2180/// Notes on various nodes:
2181///
2182/// Real/Imag - These return the real/imag part of a complex operand. If
2183/// applied to a non-complex value, the former returns its operand and the
2184/// later returns zero in the type of the operand.
2185///
2186class UnaryOperator final
2187 : public Expr,
2188 private llvm::TrailingObjects<UnaryOperator, FPOptionsOverride> {
2189 Stmt *Val;
2190
2191 size_t numTrailingObjects(OverloadToken<FPOptionsOverride>) const {
2192 return UnaryOperatorBits.HasFPFeatures ? 1 : 0;
2193 }
2194
2195 FPOptionsOverride &getTrailingFPFeatures() {
2196 assert(UnaryOperatorBits.HasFPFeatures);
2197 return *getTrailingObjects<FPOptionsOverride>();
2198 }
2199
2200 const FPOptionsOverride &getTrailingFPFeatures() const {
2201 assert(UnaryOperatorBits.HasFPFeatures);
2202 return *getTrailingObjects<FPOptionsOverride>();
2203 }
2204
2205public:
2207
2208protected:
2209 UnaryOperator(const ASTContext &Ctx, Expr *input, Opcode opc, QualType type,
2211 bool CanOverflow, FPOptionsOverride FPFeatures);
2212
2213 /// Build an empty unary operator.
2214 explicit UnaryOperator(bool HasFPFeatures, EmptyShell Empty)
2215 : Expr(UnaryOperatorClass, Empty) {
2216 UnaryOperatorBits.Opc = UO_AddrOf;
2217 UnaryOperatorBits.HasFPFeatures = HasFPFeatures;
2218 }
2219
2220public:
2221 static UnaryOperator *CreateEmpty(const ASTContext &C, bool hasFPFeatures);
2222
2223 static UnaryOperator *Create(const ASTContext &C, Expr *input, Opcode opc,
2226 bool CanOverflow, FPOptionsOverride FPFeatures);
2227
2229 return static_cast<Opcode>(UnaryOperatorBits.Opc);
2230 }
2231 void setOpcode(Opcode Opc) { UnaryOperatorBits.Opc = Opc; }
2232
2233 Expr *getSubExpr() const { return cast<Expr>(Val); }
2234 void setSubExpr(Expr *E) { Val = E; }
2235
2236 /// getOperatorLoc - Return the location of the operator.
2239
2240 /// Returns true if the unary operator can cause an overflow. For instance,
2241 /// signed int i = INT_MAX; i++;
2242 /// signed char c = CHAR_MAX; c++;
2243 /// Due to integer promotions, c++ is promoted to an int before the postfix
2244 /// increment, and the result is an int that cannot overflow. However, i++
2245 /// can overflow.
2246 bool canOverflow() const { return UnaryOperatorBits.CanOverflow; }
2247 void setCanOverflow(bool C) { UnaryOperatorBits.CanOverflow = C; }
2248
2249 /// Get the FP contractibility status of this operator. Only meaningful for
2250 /// operations on floating point types.
2253 }
2254
2255 /// Get the FENV_ACCESS status of this operator. Only meaningful for
2256 /// operations on floating point types.
2257 bool isFEnvAccessOn(const LangOptions &LO) const {
2258 return getFPFeaturesInEffect(LO).getAllowFEnvAccess();
2259 }
2260
2261 /// isPostfix - Return true if this is a postfix operation, like x++.
2262 static bool isPostfix(Opcode Op) {
2263 return Op == UO_PostInc || Op == UO_PostDec;
2264 }
2265
2266 /// isPrefix - Return true if this is a prefix operation, like --x.
2267 static bool isPrefix(Opcode Op) {
2268 return Op == UO_PreInc || Op == UO_PreDec;
2269 }
2270
2271 bool isPrefix() const { return isPrefix(getOpcode()); }
2272 bool isPostfix() const { return isPostfix(getOpcode()); }
2273
2274 static bool isIncrementOp(Opcode Op) {
2275 return Op == UO_PreInc || Op == UO_PostInc;
2276 }
2277 bool isIncrementOp() const {
2278 return isIncrementOp(getOpcode());
2279 }
2280
2281 static bool isDecrementOp(Opcode Op) {
2282 return Op == UO_PreDec || Op == UO_PostDec;
2283 }
2284 bool isDecrementOp() const {
2285 return isDecrementOp(getOpcode());
2286 }
2287
2288 static bool isIncrementDecrementOp(Opcode Op) { return Op <= UO_PreDec; }
2291 }
2292
2293 static bool isArithmeticOp(Opcode Op) {
2294 return Op >= UO_Plus && Op <= UO_LNot;
2295 }
2296 bool isArithmeticOp() const { return isArithmeticOp(getOpcode()); }
2297
2298 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
2299 /// corresponds to, e.g. "sizeof" or "[pre]++"
2300 static StringRef getOpcodeStr(Opcode Op);
2301
2302 /// Retrieve the unary opcode that corresponds to the given
2303 /// overloaded operator.
2304 static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix);
2305
2306 /// Retrieve the overloaded operator kind that corresponds to
2307 /// the given unary opcode.
2309
2310 SourceLocation getBeginLoc() const LLVM_READONLY {
2311 return isPostfix() ? Val->getBeginLoc() : getOperatorLoc();
2312 }
2313 SourceLocation getEndLoc() const LLVM_READONLY {
2314 return isPostfix() ? getOperatorLoc() : Val->getEndLoc();
2315 }
2317
2318 static bool classof(const Stmt *T) {
2319 return T->getStmtClass() == UnaryOperatorClass;
2320 }
2321
2322 // Iterators
2323 child_range children() { return child_range(&Val, &Val+1); }
2325 return const_child_range(&Val, &Val + 1);
2326 }
2327
2328 /// Is FPFeatures in Trailing Storage?
2329 bool hasStoredFPFeatures() const { return UnaryOperatorBits.HasFPFeatures; }
2330
2331 /// Get FPFeatures from trailing storage.
2333 return getTrailingFPFeatures();
2334 }
2335
2336 /// Get the store FPOptionsOverride or default if not stored.
2339 }
2340
2341protected:
2342 /// Set FPFeatures in trailing storage, used by Serialization & ASTImporter.
2343 void setStoredFPFeatures(FPOptionsOverride F) { getTrailingFPFeatures() = F; }
2344
2345public:
2346 /// Get the FP features status of this operator. Only meaningful for
2347 /// operations on floating point types.
2349 if (UnaryOperatorBits.HasFPFeatures)
2352 }
2354 if (UnaryOperatorBits.HasFPFeatures)
2355 return getStoredFPFeatures();
2356 return FPOptionsOverride();
2357 }
2358
2360 friend class ASTNodeImporter;
2361 friend class ASTReader;
2362 friend class ASTStmtReader;
2363 friend class ASTStmtWriter;
2364};
2365
2366/// Helper class for OffsetOfExpr.
2367
2368// __builtin_offsetof(type, identifier(.identifier|[expr])*)
2370public:
2371 /// The kind of offsetof node we have.
2372 enum Kind {
2373 /// An index into an array.
2374 Array = 0x00,
2375 /// A field.
2376 Field = 0x01,
2377 /// A field in a dependent type, known only by its name.
2379 /// An implicit indirection through a C++ base class, when the
2380 /// field found is in a base class.
2381 Base = 0x03
2383
2384private:
2385 enum { MaskBits = 2, Mask = 0x03 };
2386
2387 /// The source range that covers this part of the designator.
2388 SourceRange Range;
2389
2390 /// The data describing the designator, which comes in three
2391 /// different forms, depending on the lower two bits.
2392 /// - An unsigned index into the array of Expr*'s stored after this node
2393 /// in memory, for [constant-expression] designators.
2394 /// - A FieldDecl*, for references to a known field.
2395 /// - An IdentifierInfo*, for references to a field with a given name
2396 /// when the class type is dependent.
2397 /// - A CXXBaseSpecifier*, for references that look at a field in a
2398 /// base class.
2399 uintptr_t Data;
2400
2401public:
2402 /// Create an offsetof node that refers to an array element.
2403 OffsetOfNode(SourceLocation LBracketLoc, unsigned Index,
2404 SourceLocation RBracketLoc)
2405 : Range(LBracketLoc, RBracketLoc), Data((Index << 2) | Array) {}
2406
2407 /// Create an offsetof node that refers to a field.
2409 : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
2410 Data(reinterpret_cast<uintptr_t>(Field) | OffsetOfNode::Field) {}
2411
2412 /// Create an offsetof node that refers to an identifier.
2414 SourceLocation NameLoc)
2415 : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
2416 Data(reinterpret_cast<uintptr_t>(Name) | Identifier) {}
2417
2418 /// Create an offsetof node that refers into a C++ base class.
2420 : Data(reinterpret_cast<uintptr_t>(Base) | OffsetOfNode::Base) {}
2421
2422 /// Determine what kind of offsetof node this is.
2423 Kind getKind() const { return static_cast<Kind>(Data & Mask); }
2424
2425 /// For an array element node, returns the index into the array
2426 /// of expressions.
2427 unsigned getArrayExprIndex() const {
2428 assert(getKind() == Array);
2429 return Data >> 2;
2430 }
2431
2432 /// For a field offsetof node, returns the field.
2434 assert(getKind() == Field);
2435 return reinterpret_cast<FieldDecl *>(Data & ~(uintptr_t)Mask);
2436 }
2437
2438 /// For a field or identifier offsetof node, returns the name of
2439 /// the field.
2441
2442 /// For a base class node, returns the base specifier.
2444 assert(getKind() == Base);
2445 return reinterpret_cast<CXXBaseSpecifier *>(Data & ~(uintptr_t)Mask);
2446 }
2447
2448 /// Retrieve the source range that covers this offsetof node.
2449 ///
2450 /// For an array element node, the source range contains the locations of
2451 /// the square brackets. For a field or identifier node, the source range
2452 /// contains the location of the period (if there is one) and the
2453 /// identifier.
2454 SourceRange getSourceRange() const LLVM_READONLY { return Range; }
2455 SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
2456 SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
2457};
2458
2459/// OffsetOfExpr - [C99 7.17] - This represents an expression of the form
2460/// offsetof(record-type, member-designator). For example, given:
2461/// @code
2462/// struct S {
2463/// float f;
2464/// double d;
2465/// };
2466/// struct T {
2467/// int i;
2468/// struct S s[10];
2469/// };
2470/// @endcode
2471/// we can represent and evaluate the expression @c offsetof(struct T, s[2].d).
2472
2473class OffsetOfExpr final
2474 : public Expr,
2475 private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
2476 SourceLocation OperatorLoc, RParenLoc;
2477 // Base type;
2478 TypeSourceInfo *TSInfo;
2479 // Number of sub-components (i.e. instances of OffsetOfNode).
2480 unsigned NumComps;
2481 // Number of sub-expressions (i.e. array subscript expressions).
2482 unsigned NumExprs;
2483
2484 size_t numTrailingObjects(OverloadToken<OffsetOfNode>) const {
2485 return NumComps;
2486 }
2487
2489 SourceLocation OperatorLoc, TypeSourceInfo *tsi,
2491 SourceLocation RParenLoc);
2492
2493 explicit OffsetOfExpr(unsigned numComps, unsigned numExprs)
2494 : Expr(OffsetOfExprClass, EmptyShell()),
2495 TSInfo(nullptr), NumComps(numComps), NumExprs(numExprs) {}
2496
2497public:
2498
2499 static OffsetOfExpr *Create(const ASTContext &C, QualType type,
2500 SourceLocation OperatorLoc, TypeSourceInfo *tsi,
2502 ArrayRef<Expr*> exprs, SourceLocation RParenLoc);
2503
2504 static OffsetOfExpr *CreateEmpty(const ASTContext &C,
2505 unsigned NumComps, unsigned NumExprs);
2506
2507 /// getOperatorLoc - Return the location of the operator.
2508 SourceLocation getOperatorLoc() const { return OperatorLoc; }
2509 void setOperatorLoc(SourceLocation L) { OperatorLoc = L; }
2510
2511 /// Return the location of the right parentheses.
2512 SourceLocation getRParenLoc() const { return RParenLoc; }
2513 void setRParenLoc(SourceLocation R) { RParenLoc = R; }
2514
2516 return TSInfo;
2517 }
2519 TSInfo = tsi;
2520 }
2521
2522 const OffsetOfNode &getComponent(unsigned Idx) const {
2523 assert(Idx < NumComps && "Subscript out of range");
2524 return getTrailingObjects<OffsetOfNode>()[Idx];
2525 }
2526
2527 void setComponent(unsigned Idx, OffsetOfNode ON) {
2528 assert(Idx < NumComps && "Subscript out of range");
2529 getTrailingObjects<OffsetOfNode>()[Idx] = ON;
2530 }
2531
2532 unsigned getNumComponents() const {
2533 return NumComps;
2534 }
2535
2536 Expr* getIndexExpr(unsigned Idx) {
2537 assert(Idx < NumExprs && "Subscript out of range");
2538 return getTrailingObjects<Expr *>()[Idx];
2539 }
2540
2541 const Expr *getIndexExpr(unsigned Idx) const {
2542 assert(Idx < NumExprs && "Subscript out of range");
2543 return getTrailingObjects<Expr *>()[Idx];
2544 }
2545
2546 void setIndexExpr(unsigned Idx, Expr* E) {
2547 assert(Idx < NumComps && "Subscript out of range");
2548 getTrailingObjects<Expr *>()[Idx] = E;
2549 }
2550
2551 unsigned getNumExpressions() const {
2552 return NumExprs;
2553 }
2554
2555 SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; }
2556 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
2557
2558 static bool classof(const Stmt *T) {
2559 return T->getStmtClass() == OffsetOfExprClass;
2560 }
2561
2562 // Iterators
2564 Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
2565 return child_range(begin, begin + NumExprs);
2566 }
2568 Stmt *const *begin =
2569 reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
2570 return const_child_range(begin, begin + NumExprs);
2571 }
2573};
2574
2575/// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated)
2576/// expression operand. Used for sizeof/alignof (C99 6.5.3.4) and
2577/// vec_step (OpenCL 1.1 6.11.12).
2579 union {
2582 } Argument;
2583 SourceLocation OpLoc, RParenLoc;
2584
2585public:
2587 QualType resultType, SourceLocation op,
2588 SourceLocation rp)
2589 : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_PRValue,
2590 OK_Ordinary),
2591 OpLoc(op), RParenLoc(rp) {
2592 assert(ExprKind <= UETT_Last && "invalid enum value!");
2593 UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
2594 assert(static_cast<unsigned>(ExprKind) ==
2596 "UnaryExprOrTypeTraitExprBits.Kind overflow!");
2597 UnaryExprOrTypeTraitExprBits.IsType = true;
2598 Argument.Ty = TInfo;
2600 }
2601
2603 QualType resultType, SourceLocation op,
2604 SourceLocation rp);
2605
2606 /// Construct an empty sizeof/alignof expression.
2608 : Expr(UnaryExprOrTypeTraitExprClass, Empty) { }
2609
2611 return static_cast<UnaryExprOrTypeTrait>(UnaryExprOrTypeTraitExprBits.Kind);
2612 }
2614 assert(K <= UETT_Last && "invalid enum value!");
2616 assert(static_cast<unsigned>(K) == UnaryExprOrTypeTraitExprBits.Kind &&
2617 "UnaryExprOrTypeTraitExprBits.Kind overflow!");
2618 }
2619
2620 bool isArgumentType() const { return UnaryExprOrTypeTraitExprBits.IsType; }
2622 return getArgumentTypeInfo()->getType();
2623 }
2625 assert(isArgumentType() && "calling getArgumentType() when arg is expr");
2626 return Argument.Ty;
2627 }
2629 assert(!isArgumentType() && "calling getArgumentExpr() when arg is type");
2630 return static_cast<Expr*>(Argument.Ex);
2631 }
2632 const Expr *getArgumentExpr() const {
2633 return const_cast<UnaryExprOrTypeTraitExpr*>(this)->getArgumentExpr();
2634 }
2635
2637 Argument.Ex = E;
2638 UnaryExprOrTypeTraitExprBits.IsType = false;
2639 }
2641 Argument.Ty = TInfo;
2642 UnaryExprOrTypeTraitExprBits.IsType = true;
2643 }
2644
2645 /// Gets the argument type, or the type of the argument expression, whichever
2646 /// is appropriate.
2649 }
2650
2651 SourceLocation getOperatorLoc() const { return OpLoc; }
2652 void setOperatorLoc(SourceLocation L) { OpLoc = L; }
2653
2654 SourceLocation getRParenLoc() const { return RParenLoc; }
2655 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
2656
2657 SourceLocation getBeginLoc() const LLVM_READONLY { return OpLoc; }
2658 SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
2659
2660 static bool classof(const Stmt *T) {
2661 return T->getStmtClass() == UnaryExprOrTypeTraitExprClass;
2662 }
2663
2664 // Iterators
2667};
2668
2669//===----------------------------------------------------------------------===//
2670// Postfix Operators.
2671//===----------------------------------------------------------------------===//
2672
2673/// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
2674class ArraySubscriptExpr : public Expr {
2675 enum { LHS, RHS, END_EXPR };
2676 Stmt *SubExprs[END_EXPR];
2677
2678 bool lhsIsBase() const { return getRHS()->getType()->isIntegerType(); }
2679
2680public:
2682 ExprObjectKind OK, SourceLocation rbracketloc)
2683 : Expr(ArraySubscriptExprClass, t, VK, OK) {
2684 SubExprs[LHS] = lhs;
2685 SubExprs[RHS] = rhs;
2686 ArrayOrMatrixSubscriptExprBits.RBracketLoc = rbracketloc;
2688 }
2689
2690 /// Create an empty array subscript expression.
2692 : Expr(ArraySubscriptExprClass, Shell) { }
2693
2694 /// An array access can be written A[4] or 4[A] (both are equivalent).
2695 /// - getBase() and getIdx() always present the normalized view: A[4].
2696 /// In this case getBase() returns "A" and getIdx() returns "4".
2697 /// - getLHS() and getRHS() present the syntactic view. e.g. for
2698 /// 4[A] getLHS() returns "4".
2699 /// Note: Because vector element access is also written A[4] we must
2700 /// predicate the format conversion in getBase and getIdx only on the
2701 /// the type of the RHS, as it is possible for the LHS to be a vector of
2702 /// integer type
2703 Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
2704 const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
2705 void setLHS(Expr *E) { SubExprs[LHS] = E; }
2706
2707 Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
2708 const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
2709 void setRHS(Expr *E) { SubExprs[RHS] = E; }
2710
2711 Expr *getBase() { return lhsIsBase() ? getLHS() : getRHS(); }
2712 const Expr *getBase() const { return lhsIsBase() ? getLHS() : getRHS(); }
2713
2714 Expr *getIdx() { return lhsIsBase() ? getRHS() : getLHS(); }
2715 const Expr *getIdx() const { return lhsIsBase() ? getRHS() : getLHS(); }
2716
2717 SourceLocation getBeginLoc() const LLVM_READONLY {
2718 return getLHS()->getBeginLoc();
2719 }
2721
2723 return ArrayOrMatrixSubscriptExprBits.RBracketLoc;
2724 }
2726 ArrayOrMatrixSubscriptExprBits.RBracketLoc = L;
2727 }
2728
2729 SourceLocation getExprLoc() const LLVM_READONLY {
2730 return getBase()->getExprLoc();
2731 }
2732
2733 static bool classof(const Stmt *T) {
2734 return T->getStmtClass() == ArraySubscriptExprClass;
2735 }
2736
2737 // Iterators
2739 return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
2740 }
2742 return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
2743 }
2744};
2745
2746/// MatrixSubscriptExpr - Matrix subscript expression for the MatrixType
2747/// extension.
2748/// MatrixSubscriptExpr can be either incomplete (only Base and RowIdx are set
2749/// so far, the type is IncompleteMatrixIdx) or complete (Base, RowIdx and
2750/// ColumnIdx refer to valid expressions). Incomplete matrix expressions only
2751/// exist during the initial construction of the AST.
2753 enum { BASE, ROW_IDX, COLUMN_IDX, END_EXPR };
2754 Stmt *SubExprs[END_EXPR];
2755
2756public:
2758 SourceLocation RBracketLoc)
2759 : Expr(MatrixSubscriptExprClass, T, Base->getValueKind(),
2761 SubExprs[BASE] = Base;
2762 SubExprs[ROW_IDX] = RowIdx;
2763 SubExprs[COLUMN_IDX] = ColumnIdx;
2764 ArrayOrMatrixSubscriptExprBits.RBracketLoc = RBracketLoc;
2766 }
2767
2768 /// Create an empty matrix subscript expression.
2770 : Expr(MatrixSubscriptExprClass, Shell) {}
2771
2772 bool isIncomplete() const {
2773 bool IsIncomplete = hasPlaceholderType(BuiltinType::IncompleteMatrixIdx);
2774 assert((SubExprs[COLUMN_IDX] || IsIncomplete) &&
2775 "expressions without column index must be marked as incomplete");
2776 return IsIncomplete;
2777 }
2778 Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
2779 const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
2780 void setBase(Expr *E) { SubExprs[BASE] = E; }
2781
2782 Expr *getRowIdx() { return cast<Expr>(SubExprs[ROW_IDX]); }
2783 const Expr *getRowIdx() const { return cast<Expr>(SubExprs[ROW_IDX]); }
2784 void setRowIdx(Expr *E) { SubExprs[ROW_IDX] = E; }
2785
2786 Expr *getColumnIdx() { return cast_or_null<Expr>(SubExprs[COLUMN_IDX]); }
2787 const Expr *getColumnIdx() const {
2788 assert(!isIncomplete() &&
2789 "cannot get the column index of an incomplete expression");
2790 return cast<Expr>(SubExprs[COLUMN_IDX]);
2791 }
2792 void setColumnIdx(Expr *E) { SubExprs[COLUMN_IDX] = E; }
2793
2794 SourceLocation getBeginLoc() const LLVM_READONLY {
2795 return getBase()->getBeginLoc();
2796 }
2797
2799
2800 SourceLocation getExprLoc() const LLVM_READONLY {
2801 return getBase()->getExprLoc();
2802 }
2803
2805 return ArrayOrMatrixSubscriptExprBits.RBracketLoc;
2806 }
2808 ArrayOrMatrixSubscriptExprBits.RBracketLoc = L;
2809 }
2810
2811 static bool classof(const Stmt *T) {
2812 return T->getStmtClass() == MatrixSubscriptExprClass;
2813 }
2814
2815 // Iterators
2817 return child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
2818 }
2820 return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
2821 }
2822};
2823
2824/// CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
2825/// CallExpr itself represents a normal function call, e.g., "f(x, 2)",
2826/// while its subclasses may represent alternative syntax that (semantically)
2827/// results in a function call. For example, CXXOperatorCallExpr is
2828/// a subclass for overloaded operator calls that use operator syntax, e.g.,
2829/// "str1 + str2" to resolve to a function call.
2830class CallExpr : public Expr {
2831 enum { FN = 0, PREARGS_START = 1 };
2832
2833 /// The number of arguments in the call expression.
2834 unsigned NumArgs;
2835
2836 /// The location of the right parentheses. This has a different meaning for
2837 /// the derived classes of CallExpr.
2838 SourceLocation RParenLoc;
2839
2840 // CallExpr store some data in trailing objects. However since CallExpr
2841 // is used a base of other expression classes we cannot use
2842 // llvm::TrailingObjects. Instead we manually perform the pointer arithmetic
2843 // and casts.
2844 //
2845 // The trailing objects are in order:
2846 //
2847 // * A single "Stmt *" for the callee expression.
2848 //
2849 // * An array of getNumPreArgs() "Stmt *" for the pre-argument expressions.
2850 //
2851 // * An array of getNumArgs() "Stmt *" for the argument expressions.
2852 //
2853 // * An optional of type FPOptionsOverride.
2854 //
2855 // Note that we store the offset in bytes from the this pointer to the start
2856 // of the trailing objects. It would be perfectly possible to compute it
2857 // based on the dynamic kind of the CallExpr. However 1.) we have plenty of
2858 // space in the bit-fields of Stmt. 2.) It was benchmarked to be faster to
2859 // compute this once and then load the offset from the bit-fields of Stmt,
2860 // instead of re-computing the offset each time the trailing objects are
2861 // accessed.
2862
2863 /// Return a pointer to the start of the trailing array of "Stmt *".
2864 Stmt **getTrailingStmts() {
2865 return reinterpret_cast<Stmt **>(reinterpret_cast<char *>(this) +
2866 CallExprBits.OffsetToTrailingObjects);
2867 }
2868 Stmt *const *getTrailingStmts() const {
2869 return const_cast<CallExpr *>(this)->getTrailingStmts();
2870 }
2871
2872 /// Map a statement class to the appropriate offset in bytes from the
2873 /// this pointer to the trailing objects.
2874 static unsigned offsetToTrailingObjects(StmtClass SC);
2875
2876 unsigned getSizeOfTrailingStmts() const {
2877 return (1 + getNumPreArgs() + getNumArgs()) * sizeof(Stmt *);
2878 }
2879
2880 size_t getOffsetOfTrailingFPFeatures() const {
2881 assert(hasStoredFPFeatures());
2882 return CallExprBits.OffsetToTrailingObjects + getSizeOfTrailingStmts();
2883 }
2884
2885public:
2886 enum class ADLCallKind : bool { NotADL, UsesADL };
2889
2890protected:
2891 /// Build a call expression, assuming that appropriate storage has been
2892 /// allocated for the trailing objects.
2893 CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
2895 SourceLocation RParenLoc, FPOptionsOverride FPFeatures,
2896 unsigned MinNumArgs, ADLCallKind UsesADL);
2897
2898 /// Build an empty call expression, for deserialization.
2899 CallExpr(StmtClass SC, unsigned NumPreArgs, unsigned NumArgs,
2900 bool hasFPFeatures, EmptyShell Empty);
2901
2902 /// Return the size in bytes needed for the trailing objects.
2903 /// Used by the derived classes to allocate the right amount of storage.
2904 static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs,
2905 bool HasFPFeatures) {
2906 return (1 + NumPreArgs + NumArgs) * sizeof(Stmt *) +
2907 HasFPFeatures * sizeof(FPOptionsOverride);
2908 }
2909
2910 Stmt *getPreArg(unsigned I) {
2911 assert(I < getNumPreArgs() && "Prearg access out of range!");
2912 return getTrailingStmts()[PREARGS_START + I];
2913 }
2914 const Stmt *getPreArg(unsigned I) const {
2915 assert(I < getNumPreArgs() && "Prearg access out of range!");
2916 return getTrailingStmts()[PREARGS_START + I];
2917 }
2918 void setPreArg(unsigned I, Stmt *PreArg) {
2919 assert(I < getNumPreArgs() && "Prearg access out of range!");
2920 getTrailingStmts()[PREARGS_START + I] = PreArg;
2921 }
2922
2923 unsigned getNumPreArgs() const { return CallExprBits.NumPreArgs; }
2924
2925 /// Return a pointer to the trailing FPOptions
2927 assert(hasStoredFPFeatures());
2928 return reinterpret_cast<FPOptionsOverride *>(
2929 reinterpret_cast<char *>(this) + CallExprBits.OffsetToTrailingObjects +
2930 getSizeOfTrailingStmts());
2931 }
2933 assert(hasStoredFPFeatures());
2934 return reinterpret_cast<const FPOptionsOverride *>(
2935 reinterpret_cast<const char *>(this) +
2936 CallExprBits.OffsetToTrailingObjects + getSizeOfTrailingStmts());
2937 }
2938
2939public:
2940 /// Create a call expression.
2941 /// \param Fn The callee expression,
2942 /// \param Args The argument array,
2943 /// \param Ty The type of the call expression (which is *not* the return
2944 /// type in general),
2945 /// \param VK The value kind of the call expression (lvalue, rvalue, ...),
2946 /// \param RParenLoc The location of the right parenthesis in the call
2947 /// expression.
2948 /// \param FPFeatures Floating-point features associated with the call,
2949 /// \param MinNumArgs Specifies the minimum number of arguments. The actual
2950 /// number of arguments will be the greater of Args.size()
2951 /// and MinNumArgs. This is used in a few places to allocate
2952 /// enough storage for the default arguments.
2953 /// \param UsesADL Specifies whether the callee was found through
2954 /// argument-dependent lookup.
2955 ///
2956 /// Note that you can use CreateTemporary if you need a temporary call
2957 /// expression on the stack.
2958 static CallExpr *Create(const ASTContext &Ctx, Expr *Fn,
2960 SourceLocation RParenLoc,
2961 FPOptionsOverride FPFeatures, unsigned MinNumArgs = 0,
2963
2964 /// Create a temporary call expression with no arguments in the memory
2965 /// pointed to by Mem. Mem must points to at least sizeof(CallExpr)
2966 /// + sizeof(Stmt *) bytes of storage, aligned to alignof(CallExpr):
2967 ///
2968 /// \code{.cpp}
2969 /// alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
2970 /// CallExpr *TheCall = CallExpr::CreateTemporary(Buffer, etc);
2971 /// \endcode
2972 static CallExpr *CreateTemporary(void *Mem, Expr *Fn, QualType Ty,
2973 ExprValueKind VK, SourceLocation RParenLoc,
2975
2976 /// Create an empty call expression, for deserialization.
2977 static CallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
2978 bool HasFPFeatures, EmptyShell Empty);
2979
2980 Expr *getCallee() { return cast<Expr>(getTrailingStmts()[FN]); }
2981 const Expr *getCallee() const { return cast<Expr>(getTrailingStmts()[FN]); }
2982 void setCallee(Expr *F) { getTrailingStmts()[FN] = F; }
2983
2985 return static_cast<ADLCallKind>(CallExprBits.UsesADL);
2986 }
2988 CallExprBits.UsesADL = static_cast<bool>(V);
2989 }
2990 bool usesADL() const { return getADLCallKind() == UsesADL; }
2991
2992 bool hasStoredFPFeatures() const { return CallExprBits.HasFPFeatures; }
2993
2995 const Decl *getCalleeDecl() const {
2997 }
2998
2999 /// If the callee is a FunctionDecl, return it. Otherwise return null.
3001 return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
3002 }
3004 return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
3005 }
3006
3007 /// getNumArgs - Return the number of actual arguments to this call.
3008 unsigned getNumArgs() const { return NumArgs; }
3009
3010 /// Retrieve the call arguments.
3012 return reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START +
3013 getNumPreArgs());
3014 }
3015 const Expr *const *getArgs() const {
3016 return reinterpret_cast<const Expr *const *>(
3017 getTrailingStmts() + PREARGS_START + getNumPreArgs());
3018 }
3019
3020 /// getArg - Return the specified argument.
3021 Expr *getArg(unsigned Arg) {
3022 assert(Arg < getNumArgs() && "Arg access out of range!");
3023 return getArgs()[Arg];
3024 }
3025 const Expr *getArg(unsigned Arg) const {
3026 assert(Arg < getNumArgs() && "Arg access out of range!");
3027 return getArgs()[Arg];
3028 }
3029
3030 /// setArg - Set the specified argument.
3031 /// ! the dependence bits might be stale after calling this setter, it is
3032 /// *caller*'s responsibility to recompute them by calling
3033 /// computeDependence().
3034 void setArg(unsigned Arg, Expr *ArgExpr) {
3035 assert(Arg < getNumArgs() && "Arg access out of range!");
3036 getArgs()[Arg] = ArgExpr;
3037 }
3038
3039 /// Compute and set dependence bits.
3042 this, llvm::ArrayRef(
3043 reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START),
3044 getNumPreArgs())));
3045 }
3046
3047 /// Reduce the number of arguments in this call expression. This is used for
3048 /// example during error recovery to drop extra arguments. There is no way
3049 /// to perform the opposite because: 1.) We don't track how much storage
3050 /// we have for the argument array 2.) This would potentially require growing
3051 /// the argument array, something we cannot support since the arguments are
3052 /// stored in a trailing array.
3053 void shrinkNumArgs(unsigned NewNumArgs) {
3054 assert((NewNumArgs <= getNumArgs()) &&
3055 "shrinkNumArgs cannot increase the number of arguments!");
3056 NumArgs = NewNumArgs;
3057 }
3058
3059 /// Bluntly set a new number of arguments without doing any checks whatsoever.
3060 /// Only used during construction of a CallExpr in a few places in Sema.
3061 /// FIXME: Find a way to remove it.
3062 void setNumArgsUnsafe(unsigned NewNumArgs) { NumArgs = NewNumArgs; }
3063
3066 typedef llvm::iterator_range<arg_iterator> arg_range;
3067 typedef llvm::iterator_range<const_arg_iterator> const_arg_range;
3068
3071 return const_arg_range(arg_begin(), arg_end());
3072 }
3073
3075 return getTrailingStmts() + PREARGS_START + getNumPreArgs();
3076 }
3078
3080 return getTrailingStmts() + PREARGS_START + getNumPreArgs();
3081 }
3083
3084 /// This method provides fast access to all the subexpressions of
3085 /// a CallExpr without going through the slower virtual child_iterator
3086 /// interface. This provides efficient reverse iteration of the
3087 /// subexpressions. This is currently used for CFG construction.
3089 return llvm::ArrayRef(getTrailingStmts(),
3090 PREARGS_START + getNumPreArgs() + getNumArgs());
3091 }
3092
3093 /// Get FPOptionsOverride from trailing storage.
3095 assert(hasStoredFPFeatures());
3096 return *getTrailingFPFeatures();
3097 }
3098 /// Set FPOptionsOverride in trailing storage. Used only by Serialization.
3100 assert(hasStoredFPFeatures());
3101 *getTrailingFPFeatures() = F;
3102 }
3103
3104 /// Get the store FPOptionsOverride or default if not stored.
3107 }
3108
3109 /// Get the FP features status of this operator. Only meaningful for
3110 /// operations on floating point types.
3112 if (hasStoredFPFeatures())
3115 }
3116
3118 if (hasStoredFPFeatures())
3119 return getStoredFPFeatures();
3120 return FPOptionsOverride();
3121 }
3122
3123 /// getBuiltinCallee - If this is a call to a builtin, return the builtin ID
3124 /// of the callee. If not, return 0.
3125 unsigned getBuiltinCallee() const;
3126
3127 /// Returns \c true if this is a call to a builtin which does not
3128 /// evaluate side-effects within its arguments.
3129 bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const;
3130
3131 /// getCallReturnType - Get the return type of the call expr. This is not
3132 /// always the type of the expr itself, if the return type is a reference
3133 /// type.
3134 QualType getCallReturnType(const ASTContext &Ctx) const;
3135
3136 /// Returns the WarnUnusedResultAttr that is either declared on the called
3137 /// function, or its return type declaration.
3138 const Attr *getUnusedResultAttr(const ASTContext &Ctx) const;
3139
3140 /// Returns true if this call expression should warn on unused results.
3141 bool hasUnusedResultAttr(const ASTContext &Ctx) const {
3142 return getUnusedResultAttr(Ctx) != nullptr;
3143 }
3144
3145 SourceLocation getRParenLoc() const { return RParenLoc; }
3146 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3147
3148 SourceLocation getBeginLoc() const LLVM_READONLY;
3149 SourceLocation getEndLoc() const LLVM_READONLY;
3150
3151 /// Return true if this is a call to __assume() or __builtin_assume() with
3152 /// a non-value-dependent constant parameter evaluating as false.
3153 bool isBuiltinAssumeFalse(const ASTContext &Ctx) const;
3154
3155 /// Used by Sema to implement MSVC-compatible delayed name lookup.
3156 /// (Usually Exprs themselves should set dependence).
3158 setDependence(getDependence() | ExprDependence::TypeValueInstantiation);
3159 }
3160
3161 bool isCallToStdMove() const;
3162
3163 static bool classof(const Stmt *T) {
3164 return T->getStmtClass() >= firstCallExprConstant &&
3165 T->getStmtClass() <= lastCallExprConstant;
3166 }
3167
3168 // Iterators
3170 return child_range(getTrailingStmts(), getTrailingStmts() + PREARGS_START +
3172 }
3173
3175 return const_child_range(getTrailingStmts(),
3176 getTrailingStmts() + PREARGS_START +
3178 }
3179};
3180
3181/// MemberExpr - [C99 6.5.2.3] Structure and Union Members. X->F and X.F.
3182///
3183class MemberExpr final
3184 : public Expr,
3185 private llvm::TrailingObjects<MemberExpr, NestedNameSpecifierLoc,
3186 DeclAccessPair, ASTTemplateKWAndArgsInfo,
3187 TemplateArgumentLoc> {
3188 friend class ASTReader;
3189 friend class ASTStmtReader;
3190 friend class ASTStmtWriter;
3191 friend TrailingObjects;
3192
3193 /// Base - the expression for the base pointer or structure references. In
3194 /// X.F, this is "X".
3195 Stmt *Base;
3196
3197 /// MemberDecl - This is the decl being referenced by the field/member name.
3198 /// In X.F, this is the decl referenced by F.
3199 ValueDecl *MemberDecl;
3200
3201 /// MemberDNLoc - Provides source/type location info for the
3202 /// declaration name embedded in MemberDecl.
3203 DeclarationNameLoc MemberDNLoc;
3204
3205 /// MemberLoc - This is the location of the member name.
3206 SourceLocation MemberLoc;
3207
3208 size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>) const {
3209 return hasQualifier();
3210 }
3211
3212 size_t numTrailingObjects(OverloadToken<DeclAccessPair>) const {
3213 return hasFoundDecl();
3214 }
3215
3216 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
3217 return hasTemplateKWAndArgsInfo();
3218 }
3219
3220 bool hasFoundDecl() const { return MemberExprBits.HasFoundDecl; }
3221
3222 bool hasTemplateKWAndArgsInfo() const {
3223 return MemberExprBits.HasTemplateKWAndArgsInfo;
3224 }
3225
3226 MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
3227 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3228 ValueDecl *MemberDecl, DeclAccessPair FoundDecl,
3229 const DeclarationNameInfo &NameInfo,
3230 const TemplateArgumentListInfo *TemplateArgs, QualType T,
3232 MemberExpr(EmptyShell Empty)
3233 : Expr(MemberExprClass, Empty), Base(), MemberDecl() {}
3234
3235public:
3236 static MemberExpr *Create(const ASTContext &C, Expr *Base, bool IsArrow,
3237 SourceLocation OperatorLoc,
3238 NestedNameSpecifierLoc QualifierLoc,
3239 SourceLocation TemplateKWLoc, ValueDecl *MemberDecl,
3240 DeclAccessPair FoundDecl,
3241 DeclarationNameInfo MemberNameInfo,
3242 const TemplateArgumentListInfo *TemplateArgs,
3243 QualType T, ExprValueKind VK, ExprObjectKind OK,
3244 NonOdrUseReason NOUR);
3245
3246 /// Create an implicit MemberExpr, with no location, qualifier, template
3247 /// arguments, and so on. Suitable only for non-static member access.
3249 bool IsArrow, ValueDecl *MemberDecl,
3251 ExprObjectKind OK) {
3252 return Create(C, Base, IsArrow, SourceLocation(), NestedNameSpecifierLoc(),
3253 SourceLocation(), MemberDecl,
3254 DeclAccessPair::make(MemberDecl, MemberDecl->getAccess()),
3255 DeclarationNameInfo(), nullptr, T, VK, OK, NOUR_None);
3256 }
3257
3258 static MemberExpr *CreateEmpty(const ASTContext &Context, bool HasQualifier,
3259 bool HasFoundDecl,
3260 bool HasTemplateKWAndArgsInfo,
3261 unsigned NumTemplateArgs);
3262
3263 void setBase(Expr *E) { Base = E; }
3264 Expr *getBase() const { return cast<Expr>(Base); }
3265
3266 /// Retrieve the member declaration to which this expression refers.
3267 ///
3268 /// The returned declaration will be a FieldDecl or (in C++) a VarDecl (for
3269 /// static data members), a CXXMethodDecl, or an EnumConstantDecl.
3270 ValueDecl *getMemberDecl() const { return MemberDecl; }
3271 void setMemberDecl(ValueDecl *D);
3272
3273 /// Retrieves the declaration found by lookup.
3275 if (!hasFoundDecl())
3277 getMemberDecl()->getAccess());
3278 return *getTrailingObjects<DeclAccessPair>();
3279 }
3280
3281 /// Determines whether this member expression actually had
3282 /// a C++ nested-name-specifier prior to the name of the member, e.g.,
3283 /// x->Base::foo.
3284 bool hasQualifier() const { return MemberExprBits.HasQualifier; }
3285
3286 /// If the member name was qualified, retrieves the
3287 /// nested-name-specifier that precedes the member name, with source-location
3288 /// information.
3290 if (!hasQualifier())
3291 return NestedNameSpecifierLoc();
3292 return *getTrailingObjects<NestedNameSpecifierLoc>();
3293 }
3294
3295 /// If the member name was qualified, retrieves the
3296 /// nested-name-specifier that precedes the member name. Otherwise, returns
3297 /// NULL.
3300 }
3301
3302 /// Retrieve the location of the template keyword preceding
3303 /// the member name, if any.
3305 if (!hasTemplateKWAndArgsInfo())
3306 return SourceLocation();
3307 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3308 }
3309
3310 /// Retrieve the location of the left angle bracket starting the
3311 /// explicit template argument list following the member name, if any.
3313 if (!hasTemplateKWAndArgsInfo())
3314 return SourceLocation();
3315 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3316 }
3317
3318 /// Retrieve the location of the right angle bracket ending the
3319 /// explicit template argument list following the member name, if any.
3321 if (!hasTemplateKWAndArgsInfo())
3322 return SourceLocation();
3323 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3324 }
3325
3326 /// Determines whether the member name was preceded by the template keyword.
3328
3329 /// Determines whether the member name was followed by an
3330 /// explicit template argument list.
3331 bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }
3332
3333 /// Copies the template arguments (if present) into the given
3334 /// structure.
3337 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3338 getTrailingObjects<TemplateArgumentLoc>(), List);
3339 }
3340
3341 /// Retrieve the template arguments provided as part of this
3342 /// template-id.
3345 return nullptr;
3346
3347 return getTrailingObjects<TemplateArgumentLoc>();
3348 }
3349
3350 /// Retrieve the number of template arguments provided as part of this
3351 /// template-id.
3352 unsigned getNumTemplateArgs() const {
3354 return 0;
3355
3356 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3357 }
3358
3360 return {getTemplateArgs(), getNumTemplateArgs()};
3361 }
3362
3363 /// Retrieve the member declaration name info.
3365 return DeclarationNameInfo(MemberDecl->getDeclName(),
3366 MemberLoc, MemberDNLoc);
3367 }
3368
3369 SourceLocation getOperatorLoc() const { return MemberExprBits.OperatorLoc; }
3370
3371 bool isArrow() const { return MemberExprBits.IsArrow; }
3372 void setArrow(bool A) { MemberExprBits.IsArrow = A; }
3373
3374 /// getMemberLoc - Return the location of the "member", in X->F, it is the
3375 /// location of 'F'.
3376 SourceLocation getMemberLoc() const { return MemberLoc; }
3377 void setMemberLoc(SourceLocation L) { MemberLoc = L; }
3378
3379 SourceLocation getBeginLoc() const LLVM_READONLY;
3380 SourceLocation getEndLoc() const LLVM_READONLY;
3381
3382 SourceLocation getExprLoc() const LLVM_READONLY { return MemberLoc; }
3383
3384 /// Determine whether the base of this explicit is implicit.
3385 bool isImplicitAccess() const {
3386 return getBase() && getBase()->isImplicitCXXThis();
3387 }
3388
3389 /// Returns true if this member expression refers to a method that
3390 /// was resolved from an overloaded set having size greater than 1.
3392 return MemberExprBits.HadMultipleCandidates;
3393 }
3394 /// Sets the flag telling whether this expression refers to
3395 /// a method that was resolved from an overloaded set having size
3396 /// greater than 1.
3397 void setHadMultipleCandidates(bool V = true) {
3398 MemberExprBits.HadMultipleCandidates = V;
3399 }
3400
3401 /// Returns true if virtual dispatch is performed.
3402 /// If the member access is fully qualified, (i.e. X::f()), virtual
3403 /// dispatching is not performed. In -fapple-kext mode qualified
3404 /// calls to virtual method will still go through the vtable.
3405 bool performsVirtualDispatch(const LangOptions &LO) const {
3406 return LO.AppleKext || !hasQualifier();
3407 }
3408
3409 /// Is this expression a non-odr-use reference, and if so, why?
3410 /// This is only meaningful if the named member is a static member.
3412 return static_cast<NonOdrUseReason>(MemberExprBits.NonOdrUseReason);
3413 }
3414
3415 static bool classof(const Stmt *T) {
3416 return T->getStmtClass() == MemberExprClass;
3417 }
3418
3419 // Iterators
3422 return const_child_range(&Base, &Base + 1);
3423 }
3424};
3425
3426/// CompoundLiteralExpr - [C99 6.5.2.5]
3427///
3429 /// LParenLoc - If non-null, this is the location of the left paren in a
3430 /// compound literal like "(int){4}". This can be null if this is a
3431 /// synthesized compound expression.
3432 SourceLocation LParenLoc;
3433
3434 /// The type as written. This can be an incomplete array type, in
3435 /// which case the actual expression type will be different.
3436 /// The int part of the pair stores whether this expr is file scope.
3437 llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfoAndScope;
3438 Stmt *Init;
3439public:
3441 QualType T, ExprValueKind VK, Expr *init, bool fileScope)
3442 : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary),
3443 LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) {
3445 }
3446
3447 /// Construct an empty compound literal.
3449 : Expr(CompoundLiteralExprClass, Empty) { }
3450
3451 const Expr *getInitializer() const { return cast<Expr>(Init); }
3452 Expr *getInitializer() { return cast<Expr>(Init); }
3453 void setInitializer(Expr *E) { Init = E; }
3454
3455 bool isFileScope() const { return TInfoAndScope.getInt(); }
3456 void setFileScope(bool FS) { TInfoAndScope.setInt(FS); }
3457
3458 SourceLocation getLParenLoc() const { return LParenLoc; }
3459 void setLParenLoc(SourceLocation L) { LParenLoc = L; }
3460
3462 return TInfoAndScope.getPointer();
3463 }
3465 TInfoAndScope.setPointer(tinfo);
3466 }
3467
3468 SourceLocation getBeginLoc() const LLVM_READONLY {
3469 // FIXME: Init should never be null.
3470 if (!Init)
3471 return SourceLocation();
3472 if (LParenLoc.isInvalid())
3473 return Init->getBeginLoc();
3474 return LParenLoc;
3475 }
3476 SourceLocation getEndLoc() const LLVM_READONLY {
3477 // FIXME: Init should never be null.
3478 if (!Init)
3479 return SourceLocation();
3480 return Init->getEndLoc();
3481 }
3482
3483 static bool classof(const Stmt *T) {
3484 return T->getStmtClass() == CompoundLiteralExprClass;
3485 }
3486
3487 // Iterators
3488 child_range children() { return child_range(&Init, &Init+1); }
3490 return const_child_range(&Init, &Init + 1);
3491 }
3492};
3493
3494/// CastExpr - Base class for type casts, including both implicit
3495/// casts (ImplicitCastExpr) and explicit casts that have some
3496/// representation in the source code (ExplicitCastExpr's derived
3497/// classes).
3498class CastExpr : public Expr {
3499 Stmt *Op;
3500
3501 bool CastConsistency() const;
3502
3503 const CXXBaseSpecifier * const *path_buffer() const {
3504 return const_cast<CastExpr*>(this)->path_buffer();
3505 }
3506 CXXBaseSpecifier **path_buffer();
3507
3508 friend class ASTStmtReader;
3509
3510protected:
3512 Expr *op, unsigned BasePathSize, bool HasFPFeatures)
3513 : Expr(SC, ty, VK, OK_Ordinary), Op(op) {
3514 CastExprBits.Kind = kind;
3515 CastExprBits.PartOfExplicitCast = false;
3516 CastExprBits.BasePathSize = BasePathSize;
3517 assert((CastExprBits.BasePathSize == BasePathSize) &&
3518 "BasePathSize overflow!");
3519 assert(CastConsistency());
3520 CastExprBits.HasFPFeatures = HasFPFeatures;
3521 }
3522
3523 /// Construct an empty cast.
3524 CastExpr(StmtClass SC, EmptyShell Empty, unsigned BasePathSize,
3525 bool HasFPFeatures)
3526 : Expr(SC, Empty) {
3527 CastExprBits.PartOfExplicitCast = false;
3528 CastExprBits.BasePathSize = BasePathSize;
3529 CastExprBits.HasFPFeatures = HasFPFeatures;
3530 assert((CastExprBits.BasePathSize == BasePathSize) &&
3531 "BasePathSize overflow!");
3532 }
3533
3534 /// Return a pointer to the trailing FPOptions.
3535 /// \pre hasStoredFPFeatures() == true
3538 return const_cast<CastExpr *>(this)->getTrailingFPFeatures();
3539 }
3540
3541public:
3542 CastKind getCastKind() const { return (CastKind) CastExprBits.Kind; }
3543 void setCastKind(CastKind K) { CastExprBits.Kind = K; }
3544
3545 static const char *getCastKindName(CastKind CK);
3546 const char *getCastKindName() const { return getCastKindName(getCastKind()); }
3547
3548 Expr *getSubExpr() { return cast<Expr>(Op); }
3549 const Expr *getSubExpr() const { return cast<Expr>(Op); }
3550 void setSubExpr(Expr *E) { Op = E; }
3551
3552 /// Retrieve the cast subexpression as it was written in the source
3553 /// code, looking through any implicit casts or other intermediate nodes
3554 /// introduced by semantic analysis.
3556 const Expr *getSubExprAsWritten() const {
3557 return const_cast<CastExpr *>(this)->getSubExprAsWritten();
3558 }
3559
3560 /// If this cast applies a user-defined conversion, retrieve the conversion
3561 /// function that it invokes.
3563
3566 bool path_empty() const { return path_size() == 0; }
3567 unsigned path_size() const { return CastExprBits.BasePathSize; }
3568 path_iterator path_begin() { return path_buffer(); }
3569 path_iterator path_end() { return path_buffer() + path_size(); }
3570 path_const_iterator path_begin() const { return path_buffer(); }
3571 path_const_iterator path_end() const { return path_buffer() + path_size(); }
3572
3573 /// Path through the class hierarchy taken by casts between base and derived
3574 /// classes (see implementation of `CastConsistency()` for a full list of
3575 /// cast kinds that have a path).
3576 ///
3577 /// For each derived-to-base edge in the path, the path contains a
3578 /// `CXXBaseSpecifier` for the base class of that edge; the entries are
3579 /// ordered from derived class to base class.
3580 ///
3581 /// For example, given classes `Base`, `Intermediate : public Base` and
3582 /// `Derived : public Intermediate`, the path for a cast from `Derived *` to
3583 /// `Base *` contains two entries: One for `Intermediate`, and one for `Base`,
3584 /// in that order.
3585 llvm::iterator_range<path_iterator> path() {
3586 return llvm::make_range(path_begin(), path_end());
3587 }
3588 llvm::iterator_range<path_const_iterator> path() const {
3589 return llvm::make_range(path_begin(), path_end());
3590 }
3591
3593 assert(getCastKind() == CK_ToUnion);
3595 }
3596
3597 bool hasStoredFPFeatures() const { return CastExprBits.HasFPFeatures; }
3598
3599 /// Get FPOptionsOverride from trailing storage.
3601 assert(hasStoredFPFeatures());
3602 return *getTrailingFPFeatures();
3603 }
3604
3605 /// Get the store FPOptionsOverride or default if not stored.
3608 }
3609
3610 /// Get the FP features status of this operation. Only meaningful for
3611 /// operations on floating point types.
3613 if (hasStoredFPFeatures())
3616 }
3617
3619 if (hasStoredFPFeatures())
3620 return getStoredFPFeatures();
3621 return FPOptionsOverride();
3622 }
3623
3624 /// Return
3625 // True : if this conversion changes the volatile-ness of a gl-value.
3626 // Qualification conversions on gl-values currently use CK_NoOp, but
3627 // it's important to recognize volatile-changing conversions in
3628 // clients code generation that normally eagerly peephole loads. Note
3629 // that the query is answering for this specific node; Sema may
3630 // produce multiple cast nodes for any particular conversion sequence.
3631 // False : Otherwise.
3633 return (isGLValue() && (getType().isVolatileQualified() !=
3634 getSubExpr()->getType().isVolatileQualified()));
3635 }
3636
3637 static const FieldDecl *getTargetFieldForToUnionCast(QualType unionType,
3638 QualType opType);
3639 static const FieldDecl *getTargetFieldForToUnionCast(const RecordDecl *RD,
3640 QualType opType);
3641
3642 static bool classof(const Stmt *T) {
3643 return T->getStmtClass() >= firstCastExprConstant &&
3644 T->getStmtClass() <= lastCastExprConstant;
3645 }
3646
3647 // Iterators
3648 child_range children() { return child_range(&Op, &Op+1); }
3649 const_child_range children() const { return const_child_range(&Op, &Op + 1); }
3650};
3651
3652/// ImplicitCastExpr - Allows us to explicitly represent implicit type
3653/// conversions, which have no direct representation in the original
3654/// source code. For example: converting T[]->T*, void f()->void
3655/// (*f)(), float->double, short->int, etc.
3656///
3657/// In C, implicit casts always produce rvalues. However, in C++, an
3658/// implicit cast whose result is being bound to a reference will be
3659/// an lvalue or xvalue. For example:
3660///
3661/// @code
3662/// class Base { };
3663/// class Derived : public Base { };
3664/// Derived &&ref();
3665/// void f(Derived d) {
3666/// Base& b = d; // initializer is an ImplicitCastExpr
3667/// // to an lvalue of type Base
3668/// Base&& r = ref(); // initializer is an ImplicitCastExpr
3669/// // to an xvalue of type Base
3670/// }
3671/// @endcode
3673 : public CastExpr,
3674 private llvm::TrailingObjects<ImplicitCastExpr, CXXBaseSpecifier *,
3675 FPOptionsOverride> {
3676
3677 ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
3678 unsigned BasePathLength, FPOptionsOverride FPO,
3679 ExprValueKind VK)
3680 : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, BasePathLength,
3683 if (hasStoredFPFeatures())
3684 *getTrailingFPFeatures() = FPO;
3685 }
3686
3687 /// Construct an empty implicit cast.
3688 explicit ImplicitCastExpr(EmptyShell Shell, unsigned PathSize,
3689 bool HasFPFeatures)
3690 : CastExpr(ImplicitCastExprClass, Shell, PathSize, HasFPFeatures) {}
3691
3692 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
3693 return path_size();
3694 }
3695
3696public:
3700 : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, 0,
3701 FPO.requiresTrailingStorage()) {
3702 if (hasStoredFPFeatures())
3703 *getTrailingFPFeatures() = FPO;
3704 }
3705
3706 bool isPartOfExplicitCast() const { return CastExprBits.PartOfExplicitCast; }
3707 void setIsPartOfExplicitCast(bool PartOfExplicitCast) {
3708 CastExprBits.PartOfExplicitCast = PartOfExplicitCast;
3709 }
3710
3711 static ImplicitCastExpr *Create(const ASTContext &Context, QualType T,
3712 CastKind Kind, Expr *Operand,
3713 const CXXCastPath *BasePath,
3715
3716 static ImplicitCastExpr *CreateEmpty(const ASTContext &Context,
3717 unsigned PathSize, bool HasFPFeatures);
3718
3719 SourceLocation getBeginLoc() const LLVM_READONLY {
3720 return getSubExpr()->getBeginLoc();
3721 }
3722 SourceLocation getEndLoc() const LLVM_READONLY {
3723 return getSubExpr()->getEndLoc();
3724 }
3725
3726 static bool classof(const Stmt *T) {
3727 return T->getStmtClass() == ImplicitCastExprClass;
3728 }
3729
3731 friend class CastExpr;
3732};
3733
3734/// ExplicitCastExpr - An explicit cast written in the source
3735/// code.
3736///
3737/// This class is effectively an abstract class, because it provides
3738/// the basic representation of an explicitly-written cast without
3739/// specifying which kind of cast (C cast, functional cast, static
3740/// cast, etc.) was written; specific derived classes represent the
3741/// particular style of cast and its location information.
3742///
3743/// Unlike implicit casts, explicit cast nodes have two different
3744/// types: the type that was written into the source code, and the
3745/// actual type of the expression as determined by semantic
3746/// analysis. These types may differ slightly. For example, in C++ one
3747/// can cast to a reference type, which indicates that the resulting
3748/// expression will be an lvalue or xvalue. The reference type, however,
3749/// will not be used as the type of the expression.
3751 /// TInfo - Source type info for the (written) type
3752 /// this expression is casting to.
3753 TypeSourceInfo *TInfo;
3754
3755protected:
3757 CastKind kind, Expr *op, unsigned PathSize,
3758 bool HasFPFeatures, TypeSourceInfo *writtenTy)
3759 : CastExpr(SC, exprTy, VK, kind, op, PathSize, HasFPFeatures),
3760 TInfo(writtenTy) {
3762 }
3763
3764 /// Construct an empty explicit cast.
3765 ExplicitCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize,
3766 bool HasFPFeatures)
3767 : CastExpr(SC, Shell, PathSize, HasFPFeatures) {}
3768
3769public:
3770 /// getTypeInfoAsWritten - Returns the type source info for the type
3771 /// that this expression is casting to.
3772 TypeSourceInfo *getTypeInfoAsWritten() const { return TInfo; }
3773 void setTypeInfoAsWritten(TypeSourceInfo *writtenTy) { TInfo = writtenTy; }
3774
3775 /// getTypeAsWritten - Returns the type that this expression is
3776 /// casting to, as written in the source code.
3777 QualType getTypeAsWritten() const { return TInfo->getType(); }
3778
3779 static bool classof(const Stmt *T) {
3780 return T->getStmtClass() >= firstExplicitCastExprConstant &&
3781 T->getStmtClass() <= lastExplicitCastExprConstant;
3782 }
3783};
3784
3785/// CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style
3786/// cast in C++ (C++ [expr.cast]), which uses the syntax
3787/// (Type)expr. For example: @c (int)f.
3789 : public ExplicitCastExpr,
3790 private llvm::TrailingObjects<CStyleCastExpr, CXXBaseSpecifier *,
3791 FPOptionsOverride> {
3792 SourceLocation LPLoc; // the location of the left paren
3793 SourceLocation RPLoc; // the location of the right paren
3794
3795 CStyleCastExpr(QualType exprTy, ExprValueKind vk, CastKind kind, Expr *op,
3796 unsigned PathSize, FPOptionsOverride FPO,
3798 : ExplicitCastExpr(CStyleCastExprClass, exprTy, vk, kind, op, PathSize,
3799 FPO.requiresTrailingStorage(), writtenTy),
3800 LPLoc(l), RPLoc(r) {
3801 if (hasStoredFPFeatures())
3802 *getTrailingFPFeatures() = FPO;
3803 }
3804
3805 /// Construct an empty C-style explicit cast.
3806 explicit CStyleCastExpr(EmptyShell Shell, unsigned PathSize,
3807 bool HasFPFeatures)
3808 : ExplicitCastExpr(CStyleCastExprClass, Shell, PathSize, HasFPFeatures) {}
3809
3810 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
3811 return path_size();
3812 }
3813
3814public:
3815 static CStyleCastExpr *
3816 Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K,
3817 Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO,
3819
3820 static CStyleCastExpr *CreateEmpty(const ASTContext &Context,
3821 unsigned PathSize, bool HasFPFeatures);
3822
3823 SourceLocation getLParenLoc() const { return LPLoc; }
3824 void setLParenLoc(SourceLocation L) { LPLoc = L; }
3825
3826 SourceLocation getRParenLoc() const { return RPLoc; }
3827 void setRParenLoc(SourceLocation L) { RPLoc = L; }
3828
3829 SourceLocation getBeginLoc() const LLVM_READONLY { return LPLoc; }
3830 SourceLocation getEndLoc() const LLVM_READONLY {
3831 return getSubExpr()->getEndLoc();
3832 }
3833
3834 static bool classof(const Stmt *T) {
3835 return T->getStmtClass() == CStyleCastExprClass;
3836 }
3837
3839 friend class CastExpr;
3840};
3841
3842/// A builtin binary operation expression such as "x + y" or "x <= y".
3843///
3844/// This expression node kind describes a builtin binary operation,
3845/// such as "x + y" for integer values "x" and "y". The operands will
3846/// already have been converted to appropriate types (e.g., by
3847/// performing promotions or conversions).
3848///
3849/// In C++, where operators may be overloaded, a different kind of
3850/// expression node (CXXOperatorCallExpr) is used to express the
3851/// invocation of an overloaded operator with operator syntax. Within
3852/// a C++ template, whether BinaryOperator or CXXOperatorCallExpr is
3853/// used to store an expression "x + y" depends on the subexpressions
3854/// for x and y. If neither x or y is type-dependent, and the "+"
3855/// operator resolves to a built-in operation, BinaryOperator will be
3856/// used to express the computation (x and y may still be
3857/// value-dependent). If either x or y is type-dependent, or if the
3858/// "+" resolves to an overloaded operator, CXXOperatorCallExpr will
3859/// be used to express the computation.
3860class BinaryOperator : public Expr {
3861 enum { LHS, RHS, END_EXPR };
3862 Stmt *SubExprs[END_EXPR];
3863
3864public:
3866
3867protected:
3868 size_t offsetOfTrailingStorage() const;
3869
3870 /// Return a pointer to the trailing FPOptions
3872 assert(BinaryOperatorBits.HasFPFeatures);
3873 return reinterpret_cast<FPOptionsOverride *>(
3874 reinterpret_cast<char *>(this) + offsetOfTrailingStorage());
3875 }
3877 assert(BinaryOperatorBits.HasFPFeatures);
3878 return reinterpret_cast<const FPOptionsOverride *>(
3879 reinterpret_cast<const char *>(this) + offsetOfTrailingStorage());
3880 }
3881
3882 /// Build a binary operator, assuming that appropriate storage has been
3883 /// allocated for the trailing objects when needed.
3884 BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs, Opcode opc,
3886 SourceLocation opLoc, FPOptionsOverride FPFeatures);
3887
3888 /// Construct an empty binary operator.
3889 explicit BinaryOperator(EmptyShell Empty) : Expr(BinaryOperatorClass, Empty) {
3890 BinaryOperatorBits.Opc = BO_Comma;
3891 BinaryOperatorBits.ExcludedOverflowPattern = false;
3892 }
3893
3894public:
3895 static BinaryOperator *CreateEmpty(const ASTContext &C, bool hasFPFeatures);
3896
3897 static BinaryOperator *Create(const ASTContext &C, Expr *lhs, Expr *rhs,
3898 Opcode opc, QualType ResTy, ExprValueKind VK,
3900 FPOptionsOverride FPFeatures);
3904
3906 return static_cast<Opcode>(BinaryOperatorBits.Opc);
3907 }
3908 void setOpcode(Opcode Opc) { BinaryOperatorBits.Opc = Opc; }
3909
3910 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3911 void setLHS(Expr *E) { SubExprs[LHS] = E; }
3912 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3913 void setRHS(Expr *E) { SubExprs[RHS] = E; }
3914
3915 SourceLocation getBeginLoc() const LLVM_READONLY {
3916 return getLHS()->getBeginLoc();
3917 }
3918 SourceLocation getEndLoc() const LLVM_READONLY {
3919 return getRHS()->getEndLoc();
3920 }
3921
3922 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
3923 /// corresponds to, e.g. "<<=".
3924 static StringRef getOpcodeStr(Opcode Op);
3925
3926 StringRef getOpcodeStr() const { return getOpcodeStr(getOpcode()); }
3927
3928 /// Retrieve the binary opcode that corresponds to the given
3929 /// overloaded operator.
3931
3932 /// Retrieve the overloaded operator kind that corresponds to
3933 /// the given binary opcode.
3935
3936 /// predicates to categorize the respective opcodes.
3937 static bool isPtrMemOp(Opcode Opc) {
3938 return Opc == BO_PtrMemD || Opc == BO_PtrMemI;
3939 }
3940 bool isPtrMemOp() const { return isPtrMemOp(getOpcode()); }
3941
3942 static bool isMultiplicativeOp(Opcode Opc) {
3943 return Opc >= BO_Mul && Opc <= BO_Rem;
3944 }
3946 static bool isAdditiveOp(Opcode Opc) { return Opc == BO_Add || Opc==BO_Sub; }
3947 bool isAdditiveOp() const { return isAdditiveOp(getOpcode()); }
3948 static bool isShiftOp(Opcode Opc) { return Opc == BO_Shl || Opc == BO_Shr; }
3949 bool isShiftOp() const { return isShiftOp(getOpcode()); }
3950
3951 static bool isBitwiseOp(Opcode Opc) { return Opc >= BO_And && Opc <= BO_Or; }
3952 bool isBitwiseOp() const { return isBitwiseOp(getOpcode()); }
3953
3954 static bool isRelationalOp(Opcode Opc) { return Opc >= BO_LT && Opc<=BO_GE; }
3955 bool isRelationalOp() const { return isRelationalOp(getOpcode()); }
3956
3957 static bool isEqualityOp(Opcode Opc) { return Opc == BO_EQ || Opc == BO_NE; }
3958 bool isEqualityOp() const { return isEqualityOp(getOpcode()); }
3959
3960 static bool isComparisonOp(Opcode Opc) { return Opc >= BO_Cmp && Opc<=BO_NE; }
3961 bool isComparisonOp() const { return isComparisonOp(getOpcode()); }
3962
3963 static bool isCommaOp(Opcode Opc) { return Opc == BO_Comma; }
3964 bool isCommaOp() const { return isCommaOp(getOpcode()); }
3965
3967 switch (Opc) {
3968 default:
3969 llvm_unreachable("Not a comparison operator.");
3970 case BO_LT: return BO_GE;
3971 case BO_GT: return BO_LE;
3972 case BO_LE: return BO_GT;
3973 case BO_GE: return BO_LT;
3974 case BO_EQ: return BO_NE;
3975 case BO_NE: return BO_EQ;
3976 }
3977 }
3978
3980 switch (Opc) {
3981 default:
3982 llvm_unreachable("Not a comparison operator.");
3983 case BO_LT: return BO_GT;
3984 case BO_GT: return BO_LT;
3985 case BO_LE: return BO_GE;
3986 case BO_GE: return BO_LE;
3987 case BO_EQ:
3988 case BO_NE:
3989 return Opc;
3990 }
3991 }
3992
3993 static bool isLogicalOp(Opcode Opc) { return Opc == BO_LAnd || Opc==BO_LOr; }
3994 bool isLogicalOp() const { return isLogicalOp(getOpcode()); }
3995
3996 static bool isAssignmentOp(Opcode Opc) {
3997 return Opc >= BO_Assign && Opc <= BO_OrAssign;
3998 }
3999 bool isAssignmentOp() const { return isAssignmentOp(getOpcode()); }
4000
4002 return Opc > BO_Assign && Opc <= BO_OrAssign;
4003 }
4006 }
4008 assert(isCompoundAssignmentOp(Opc));
4009 if (Opc >= BO_AndAssign)
4010 return Opcode(unsigned(Opc) - BO_AndAssign + BO_And);
4011 else
4012 return Opcode(unsigned(Opc) - BO_MulAssign + BO_Mul);
4013 }
4014
4015 static bool isShiftAssignOp(Opcode Opc) {
4016 return Opc == BO_ShlAssign || Opc == BO_ShrAssign;
4017 }
4018 bool isShiftAssignOp() const {
4019 return isShiftAssignOp(getOpcode());
4020 }
4021
4022 /// Return true if a binary operator using the specified opcode and operands
4023 /// would match the 'p = (i8*)nullptr + n' idiom for casting a pointer-sized
4024 /// integer to a pointer.
4026 const Expr *LHS,
4027 const Expr *RHS);
4028
4029 static bool classof(const Stmt *S) {
4030 return S->getStmtClass() >= firstBinaryOperatorConstant &&
4031 S->getStmtClass() <= lastBinaryOperatorConstant;
4032 }
4033
4034 // Iterators
4036 return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
4037 }
4039 return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
4040 }
4041
4042 /// Set and fetch the bit that shows whether FPFeatures needs to be
4043 /// allocated in Trailing Storage
4044 void setHasStoredFPFeatures(bool B) { BinaryOperatorBits.HasFPFeatures = B; }
4045 bool hasStoredFPFeatures() const { return BinaryOperatorBits.HasFPFeatures; }
4046
4047 /// Set and get the bit that informs arithmetic overflow sanitizers whether
4048 /// or not they should exclude certain BinaryOperators from instrumentation
4050 BinaryOperatorBits.ExcludedOverflowPattern = B;
4051 }
4053 return BinaryOperatorBits.ExcludedOverflowPattern;
4054 }
4055
4056 /// Get FPFeatures from trailing storage
4058 assert(hasStoredFPFeatures());
4059 return *getTrailingFPFeatures();
4060 }
4061 /// Set FPFeatures in trailing storage, used only by Serialization
4063 assert(BinaryOperatorBits.HasFPFeatures);
4064 *getTrailingFPFeatures() = F;
4065 }
4066 /// Get the store FPOptionsOverride or default if not stored.
4069 }
4070
4071 /// Get the FP features status of this operator. Only meaningful for
4072 /// operations on floating point types.
4074 if (BinaryOperatorBits.HasFPFeatures)
4077 }
4078
4079 // This is used in ASTImporter
4081 if (BinaryOperatorBits.HasFPFeatures)
4082 return getStoredFPFeatures();
4083 return FPOptionsOverride();
4084 }
4085
4086 /// Get the FP contractibility status of this operator. Only meaningful for
4087 /// operations on floating point types.
4090 }
4091
4092 /// Get the FENV_ACCESS status of this operator. Only meaningful for
4093 /// operations on floating point types.
4094 bool isFEnvAccessOn(const LangOptions &LO) const {
4095 return getFPFeaturesInEffect(LO).getAllowFEnvAccess();
4096 }
4097
4098protected:
4099 BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs, Opcode opc,
4101 SourceLocation opLoc, FPOptionsOverride FPFeatures,
4102 bool dead2);
4103
4104 /// Construct an empty BinaryOperator, SC is CompoundAssignOperator.
4106 BinaryOperatorBits.Opc = BO_MulAssign;
4107 }
4108
4109 /// Return the size in bytes needed for the trailing objects.
4110 /// Used to allocate the right amount of storage.
4111 static unsigned sizeOfTrailingObjects(bool HasFPFeatures) {
4112 return HasFPFeatures * sizeof(FPOptionsOverride);
4113 }
4114};
4115
4116/// CompoundAssignOperator - For compound assignments (e.g. +=), we keep
4117/// track of the type the operation is performed in. Due to the semantics of
4118/// these operators, the operands are promoted, the arithmetic performed, an
4119/// implicit conversion back to the result type done, then the assignment takes
4120/// place. This captures the intermediate type which the computation is done
4121/// in.
4123 QualType ComputationLHSType;
4124 QualType ComputationResultType;
4125
4126 /// Construct an empty CompoundAssignOperator.
4128 bool hasFPFeatures)
4129 : BinaryOperator(CompoundAssignOperatorClass, Empty) {}
4130
4131protected:
4133 QualType ResType, ExprValueKind VK, ExprObjectKind OK,
4134 SourceLocation OpLoc, FPOptionsOverride FPFeatures,
4135 QualType CompLHSType, QualType CompResultType)
4136 : BinaryOperator(C, lhs, rhs, opc, ResType, VK, OK, OpLoc, FPFeatures,
4137 true),
4138 ComputationLHSType(CompLHSType), ComputationResultType(CompResultType) {
4139 assert(isCompoundAssignmentOp() &&
4140 "Only should be used for compound assignments");
4141 }
4142
4143public:
4145 bool hasFPFeatures);
4146
4147 static CompoundAssignOperator *
4148 Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
4150 FPOptionsOverride FPFeatures, QualType CompLHSType = QualType(),
4151 QualType CompResultType = QualType());
4152
4153 // The two computation types are the type the LHS is converted
4154 // to for the computation and the type of the result; the two are
4155 // distinct in a few cases (specifically, int+=ptr and ptr-=ptr).
4156 QualType getComputationLHSType() const { return ComputationLHSType; }
4157 void setComputationLHSType(QualType T) { ComputationLHSType = T; }
4158
4159 QualType getComputationResultType() const { return ComputationResultType; }
4160 void setComputationResultType(QualType T) { ComputationResultType = T; }
4161
4162 static bool classof(const Stmt *S) {
4163 return S->getStmtClass() == CompoundAssignOperatorClass;
4164 }
4165};
4166
4168 assert(BinaryOperatorBits.HasFPFeatures);
4169 return isa<CompoundAssignOperator>(this) ? sizeof(CompoundAssignOperator)
4170 : sizeof(BinaryOperator);
4171}
4172
4173/// AbstractConditionalOperator - An abstract base class for
4174/// ConditionalOperator and BinaryConditionalOperator.
4176 SourceLocation QuestionLoc, ColonLoc;
4177 friend class ASTStmtReader;
4178
4179protected:
4182 SourceLocation cloc)
4183 : Expr(SC, T, VK, OK), QuestionLoc(qloc), ColonLoc(cloc) {}
4184
4186 : Expr(SC, Empty) { }
4187
4188public:
4189 /// getCond - Return the expression representing the condition for
4190 /// the ?: operator.
4191 Expr *getCond() const;
4192
4193 /// getTrueExpr - Return the subexpression representing the value of
4194 /// the expression if the condition evaluates to true.
4195 Expr *getTrueExpr() const;
4196
4197 /// getFalseExpr - Return the subexpression representing the value of
4198 /// the expression if the condition evaluates to false. This is
4199 /// the same as getRHS.
4200 Expr *getFalseExpr() const;
4201
4202 SourceLocation getQuestionLoc() const { return QuestionLoc; }
4203 SourceLocation getColonLoc() const { return ColonLoc; }
4204
4205 static bool classof(const Stmt *T) {
4206 return T->getStmtClass() == ConditionalOperatorClass ||
4207 T->getStmtClass() == BinaryConditionalOperatorClass;
4208 }
4209};
4210
4211/// ConditionalOperator - The ?: ternary operator. The GNU "missing
4212/// middle" extension is a BinaryConditionalOperator.
4214 enum { COND, LHS, RHS, END_EXPR };
4215 Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
4216
4217 friend class ASTStmtReader;
4218public:
4220 SourceLocation CLoc, Expr *rhs, QualType t,
4222 : AbstractConditionalOperator(ConditionalOperatorClass, t, VK, OK, QLoc,
4223 CLoc) {
4224 SubExprs[COND] = cond;
4225 SubExprs[LHS] = lhs;
4226 SubExprs[RHS] = rhs;