Lines Matching refs:Expr
1 //===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===//
10 // This file defines the Expr interface and subclasses.
71 Expr *RHS;
92 SubobjectAdjustment(const MemberPointerType *MPT, Expr *RHS)
99 /// Expr - This represents one expression. Note that Expr's are subclasses of
103 class Expr : public Stmt {
107 Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK,
121 explicit Expr(StmtClass SC, EmptyShell) : Stmt(SC) { }
130 // type. Additionally, inspect Expr::isLvalue to determine whether
233 bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc,
332 friend class Expr;
446 return const_cast<Expr*>(this)->getSourceBitField();
516 static bool isPotentialConstantExprUnevaluated(Expr *E,
526 const Expr **Culprit = nullptr) const;
622 ArrayRef<const Expr*> Args) const;
679 static QualType findBoundMemberType(const Expr *expr);
683 Expr *IgnoreImpCasts() LLVM_READONLY;
687 Expr *IgnoreImplicit() LLVM_READONLY {
688 return cast<Expr>(Stmt::IgnoreImplicit());
691 const Expr *IgnoreImplicit() const LLVM_READONLY {
692 return const_cast<Expr*>(this)->IgnoreImplicit();
695 /// IgnoreParens - Ignore parentheses. If this Expr is a ParenExpr, return
698 /// Otherwise, the method returns the current Expr.
699 Expr *IgnoreParens() LLVM_READONLY;
703 Expr *IgnoreParenCasts() LLVM_READONLY;
706 Expr *IgnoreCasts() LLVM_READONLY;
710 Expr *IgnoreParenImpCasts() LLVM_READONLY;
712 /// IgnoreConversionOperator - Ignore conversion operator. If this Expr is a
714 Expr *IgnoreConversionOperator() LLVM_READONLY;
716 const Expr *IgnoreConversionOperator() const LLVM_READONLY {
717 return const_cast<Expr*>(this)->IgnoreConversionOperator();
720 const Expr *IgnoreParenImpCasts() const LLVM_READONLY {
721 return const_cast<Expr*>(this)->IgnoreParenImpCasts();
726 Expr *IgnoreParenLValueCasts() LLVM_READONLY;
728 const Expr *IgnoreParenLValueCasts() const LLVM_READONLY {
729 return const_cast<Expr*>(this)->IgnoreParenLValueCasts();
735 Expr *IgnoreParenNoopCasts(ASTContext &Ctx) LLVM_READONLY;
738 Expr *ignoreParenBaseCasts() LLVM_READONLY;
740 const Expr *ignoreParenBaseCasts() const LLVM_READONLY {
741 return const_cast<Expr*>(this)->ignoreParenBaseCasts();
760 const Expr *IgnoreImpCasts() const LLVM_READONLY {
761 return const_cast<Expr*>(this)->IgnoreImpCasts();
763 const Expr *IgnoreParens() const LLVM_READONLY {
764 return const_cast<Expr*>(this)->IgnoreParens();
766 const Expr *IgnoreParenCasts() const LLVM_READONLY {
767 return const_cast<Expr*>(this)->IgnoreParenCasts();
770 const Expr *IgnoreCasts() const LLVM_READONLY {
771 return const_cast<Expr*>(this)->IgnoreCasts();
774 const Expr *IgnoreParenNoopCasts(ASTContext &Ctx) const LLVM_READONLY {
775 return const_cast<Expr*>(this)->IgnoreParenNoopCasts(Ctx);
778 static bool hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs);
792 const Expr *skipRValueSubobjectAdjustments(
793 SmallVectorImpl<const Expr *> &CommaLHS,
812 class OpaqueValueExpr : public Expr {
814 Expr *SourceExpr;
820 Expr *SourceExpr = nullptr)
821 : Expr(OpaqueValueExprClass, T, VK, OK,
833 static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr);
836 : Expr(OpaqueValueExprClass, Empty) { }
862 Expr *getSourceExpr() const { return SourceExpr; }
892 class DeclRefExpr : public Expr {
944 : Expr(DeclRefExprClass, Empty) { }
954 : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
1165 class PredefinedExpr : public Expr {
1184 : Expr(PredefinedExprClass, type, VK_LValue, OK_Ordinary,
1192 : Expr(PredefinedExprClass, Empty) { }
1264 class IntegerLiteral : public Expr, public APIntStorage {
1269 : Expr(IntegerLiteralClass, Empty) { }
1302 class CharacterLiteral : public Expr {
1318 : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary, false, false,
1325 CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { }
1349 class FloatingLiteral : public Expr, private APFloatStorage {
1416 class ImaginaryLiteral : public Expr {
1419 ImaginaryLiteral(Expr *val, QualType Ty)
1420 : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary, false, false,
1426 : Expr(ImaginaryLiteralClass, Empty) { }
1428 const Expr *getSubExpr() const { return cast<Expr>(Val); }
1429 Expr *getSubExpr() { return cast<Expr>(Val); }
1430 void setSubExpr(Expr *E) { Val = E; }
1459 class StringLiteral : public Expr {
1485 Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary, false, false, false,
1608 class ParenExpr : public Expr {
1612 ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
1613 : Expr(ParenExprClass, val->getType(),
1622 : Expr(ParenExprClass, Empty) { }
1624 const Expr *getSubExpr() const { return cast<Expr>(Val); }
1625 Expr *getSubExpr() { return cast<Expr>(Val); }
1626 void setSubExpr(Expr *E) { Val = E; }
1658 class UnaryOperator : public Expr {
1668 UnaryOperator(Expr *input, Opcode opc, QualType type,
1670 : Expr(UnaryOperatorClass, type, VK, OK,
1680 : Expr(UnaryOperatorClass, Empty), Opc(UO_AddrOf) { }
1685 Expr *getSubExpr() const { return cast<Expr>(Val); }
1686 void setSubExpr(Expr *E) { Val = E; }
1771 class OffsetOfExpr : public Expr {
1797 /// - An unsigned index into the array of Expr*'s stored after this node
1879 ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs,
1883 : Expr(OffsetOfExprClass, EmptyShell()),
1891 ArrayRef<Expr*> exprs, SourceLocation RParenLoc);
1925 Expr* getIndexExpr(unsigned Idx) {
1927 return reinterpret_cast<Expr **>(
1930 const Expr *getIndexExpr(unsigned Idx) const {
1934 void setIndexExpr(unsigned Idx, Expr* E) {
1936 reinterpret_cast<Expr **>(
1963 class UnaryExprOrTypeTraitExpr : public Expr {
1974 Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary,
1986 UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, Expr *E,
1989 Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary,
2003 : Expr(UnaryExprOrTypeTraitExprClass, Empty) { }
2018 Expr *getArgumentExpr() {
2020 return static_cast<Expr*>(Argument.Ex);
2022 const Expr *getArgumentExpr() const {
2026 void setArgument(Expr *E) {
2063 class ArraySubscriptExpr : public Expr {
2068 ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t,
2071 : Expr(ArraySubscriptExprClass, t, VK, OK,
2085 : Expr(ArraySubscriptExprClass, Shell) { }
2096 Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
2097 const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
2098 void setLHS(Expr *E) { SubExprs[LHS] = E; }
2100 Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
2101 const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
2102 void setRHS(Expr *E) { SubExprs[RHS] = E; }
2104 Expr *getBase() {
2105 return cast<Expr>(getRHS()->getType()->isIntegerType() ? getLHS():getRHS());
2108 const Expr *getBase() const {
2109 return cast<Expr>(getRHS()->getType()->isIntegerType() ? getLHS():getRHS());
2112 Expr *getIdx() {
2113 return cast<Expr>(getRHS()->getType()->isIntegerType() ? getRHS():getLHS());
2116 const Expr *getIdx() const {
2117 return cast<Expr>(getRHS()->getType()->isIntegerType() ? getRHS():getLHS());
2149 class CallExpr : public Expr {
2157 CallExpr(const ASTContext& C, StmtClass SC, Expr *fn, unsigned NumPreArgs,
2158 ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
2179 CallExpr(const ASTContext& C, Expr *fn, ArrayRef<Expr*> args, QualType t,
2185 const Expr *getCallee() const { return cast<Expr>(SubExprs[FN]); }
2186 Expr *getCallee() { return cast<Expr>(SubExprs[FN]); }
2187 void setCallee(Expr *F) { SubExprs[FN] = F; }
2205 Expr **getArgs() {
2206 return reinterpret_cast<Expr **>(SubExprs+getNumPreArgs()+PREARGS_START);
2208 const Expr *const *getArgs() const {
2213 Expr *getArg(unsigned Arg) {
2215 return cast<Expr>(SubExprs[Arg+getNumPreArgs()+PREARGS_START]);
2217 const Expr *getArg(unsigned Arg) const {
2219 return cast<Expr>(SubExprs[Arg+getNumPreArgs()+PREARGS_START]);
2223 void setArg(unsigned Arg, Expr *ArgExpr) {
2300 class MemberExpr : public Expr {
2361 MemberExpr(Expr *base, bool isarrow, ValueDecl *memberdecl,
2364 : Expr(MemberExprClass, ty, VK, OK,
2380 MemberExpr(Expr *base, bool isarrow, ValueDecl *memberdecl,
2383 : Expr(MemberExprClass, ty, VK, OK,
2392 static MemberExpr *Create(const ASTContext &C, Expr *base, bool isarrow,
2400 void setBase(Expr *E) { Base = E; }
2401 Expr *getBase() const { return cast<Expr>(Base); }
2585 class CompoundLiteralExpr : public Expr {
2598 QualType T, ExprValueKind VK, Expr *init, bool fileScope)
2599 : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary,
2609 : Expr(CompoundLiteralExprClass, Empty) { }
2611 const Expr *getInitializer() const { return cast<Expr>(Init); }
2612 Expr *getInitializer() { return cast<Expr>(Init); }
2613 void setInitializer(Expr *E) { Init = E; }
2655 class CastExpr : public Expr {
2677 const CastKind kind, Expr *op, unsigned BasePathSize) :
2678 Expr(SC, ty, VK, OK_Ordinary,
2698 : Expr(SC, Empty) {
2707 Expr *getSubExpr() { return cast<Expr>(Op); }
2708 const Expr *getSubExpr() const { return cast<Expr>(Op); }
2709 void setSubExpr(Expr *E) { Op = E; }
2714 Expr *getSubExprAsWritten();
2715 const Expr *getSubExprAsWritten() const {
2761 ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
2772 ImplicitCastExpr(OnStack_t _, QualType ty, CastKind kind, Expr *op,
2778 CastKind Kind, Expr *Operand,
2797 inline Expr *Expr::IgnoreImpCasts() {
2798 Expr *e = this;
2827 CastKind kind, Expr *op, unsigned PathSize,
2858 CStyleCastExpr(QualType exprTy, ExprValueKind vk, CastKind kind, Expr *op,
2871 Expr *Op, const CXXCastPath *BasePath,
2912 class BinaryOperator : public Expr {
2930 BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
2933 : Expr(BinaryOperatorClass, ResTy, VK, OK,
2949 : Expr(BinaryOperatorClass, Empty), Opc(BO_Comma) { }
2958 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
2959 void setLHS(Expr *E) { SubExprs[LHS] = E; }
2960 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
2961 void setRHS(Expr *E) { SubExprs[RHS] = E; }
3079 BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
3082 : Expr(CompoundAssignOperatorClass, ResTy, VK, OK,
3095 : Expr(SC, Empty), Opc(BO_MulAssign) { }
3108 CompoundAssignOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResType,
3140 class AbstractConditionalOperator : public Expr {
3151 : Expr(SC, T, VK, OK, TD, VD, ID, ContainsUnexpandedParameterPack),
3155 : Expr(SC, Empty) { }
3160 Expr *getCond() const;
3164 Expr *getTrueExpr() const;
3169 Expr *getFalseExpr() const;
3188 ConditionalOperator(Expr *cond, SourceLocation QLoc, Expr *lhs,
3189 SourceLocation CLoc, Expr *rhs,
3216 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3220 Expr *getTrueExpr() const { return cast<Expr>(SubExprs[LHS]); }
3225 Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }
3227 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3228 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3265 BinaryConditionalOperator(Expr *common, OpaqueValueExpr *opaqueValue,
3266 Expr *cond, Expr *lhs, Expr *rhs,
3292 Expr *getCommon() const { return cast<Expr>(SubExprs[COMMON]); }
3299 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3304 Expr *getTrueExpr() const {
3305 return cast<Expr>(SubExprs[LHS]);
3311 Expr *getFalseExpr() const {
3312 return cast<Expr>(SubExprs[RHS]);
3332 inline Expr *AbstractConditionalOperator::getCond() const {
3338 inline Expr *AbstractConditionalOperator::getTrueExpr() const {
3344 inline Expr *AbstractConditionalOperator::getFalseExpr() const {
3351 class AddrLabelExpr : public Expr {
3357 : Expr(AddrLabelExprClass, t, VK_RValue, OK_Ordinary, false, false, false,
3363 : Expr(AddrLabelExprClass, Empty) { }
3390 class StmtExpr : public Expr {
3399 Expr(StmtExprClass, T, VK_RValue, OK_Ordinary,
3404 explicit StmtExpr(EmptyShell Empty) : Expr(StmtExprClass, Empty) { }
3433 class ShuffleVectorExpr : public Expr {
3444 ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, QualType Type,
3449 : Expr(ShuffleVectorExprClass, Empty), SubExprs(nullptr) { }
3470 Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
3472 /// getExpr - Return the Expr at the specified index.
3473 Expr *getExpr(unsigned Index) {
3475 return cast<Expr>(SubExprs[Index]);
3477 const Expr *getExpr(unsigned Index) const {
3479 return cast<Expr>(SubExprs[Index]);
3482 void setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs);
3498 class ConvertVectorExpr : public Expr {
3506 explicit ConvertVectorExpr(EmptyShell Empty) : Expr(ConvertVectorExprClass, Empty) {}
3509 ConvertVectorExpr(Expr* SrcExpr, TypeSourceInfo *TI, QualType DstType,
3512 : Expr(ConvertVectorExprClass, DstType, VK, OK,
3521 /// getSrcExpr - Return the Expr to be converted.
3522 Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }
3558 class ChooseExpr : public Expr {
3564 ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs,
3568 : Expr(ChooseExprClass, t, VK, OK, TypeDependent, ValueDependent,
3582 explicit ChooseExpr(EmptyShell Empty) : Expr(ChooseExprClass, Empty) { }
3599 Expr *getChosenSubExpr() const {
3603 Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
3604 void setCond(Expr *E) { SubExprs[COND] = E; }
3605 Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
3606 void setLHS(Expr *E) { SubExprs[LHS] = E; }
3607 Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
3608 void setRHS(Expr *E) { SubExprs[RHS] = E; }
3635 class GNUNullExpr : public Expr {
3641 : Expr(GNUNullExprClass, Ty, VK_RValue, OK_Ordinary, false, false, false,
3646 explicit GNUNullExpr(EmptyShell Empty) : Expr(GNUNullExprClass, Empty) { }
3664 class VAArgExpr : public Expr {
3669 VAArgExpr(SourceLocation BLoc, Expr* e, TypeSourceInfo *TInfo,
3671 : Expr(VAArgExprClass, t, VK_RValue, OK_Ordinary,
3682 explicit VAArgExpr(EmptyShell Empty) : Expr(VAArgExprClass, Empty) { }
3684 const Expr *getSubExpr() const { return cast<Expr>(Val); }
3685 Expr *getSubExpr() { return cast<Expr>(Val); }
3686 void setSubExpr(Expr *E) { Val = E; }
3753 class InitListExpr : public Expr {
3773 llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;
3777 ArrayRef<Expr*> initExprs, SourceLocation rbraceloc);
3781 : Expr(InitListExprClass, Empty) { }
3786 Expr **getInits() { return reinterpret_cast<Expr **>(InitExprs.data()); }
3788 const Expr *getInit(unsigned Init) const {
3790 return cast_or_null<Expr>(InitExprs[Init]);
3793 Expr *getInit(unsigned Init) {
3795 return cast_or_null<Expr>(InitExprs[Init]);
3798 void setInit(unsigned Init, Expr *expr) {
3829 Expr *updateInit(const ASTContext &C, unsigned Init, Expr *expr);
3834 Expr *getArrayFiller() {
3835 return ArrayFillerOrUnionFieldInit.dyn_cast<Expr *>();
3837 const Expr *getArrayFiller() const {
3840 void setArrayFiller(Expr *filler);
3955 class DesignatedInitExpr : public Expr {
3985 ArrayRef<Expr*> IndexExprs, Expr *Init);
3988 : Expr(DesignatedInitExprClass, EmptyShell()),
4147 ArrayRef<Expr*> IndexExprs,
4149 bool GNUSyntax, Expr *Init);
4193 Expr *getArrayIndex(const Designator &D) const;
4194 Expr *getArrayRangeStart(const Designator &D) const;
4195 Expr *getArrayRangeEnd(const Designator &D) const;
4208 Expr *getInit() const {
4209 return cast<Expr>(*const_cast<DesignatedInitExpr*>(this)->child_begin());
4212 void setInit(Expr *init) {
4222 Expr *getSubExpr(unsigned Idx) const {
4224 return cast<Expr>(reinterpret_cast<Stmt *const *>(this + 1)[Idx]);
4227 void setSubExpr(unsigned Idx, Expr *E) {
4261 class ImplicitValueInitExpr : public Expr {
4264 : Expr(ImplicitValueInitExprClass, ty, VK_RValue, OK_Ordinary,
4269 : Expr(ImplicitValueInitExprClass, Empty) { }
4283 class ParenListExpr : public Expr {
4290 ArrayRef<Expr*> exprs, SourceLocation rparenloc);
4293 explicit ParenListExpr(EmptyShell Empty) : Expr(ParenListExprClass, Empty) { }
4297 const Expr* getExpr(unsigned Init) const {
4299 return cast_or_null<Expr>(Exprs[Init]);
4302 Expr* getExpr(unsigned Init) {
4304 return cast_or_null<Expr>(Exprs[Init]);
4307 Expr **getExprs() { return reinterpret_cast<Expr **>(Exprs); }
4355 class GenericSelectionExpr : public Expr {
4364 SourceLocation GenericLoc, Expr *ControllingExpr,
4366 ArrayRef<Expr*> AssocExprs,
4373 SourceLocation GenericLoc, Expr *ControllingExpr,
4375 ArrayRef<Expr*> AssocExprs,
4380 : Expr(GenericSelectionExprClass, Empty) { }
4388 const Expr *getAssocExpr(unsigned i) const {
4389 return cast<Expr>(SubExprs[END_EXPR+i]);
4391 Expr *getAssocExpr(unsigned i) { return cast<Expr>(SubExprs[END_EXPR+i]); }
4405 const Expr *getControllingExpr() const {
4406 return cast<Expr>(SubExprs[CONTROLLING]);
4408 Expr *getControllingExpr() { return cast<Expr>(SubExprs[CONTROLLING]); }
4423 const Expr *getResultExpr() const { return getAssocExpr(getResultIndex()); }
4424 Expr *getResultExpr() { return getAssocExpr(getResultIndex()); }
4452 class ExtVectorElementExpr : public Expr {
4457 ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base,
4459 : Expr(ExtVectorElementExprClass, ty, VK,
4468 : Expr(ExtVectorElementExprClass, Empty) { }
4470 const Expr *getBase() const { return cast<Expr>(Base); }
4471 Expr *getBase() { return cast<Expr>(Base); }
4472 void setBase(Expr *E) { Base = E; }
4511 class BlockExpr : public Expr {
4516 : Expr(BlockExprClass, ty, VK_RValue, OK_Ordinary,
4523 explicit BlockExpr(EmptyShell Empty) : Expr(BlockExprClass, Empty) { }
4551 class AsTypeExpr : public Expr {
4558 explicit AsTypeExpr(EmptyShell Empty) : Expr(AsTypeExprClass, Empty) {}
4561 AsTypeExpr(Expr* SrcExpr, QualType DstType,
4564 : Expr(AsTypeExprClass, DstType, VK, OK,
4573 /// getSrcExpr - Return the Expr to be converted.
4574 Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }
4621 class PseudoObjectExpr : public Expr {
4633 Expr **getSubExprsBuffer() { return reinterpret_cast<Expr**>(this + 1); }
4634 const Expr * const *getSubExprsBuffer() const {
4635 return reinterpret_cast<const Expr * const *>(this + 1);
4641 Expr *syntactic, ArrayRef<Expr*> semantic,
4655 static PseudoObjectExpr *Create(const ASTContext &Context, Expr *syntactic,
4656 ArrayRef<Expr*> semantic,
4665 Expr *getSyntacticForm() { return getSubExprsBuffer()[0]; }
4666 const Expr *getSyntacticForm() const { return getSubExprsBuffer()[0]; }
4676 Expr *getResultExpr() {
4681 const Expr *getResultExpr() const {
4687 typedef Expr * const *semantics_iterator;
4688 typedef const Expr * const *const_semantics_iterator;
4701 Expr *getSemanticExpr(unsigned index) {
4705 const Expr *getSemanticExpr(unsigned index) const {
4735 class AtomicExpr : public Expr {
4765 AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, QualType t,
4773 explicit AtomicExpr(EmptyShell Empty) : Expr(AtomicExprClass, Empty) { }
4775 Expr *getPtr() const {
4776 return cast<Expr>(SubExprs[PTR]);
4778 Expr *getOrder() const {
4779 return cast<Expr>(SubExprs[ORDER]);
4781 Expr *getVal1() const {
4783 return cast<Expr>(SubExprs[ORDER]);
4785 return cast<Expr>(SubExprs[VAL1]);
4787 Expr *getOrderFail() const {
4789 return cast<Expr>(SubExprs[ORDER_FAIL]);
4791 Expr *getVal2() const {
4793 return cast<Expr>(SubExprs[ORDER_FAIL]);
4795 return cast<Expr>(SubExprs[VAL2]);
4797 Expr *getWeak() const {
4799 return cast<Expr>(SubExprs[WEAK]);
4805 Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }