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 | |

16 | #include "clang/AST/APValue.h" |

17 | #include "clang/AST/ASTVector.h" |

18 | #include "clang/AST/Decl.h" |

19 | #include "clang/AST/DeclAccessPair.h" |

20 | #include "clang/AST/OperationKinds.h" |

21 | #include "clang/AST/Stmt.h" |

22 | #include "clang/AST/TemplateBase.h" |

23 | #include "clang/AST/Type.h" |

24 | #include "clang/Basic/CharInfo.h" |

25 | #include "clang/Basic/FixedPoint.h" |

26 | #include "clang/Basic/LangOptions.h" |

27 | #include "clang/Basic/SyncScope.h" |

28 | #include "clang/Basic/TypeTraits.h" |

29 | #include "llvm/ADT/APFloat.h" |

30 | #include "llvm/ADT/APSInt.h" |

31 | #include "llvm/ADT/iterator.h" |

32 | #include "llvm/ADT/iterator_range.h" |

33 | #include "llvm/ADT/SmallVector.h" |

34 | #include "llvm/ADT/StringRef.h" |

35 | #include "llvm/Support/AtomicOrdering.h" |

36 | #include "llvm/Support/Compiler.h" |

37 | #include "llvm/Support/TrailingObjects.h" |

38 | |

39 | namespace clang { |

40 | class APValue; |

41 | class ASTContext; |

42 | class BlockDecl; |

43 | class CXXBaseSpecifier; |

44 | class CXXMemberCallExpr; |

45 | class CXXOperatorCallExpr; |

46 | class CastExpr; |

47 | class Decl; |

48 | class IdentifierInfo; |

49 | class MaterializeTemporaryExpr; |

50 | class NamedDecl; |

51 | class ObjCPropertyRefExpr; |

52 | class OpaqueValueExpr; |

53 | class ParmVarDecl; |

54 | class StringLiteral; |

55 | class TargetInfo; |

56 | class ValueDecl; |

57 | |

58 | /// A simple array of base specifiers. |

59 | typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath; |

60 | |

61 | /// An adjustment to be made to the temporary created when emitting a |

62 | /// reference binding, which accesses a particular subobject of that temporary. |

63 | struct SubobjectAdjustment { |

64 | enum { |

65 | DerivedToBaseAdjustment, |

66 | FieldAdjustment, |

67 | MemberPointerAdjustment |

68 | } Kind; |

69 | |

70 | struct DTB { |

71 | const CastExpr *BasePath; |

72 | const CXXRecordDecl *DerivedClass; |

73 | }; |

74 | |

75 | struct P { |

76 | const MemberPointerType *MPT; |

77 | Expr *RHS; |

78 | }; |

79 | |

80 | union { |

81 | struct DTB DerivedToBase; |

82 | FieldDecl *Field; |

83 | struct P Ptr; |

84 | }; |

85 | |

86 | SubobjectAdjustment(const CastExpr *BasePath, |

87 | const CXXRecordDecl *DerivedClass) |

88 | : Kind(DerivedToBaseAdjustment) { |

89 | DerivedToBase.BasePath = BasePath; |

90 | DerivedToBase.DerivedClass = DerivedClass; |

91 | } |

92 | |

93 | SubobjectAdjustment(FieldDecl *Field) |

94 | : Kind(FieldAdjustment) { |

95 | this->Field = Field; |

96 | } |

97 | |

98 | SubobjectAdjustment(const MemberPointerType *MPT, Expr *RHS) |

99 | : Kind(MemberPointerAdjustment) { |

100 | this->Ptr.MPT = MPT; |

101 | this->Ptr.RHS = RHS; |

102 | } |

103 | }; |

104 | |

105 | /// This represents one expression. Note that Expr's are subclasses of Stmt. |

106 | /// This allows an expression to be transparently used any place a Stmt is |

107 | /// required. |

108 | class Expr : public Stmt { |

109 | QualType TR; |

110 | |

111 | protected: |

112 | Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK, |

113 | bool TD, bool VD, bool ID, bool ContainsUnexpandedParameterPack) |

114 | : Stmt(SC) |

115 | { |

116 | ExprBits.TypeDependent = TD; |

117 | ExprBits.ValueDependent = VD; |

118 | ExprBits.InstantiationDependent = ID; |

119 | ExprBits.ValueKind = VK; |

120 | ExprBits.ObjectKind = OK; |

121 | assert(ExprBits.ObjectKind == OK && "truncated kind"); |

122 | ExprBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; |

123 | setType(T); |

124 | } |

125 | |

126 | /// Construct an empty expression. |

127 | explicit Expr(StmtClass SC, EmptyShell) : Stmt(SC) { } |

128 | |

129 | public: |

130 | QualType getType() const { return TR; } |

131 | void setType(QualType t) { |

132 | // In C++, the type of an expression is always adjusted so that it |

133 | // will not have reference type (C++ [expr]p6). Use |

134 | // QualType::getNonReferenceType() to retrieve the non-reference |

135 | // type. Additionally, inspect Expr::isLvalue to determine whether |

136 | // an expression that is adjusted in this manner should be |

137 | // considered an lvalue. |

138 | assert((t.isNull() || !t->isReferenceType()) && |

139 | "Expressions can't have reference type"); |

140 | |

141 | TR = t; |

142 | } |

143 | |

144 | /// isValueDependent - Determines whether this expression is |

145 | /// value-dependent (C++ [temp.dep.constexpr]). For example, the |

146 | /// array bound of "Chars" in the following example is |

147 | /// value-dependent. |

148 | /// @code |

149 | /// template<int Size, char (&Chars)[Size]> struct meta_string; |

150 | /// @endcode |

151 | bool isValueDependent() const { return ExprBits.ValueDependent; } |

152 | |

153 | /// Set whether this expression is value-dependent or not. |

154 | void setValueDependent(bool VD) { |

155 | ExprBits.ValueDependent = VD; |

156 | } |

157 | |

158 | /// isTypeDependent - Determines whether this expression is |

159 | /// type-dependent (C++ [temp.dep.expr]), which means that its type |

160 | /// could change from one template instantiation to the next. For |

161 | /// example, the expressions "x" and "x + y" are type-dependent in |

162 | /// the following code, but "y" is not type-dependent: |

163 | /// @code |

164 | /// template<typename T> |

165 | /// void add(T x, int y) { |

166 | /// x + y; |

167 | /// } |

168 | /// @endcode |

169 | bool isTypeDependent() const { return ExprBits.TypeDependent; } |

170 | |

171 | /// Set whether this expression is type-dependent or not. |

172 | void setTypeDependent(bool TD) { |

173 | ExprBits.TypeDependent = TD; |

174 | } |

175 | |

176 | /// Whether this expression is instantiation-dependent, meaning that |

177 | /// it depends in some way on a template parameter, even if neither its type |

178 | /// nor (constant) value can change due to the template instantiation. |

179 | /// |

180 | /// In the following example, the expression \c sizeof(sizeof(T() + T())) is |

181 | /// instantiation-dependent (since it involves a template parameter \c T), but |

182 | /// is neither type- nor value-dependent, since the type of the inner |

183 | /// \c sizeof is known (\c std::size_t) and therefore the size of the outer |

184 | /// \c sizeof is known. |

185 | /// |

186 | /// \code |

187 | /// template<typename T> |

188 | /// void f(T x, T y) { |

189 | /// sizeof(sizeof(T() + T()); |

190 | /// } |

191 | /// \endcode |

192 | /// |

193 | bool isInstantiationDependent() const { |

194 | return ExprBits.InstantiationDependent; |

195 | } |

196 | |

197 | /// Set whether this expression is instantiation-dependent or not. |

198 | void setInstantiationDependent(bool ID) { |

199 | ExprBits.InstantiationDependent = ID; |

200 | } |

201 | |

202 | /// Whether this expression contains an unexpanded parameter |

203 | /// pack (for C++11 variadic templates). |

204 | /// |

205 | /// Given the following function template: |

206 | /// |

207 | /// \code |

208 | /// template<typename F, typename ...Types> |

209 | /// void forward(const F &f, Types &&...args) { |

210 | /// f(static_cast<Types&&>(args)...); |

211 | /// } |

212 | /// \endcode |

213 | /// |

214 | /// The expressions \c args and \c static_cast<Types&&>(args) both |

215 | /// contain parameter packs. |

216 | bool containsUnexpandedParameterPack() const { |

217 | return ExprBits.ContainsUnexpandedParameterPack; |

218 | } |

219 | |

220 | /// Set the bit that describes whether this expression |

221 | /// contains an unexpanded parameter pack. |

222 | void setContainsUnexpandedParameterPack(bool PP = true) { |

223 | ExprBits.ContainsUnexpandedParameterPack = PP; |

224 | } |

225 | |

226 | /// getExprLoc - Return the preferred location for the arrow when diagnosing |

227 | /// a problem with a generic expression. |

228 | SourceLocation getExprLoc() const LLVM_READONLY; |

229 | |

230 | /// isUnusedResultAWarning - Return true if this immediate expression should |

231 | /// be warned about if the result is unused. If so, fill in expr, location, |

232 | /// and ranges with expr to warn on and source locations/ranges appropriate |

233 | /// for a warning. |

234 | bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc, |

235 | SourceRange &R1, SourceRange &R2, |

236 | ASTContext &Ctx) const; |

237 | |

238 | /// isLValue - True if this expression is an "l-value" according to |

239 | /// the rules of the current language. C and C++ give somewhat |

240 | /// different rules for this concept, but in general, the result of |

241 | /// an l-value expression identifies a specific object whereas the |

242 | /// result of an r-value expression is a value detached from any |

243 | /// specific storage. |

244 | /// |

245 | /// C++11 divides the concept of "r-value" into pure r-values |

246 | /// ("pr-values") and so-called expiring values ("x-values"), which |

247 | /// identify specific objects that can be safely cannibalized for |

248 | /// their resources. This is an unfortunate abuse of terminology on |

249 | /// the part of the C++ committee. In Clang, when we say "r-value", |

250 | /// we generally mean a pr-value. |

251 | bool isLValue() const { return getValueKind() == VK_LValue; } |

252 | bool isRValue() const { return getValueKind() == VK_RValue; } |

253 | bool isXValue() const { return getValueKind() == VK_XValue; } |

254 | bool isGLValue() const { return getValueKind() != VK_RValue; } |

255 | |

256 | enum LValueClassification { |

257 | LV_Valid, |

258 | LV_NotObjectType, |

259 | LV_IncompleteVoidType, |

260 | LV_DuplicateVectorComponents, |

261 | LV_InvalidExpression, |

262 | LV_InvalidMessageExpression, |

263 | LV_MemberFunction, |

264 | LV_SubObjCPropertySetting, |

265 | LV_ClassTemporary, |

266 | LV_ArrayTemporary |

267 | }; |

268 | /// Reasons why an expression might not be an l-value. |

269 | LValueClassification ClassifyLValue(ASTContext &Ctx) const; |

270 | |

271 | enum isModifiableLvalueResult { |

272 | MLV_Valid, |

273 | MLV_NotObjectType, |

274 | MLV_IncompleteVoidType, |

275 | MLV_DuplicateVectorComponents, |

276 | MLV_InvalidExpression, |

277 | MLV_LValueCast, // Specialized form of MLV_InvalidExpression. |

278 | MLV_IncompleteType, |

279 | MLV_ConstQualified, |

280 | MLV_ConstQualifiedField, |

281 | MLV_ConstAddrSpace, |

282 | MLV_ArrayType, |

283 | MLV_NoSetterProperty, |

284 | MLV_MemberFunction, |

285 | MLV_SubObjCPropertySetting, |

286 | MLV_InvalidMessageExpression, |

287 | MLV_ClassTemporary, |

288 | MLV_ArrayTemporary |

289 | }; |

290 | /// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, |

291 | /// does not have an incomplete type, does not have a const-qualified type, |

292 | /// and if it is a structure or union, does not have any member (including, |

293 | /// recursively, any member or element of all contained aggregates or unions) |

294 | /// with a const-qualified type. |

295 | /// |

296 | /// \param Loc [in,out] - A source location which *may* be filled |

297 | /// in with the location of the expression making this a |

298 | /// non-modifiable lvalue, if specified. |

299 | isModifiableLvalueResult |

300 | isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc = nullptr) const; |

301 | |

302 | /// The return type of classify(). Represents the C++11 expression |

303 | /// taxonomy. |

304 | class Classification { |

305 | public: |

306 | /// The various classification results. Most of these mean prvalue. |

307 | enum Kinds { |

308 | CL_LValue, |

309 | CL_XValue, |

310 | CL_Function, // Functions cannot be lvalues in C. |

311 | CL_Void, // Void cannot be an lvalue in C. |

312 | CL_AddressableVoid, // Void expression whose address can be taken in C. |

313 | CL_DuplicateVectorComponents, // A vector shuffle with dupes. |

314 | CL_MemberFunction, // An expression referring to a member function |

315 | CL_SubObjCPropertySetting, |

316 | CL_ClassTemporary, // A temporary of class type, or subobject thereof. |

317 | CL_ArrayTemporary, // A temporary of array type. |

318 | CL_ObjCMessageRValue, // ObjC message is an rvalue |

319 | CL_PRValue // A prvalue for any other reason, of any other type |

320 | }; |

321 | /// The results of modification testing. |

322 | enum ModifiableType { |

323 | CM_Untested, // testModifiable was false. |

324 | CM_Modifiable, |

325 | CM_RValue, // Not modifiable because it's an rvalue |

326 | CM_Function, // Not modifiable because it's a function; C++ only |

327 | CM_LValueCast, // Same as CM_RValue, but indicates GCC cast-as-lvalue ext |

328 | CM_NoSetterProperty,// Implicit assignment to ObjC property without setter |

329 | CM_ConstQualified, |

330 | CM_ConstQualifiedField, |

331 | CM_ConstAddrSpace, |

332 | CM_ArrayType, |

333 | CM_IncompleteType |

334 | }; |

335 | |

336 | private: |

337 | friend class Expr; |

338 | |

339 | unsigned short Kind; |

340 | unsigned short Modifiable; |

341 | |

342 | explicit Classification(Kinds k, ModifiableType m) |

343 | : Kind(k), Modifiable(m) |

344 | {} |

345 | |

346 | public: |

347 | Classification() {} |

348 | |

349 | Kinds getKind() const { return static_cast<Kinds>(Kind); } |

350 | ModifiableType getModifiable() const { |

351 | assert(Modifiable != CM_Untested && "Did not test for modifiability."); |

352 | return static_cast<ModifiableType>(Modifiable); |

353 | } |

354 | bool isLValue() const { return Kind == CL_LValue; } |

355 | bool isXValue() const { return Kind == CL_XValue; } |

356 | bool isGLValue() const { return Kind <= CL_XValue; } |

357 | bool isPRValue() const { return Kind >= CL_Function; } |

358 | bool isRValue() const { return Kind >= CL_XValue; } |

359 | bool isModifiable() const { return getModifiable() == CM_Modifiable; } |

360 | |

361 | /// Create a simple, modifiably lvalue |

362 | static Classification makeSimpleLValue() { |

363 | return Classification(CL_LValue, CM_Modifiable); |

364 | } |

365 | |

366 | }; |

367 | /// Classify - Classify this expression according to the C++11 |

368 | /// expression taxonomy. |

369 | /// |

370 | /// C++11 defines ([basic.lval]) a new taxonomy of expressions to replace the |

371 | /// old lvalue vs rvalue. This function determines the type of expression this |

372 | /// is. There are three expression types: |

373 | /// - lvalues are classical lvalues as in C++03. |

374 | /// - prvalues are equivalent to rvalues in C++03. |

375 | /// - xvalues are expressions yielding unnamed rvalue references, e.g. a |

376 | /// function returning an rvalue reference. |

377 | /// lvalues and xvalues are collectively referred to as glvalues, while |

378 | /// prvalues and xvalues together form rvalues. |

379 | Classification Classify(ASTContext &Ctx) const { |

380 | return ClassifyImpl(Ctx, nullptr); |

381 | } |

382 | |

383 | /// ClassifyModifiable - Classify this expression according to the |

384 | /// C++11 expression taxonomy, and see if it is valid on the left side |

385 | /// of an assignment. |

386 | /// |

387 | /// This function extends classify in that it also tests whether the |

388 | /// expression is modifiable (C99 6.3.2.1p1). |

389 | /// \param Loc A source location that might be filled with a relevant location |

390 | /// if the expression is not modifiable. |

391 | Classification ClassifyModifiable(ASTContext &Ctx, SourceLocation &Loc) const{ |

392 | return ClassifyImpl(Ctx, &Loc); |

393 | } |

394 | |

395 | /// getValueKindForType - Given a formal return or parameter type, |

396 | /// give its value kind. |

397 | static ExprValueKind getValueKindForType(QualType T) { |

398 | if (const ReferenceType *RT = T->getAs<ReferenceType>()) |

399 | return (isa<LValueReferenceType>(RT) |

400 | ? VK_LValue |

401 | : (RT->getPointeeType()->isFunctionType() |

402 | ? VK_LValue : VK_XValue)); |

403 | return VK_RValue; |

404 | } |

405 | |

406 | /// getValueKind - The value kind that this expression produces. |

407 | ExprValueKind getValueKind() const { |

408 | return static_cast<ExprValueKind>(ExprBits.ValueKind); |

409 | } |

410 | |

411 | /// getObjectKind - The object kind that this expression produces. |

412 | /// Object kinds are meaningful only for expressions that yield an |

413 | /// l-value or x-value. |

414 | ExprObjectKind getObjectKind() const { |

415 | return static_cast<ExprObjectKind>(ExprBits.ObjectKind); |

416 | } |

417 | |

418 | bool isOrdinaryOrBitFieldObject() const { |

419 | ExprObjectKind OK = getObjectKind(); |

420 | return (OK == OK_Ordinary || OK == OK_BitField); |

421 | } |

422 | |

423 | /// setValueKind - Set the value kind produced by this expression. |

424 | void setValueKind(ExprValueKind Cat) { ExprBits.ValueKind = Cat; } |

425 | |

426 | /// setObjectKind - Set the object kind produced by this expression. |

427 | void setObjectKind(ExprObjectKind Cat) { ExprBits.ObjectKind = Cat; } |

428 | |

429 | private: |

430 | Classification ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const; |

431 | |

432 | public: |

433 | |

434 | /// Returns true if this expression is a gl-value that |

435 | /// potentially refers to a bit-field. |

436 | /// |

437 | /// In C++, whether a gl-value refers to a bitfield is essentially |

438 | /// an aspect of the value-kind type system. |

439 | bool refersToBitField() const { return getObjectKind() == OK_BitField; } |

440 | |

441 | /// If this expression refers to a bit-field, retrieve the |

442 | /// declaration of that bit-field. |

443 | /// |

444 | /// Note that this returns a non-null pointer in subtly different |

445 | /// places than refersToBitField returns true. In particular, this can |

446 | /// return a non-null pointer even for r-values loaded from |

447 | /// bit-fields, but it will return null for a conditional bit-field. |

448 | FieldDecl *getSourceBitField(); |

449 | |

450 | const FieldDecl *getSourceBitField() const { |

451 | return const_cast<Expr*>(this)->getSourceBitField(); |

452 | } |

453 | |

454 | Decl *getReferencedDeclOfCallee(); |

455 | const Decl *getReferencedDeclOfCallee() const { |

456 | return const_cast<Expr*>(this)->getReferencedDeclOfCallee(); |

457 | } |

458 | |

459 | /// If this expression is an l-value for an Objective C |

460 | /// property, find the underlying property reference expression. |

461 | const ObjCPropertyRefExpr *getObjCProperty() const; |

462 | |

463 | /// Check if this expression is the ObjC 'self' implicit parameter. |

464 | bool isObjCSelfExpr() const; |

465 | |

466 | /// Returns whether this expression refers to a vector element. |

467 | bool refersToVectorElement() const; |

468 | |

469 | /// Returns whether this expression refers to a global register |

470 | /// variable. |

471 | bool refersToGlobalRegisterVar() const; |

472 | |

473 | /// Returns whether this expression has a placeholder type. |

474 | bool hasPlaceholderType() const { |

475 | return getType()->isPlaceholderType(); |

476 | } |

477 | |

478 | /// Returns whether this expression has a specific placeholder type. |

479 | bool hasPlaceholderType(BuiltinType::Kind K) const { |

480 | assert(BuiltinType::isPlaceholderTypeKind(K)); |

481 | if (const BuiltinType *BT = dyn_cast<BuiltinType>(getType())) |

482 | return BT->getKind() == K; |

483 | return false; |

484 | } |

485 | |

486 | /// isKnownToHaveBooleanValue - Return true if this is an integer expression |

487 | /// that is known to return 0 or 1. This happens for _Bool/bool expressions |

488 | /// but also int expressions which are produced by things like comparisons in |

489 | /// C. |

490 | bool isKnownToHaveBooleanValue() const; |

491 | |

492 | /// isIntegerConstantExpr - Return true if this expression is a valid integer |

493 | /// constant expression, and, if so, return its value in Result. If not a |

494 | /// valid i-c-e, return false and fill in Loc (if specified) with the location |

495 | /// of the invalid expression. |

496 | /// |

497 | /// Note: This does not perform the implicit conversions required by C++11 |

498 | /// [expr.const]p5. |

499 | bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, |

500 | SourceLocation *Loc = nullptr, |

501 | bool isEvaluated = true) const; |

502 | bool isIntegerConstantExpr(const ASTContext &Ctx, |

503 | SourceLocation *Loc = nullptr) const; |

504 | |

505 | /// isCXX98IntegralConstantExpr - Return true if this expression is an |

506 | /// integral constant expression in C++98. Can only be used in C++. |

507 | bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const; |

508 | |

509 | /// isCXX11ConstantExpr - Return true if this expression is a constant |

510 | /// expression in C++11. Can only be used in C++. |

511 | /// |

512 | /// Note: This does not perform the implicit conversions required by C++11 |

513 | /// [expr.const]p5. |

514 | bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result = nullptr, |

515 | SourceLocation *Loc = nullptr) const; |

516 | |

517 | /// isPotentialConstantExpr - Return true if this function's definition |

518 | /// might be usable in a constant expression in C++11, if it were marked |

519 | /// constexpr. Return false if the function can never produce a constant |

520 | /// expression, along with diagnostics describing why not. |

521 | static bool isPotentialConstantExpr(const FunctionDecl *FD, |

522 | SmallVectorImpl< |

523 | PartialDiagnosticAt> &Diags); |

524 | |

525 | /// isPotentialConstantExprUnevaluted - Return true if this expression might |

526 | /// be usable in a constant expression in C++11 in an unevaluated context, if |

527 | /// it were in function FD marked constexpr. Return false if the function can |

528 | /// never produce a constant expression, along with diagnostics describing |

529 | /// why not. |

530 | static bool isPotentialConstantExprUnevaluated(Expr *E, |

531 | const FunctionDecl *FD, |

532 | SmallVectorImpl< |

533 | PartialDiagnosticAt> &Diags); |

534 | |

535 | /// isConstantInitializer - Returns true if this expression can be emitted to |

536 | /// IR as a constant, and thus can be used as a constant initializer in C. |

537 | /// If this expression is not constant and Culprit is non-null, |

538 | /// it is used to store the address of first non constant expr. |

539 | bool isConstantInitializer(ASTContext &Ctx, bool ForRef, |

540 | const Expr **Culprit = nullptr) const; |

541 | |

542 | /// EvalStatus is a struct with detailed info about an evaluation in progress. |

543 | struct EvalStatus { |

544 | /// Whether the evaluated expression has side effects. |

545 | /// For example, (f() && 0) can be folded, but it still has side effects. |

546 | bool HasSideEffects; |

547 | |

548 | /// Whether the evaluation hit undefined behavior. |

549 | /// For example, 1.0 / 0.0 can be folded to Inf, but has undefined behavior. |

550 | /// Likewise, INT_MAX + 1 can be folded to INT_MIN, but has UB. |

551 | bool HasUndefinedBehavior; |

552 | |

553 | /// Diag - If this is non-null, it will be filled in with a stack of notes |

554 | /// indicating why evaluation failed (or why it failed to produce a constant |

555 | /// expression). |

556 | /// If the expression is unfoldable, the notes will indicate why it's not |

557 | /// foldable. If the expression is foldable, but not a constant expression, |

558 | /// the notes will describes why it isn't a constant expression. If the |

559 | /// expression *is* a constant expression, no notes will be produced. |

560 | SmallVectorImpl<PartialDiagnosticAt> *Diag; |

561 | |

562 | EvalStatus() |

563 | : HasSideEffects(false), HasUndefinedBehavior(false), Diag(nullptr) {} |

564 | |

565 | // hasSideEffects - Return true if the evaluated expression has |

566 | // side effects. |

567 | bool hasSideEffects() const { |

568 | return HasSideEffects; |

569 | } |

570 | }; |

571 | |

572 | /// EvalResult is a struct with detailed info about an evaluated expression. |

573 | struct EvalResult : EvalStatus { |

574 | /// Val - This is the value the expression can be folded to. |

575 | APValue Val; |

576 | |

577 | // isGlobalLValue - Return true if the evaluated lvalue expression |

578 | // is global. |

579 | bool isGlobalLValue() const; |

580 | }; |

581 | |

582 | /// EvaluateAsRValue - Return true if this is a constant which we can fold to |

583 | /// an rvalue using any crazy technique (that has nothing to do with language |

584 | /// standards) that we want to, even if the expression has side-effects. If |

585 | /// this function returns true, it returns the folded constant in Result. If |

586 | /// the expression is a glvalue, an lvalue-to-rvalue conversion will be |

587 | /// applied. |

588 | bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, |

589 | bool InConstantContext = false) const; |

590 | |

591 | /// EvaluateAsBooleanCondition - Return true if this is a constant |

592 | /// which we can fold and convert to a boolean condition using |

593 | /// any crazy technique that we want to, even if the expression has |

594 | /// side-effects. |

595 | bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const; |

596 | |

597 | enum SideEffectsKind { |

598 | SE_NoSideEffects, ///< Strictly evaluate the expression. |

599 | SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not |

600 | ///< arbitrary unmodeled side effects. |

601 | SE_AllowSideEffects ///< Allow any unmodeled side effect. |

602 | }; |

603 | |

604 | /// EvaluateAsInt - Return true if this is a constant which we can fold and |

605 | /// convert to an integer, using any crazy technique that we want to. |

606 | bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, |

607 | SideEffectsKind AllowSideEffects = SE_NoSideEffects) const; |

608 | |

609 | /// EvaluateAsFloat - Return true if this is a constant which we can fold and |

610 | /// convert to a floating point value, using any crazy technique that we |

611 | /// want to. |

612 | bool |

613 | EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx, |

614 | SideEffectsKind AllowSideEffects = SE_NoSideEffects) const; |

615 | |

616 | /// EvaluateAsFloat - Return true if this is a constant which we can fold and |

617 | /// convert to a fixed point value. |

618 | bool EvaluateAsFixedPoint( |

619 | EvalResult &Result, const ASTContext &Ctx, |

620 | SideEffectsKind AllowSideEffects = SE_NoSideEffects) const; |

621 | |

622 | /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be |

623 | /// constant folded without side-effects, but discard the result. |

624 | bool isEvaluatable(const ASTContext &Ctx, |

625 | SideEffectsKind AllowSideEffects = SE_NoSideEffects) const; |

626 | |

627 | /// HasSideEffects - This routine returns true for all those expressions |

628 | /// which have any effect other than producing a value. Example is a function |

629 | /// call, volatile variable read, or throwing an exception. If |

630 | /// IncludePossibleEffects is false, this call treats certain expressions with |

631 | /// potential side effects (such as function call-like expressions, |

632 | /// instantiation-dependent expressions, or invocations from a macro) as not |

633 | /// having side effects. |

634 | bool HasSideEffects(const ASTContext &Ctx, |

635 | bool IncludePossibleEffects = true) const; |

636 | |

637 | /// Determine whether this expression involves a call to any function |

638 | /// that is not trivial. |

639 | bool hasNonTrivialCall(const ASTContext &Ctx) const; |

640 | |

641 | /// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded |

642 | /// integer. This must be called on an expression that constant folds to an |

643 | /// integer. |

644 | llvm::APSInt EvaluateKnownConstInt( |

645 | const ASTContext &Ctx, |

646 | SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const; |

647 | |

648 | llvm::APSInt EvaluateKnownConstIntCheckOverflow( |

649 | const ASTContext &Ctx, |

650 | SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const; |

651 | |

652 | void EvaluateForOverflow(const ASTContext &Ctx) const; |

653 | |

654 | /// EvaluateAsLValue - Evaluate an expression to see if we can fold it to an |

655 | /// lvalue with link time known address, with no side-effects. |

656 | bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const; |

657 | |

658 | /// EvaluateAsInitializer - Evaluate an expression as if it were the |

659 | /// initializer of the given declaration. Returns true if the initializer |

660 | /// can be folded to a constant, and produces any relevant notes. In C++11, |

661 | /// notes will be produced if the expression is not a constant expression. |

662 | bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx, |

663 | const VarDecl *VD, |

664 | SmallVectorImpl<PartialDiagnosticAt> &Notes) const; |

665 | |

666 | /// EvaluateWithSubstitution - Evaluate an expression as if from the context |

667 | /// of a call to the given function with the given arguments, inside an |

668 | /// unevaluated context. Returns true if the expression could be folded to a |

669 | /// constant. |

670 | bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx, |

671 | const FunctionDecl *Callee, |

672 | ArrayRef<const Expr*> Args, |

673 | const Expr *This = nullptr) const; |

674 | |

675 | /// Indicates how the constant expression will be used. |

676 | enum ConstExprUsage { EvaluateForCodeGen, EvaluateForMangling }; |

677 | |

678 | /// Evaluate an expression that is required to be a constant expression. |

679 | bool EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage, |

680 | const ASTContext &Ctx) const; |

681 | |

682 | /// If the current Expr is a pointer, this will try to statically |

683 | /// determine the number of bytes available where the pointer is pointing. |

684 | /// Returns true if all of the above holds and we were able to figure out the |

685 | /// size, false otherwise. |

686 | /// |

687 | /// \param Type - How to evaluate the size of the Expr, as defined by the |

688 | /// "type" parameter of __builtin_object_size |

689 | bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, |

690 | unsigned Type) const; |

691 | |

692 | /// Enumeration used to describe the kind of Null pointer constant |

693 | /// returned from \c isNullPointerConstant(). |

694 | enum NullPointerConstantKind { |

695 | /// Expression is not a Null pointer constant. |

696 | NPCK_NotNull = 0, |

697 | |

698 | /// Expression is a Null pointer constant built from a zero integer |

699 | /// expression that is not a simple, possibly parenthesized, zero literal. |

700 | /// C++ Core Issue 903 will classify these expressions as "not pointers" |

701 | /// once it is adopted. |

702 | /// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903 |

703 | NPCK_ZeroExpression, |

704 | |

705 | /// Expression is a Null pointer constant built from a literal zero. |

706 | NPCK_ZeroLiteral, |

707 | |

708 | /// Expression is a C++11 nullptr. |

709 | NPCK_CXX11_nullptr, |

710 | |

711 | /// Expression is a GNU-style __null constant. |

712 | NPCK_GNUNull |

713 | }; |

714 | |

715 | /// Enumeration used to describe how \c isNullPointerConstant() |

716 | /// should cope with value-dependent expressions. |

717 | enum NullPointerConstantValueDependence { |

718 | /// Specifies that the expression should never be value-dependent. |

719 | NPC_NeverValueDependent = 0, |

720 | |

721 | /// Specifies that a value-dependent expression of integral or |

722 | /// dependent type should be considered a null pointer constant. |

723 | NPC_ValueDependentIsNull, |

724 | |

725 | /// Specifies that a value-dependent expression should be considered |

726 | /// to never be a null pointer constant. |

727 | NPC_ValueDependentIsNotNull |

728 | }; |

729 | |

730 | /// isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to |

731 | /// a Null pointer constant. The return value can further distinguish the |

732 | /// kind of NULL pointer constant that was detected. |

733 | NullPointerConstantKind isNullPointerConstant( |

734 | ASTContext &Ctx, |

735 | NullPointerConstantValueDependence NPC) const; |

736 | |

737 | /// isOBJCGCCandidate - Return true if this expression may be used in a read/ |

738 | /// write barrier. |

739 | bool isOBJCGCCandidate(ASTContext &Ctx) const; |

740 | |

741 | /// Returns true if this expression is a bound member function. |

742 | bool isBoundMemberFunction(ASTContext &Ctx) const; |

743 | |

744 | /// Given an expression of bound-member type, find the type |

745 | /// of the member. Returns null if this is an *overloaded* bound |

746 | /// member expression. |

747 | static QualType findBoundMemberType(const Expr *expr); |

748 | |

749 | /// Skip past any implicit casts which might surround this expression until |

750 | /// reaching a fixed point. Skips: |

751 | /// * ImplicitCastExpr |

752 | /// * FullExpr |

753 | Expr *IgnoreImpCasts() LLVM_READONLY; |

754 | const Expr *IgnoreImpCasts() const { |

755 | return const_cast<Expr *>(this)->IgnoreImpCasts(); |

756 | } |

757 | |

758 | /// Skip past any casts which might surround this expression until reaching |

759 | /// a fixed point. Skips: |

760 | /// * CastExpr |

761 | /// * FullExpr |

762 | /// * MaterializeTemporaryExpr |

763 | /// * SubstNonTypeTemplateParmExpr |

764 | Expr *IgnoreCasts() LLVM_READONLY; |

765 | const Expr *IgnoreCasts() const { |

766 | return const_cast<Expr *>(this)->IgnoreCasts(); |

767 | } |

768 | |

769 | /// Skip past any implicit AST nodes which might surround this expression |

770 | /// until reaching a fixed point. Skips: |

771 | /// * What IgnoreImpCasts() skips |

772 | /// * MaterializeTemporaryExpr |

773 | /// * CXXBindTemporaryExpr |

774 | Expr *IgnoreImplicit() LLVM_READONLY; |

775 | const Expr *IgnoreImplicit() const { |

776 | return const_cast<Expr *>(this)->IgnoreImplicit(); |

777 | } |

778 | |

779 | /// Skip past any parentheses which might surround this expression until |

780 | /// reaching a fixed point. Skips: |

781 | /// * ParenExpr |

782 | /// * UnaryOperator if `UO_Extension` |

783 | /// * GenericSelectionExpr if `!isResultDependent()` |

784 | /// * ChooseExpr if `!isConditionDependent()` |

785 | /// * ConstantExpr |

786 | Expr *IgnoreParens() LLVM_READONLY; |

787 | const Expr *IgnoreParens() const { |

788 | return const_cast<Expr *>(this)->IgnoreParens(); |

789 | } |

790 | |

791 | /// Skip past any parentheses and implicit casts which might surround this |

792 | /// expression until reaching a fixed point. |

793 | /// FIXME: IgnoreParenImpCasts really ought to be equivalent to |

794 | /// IgnoreParens() + IgnoreImpCasts() until reaching a fixed point. However |

795 | /// this is currently not the case. Instead IgnoreParenImpCasts() skips: |

796 | /// * What IgnoreParens() skips |

797 | /// * ImplicitCastExpr |

798 | /// * MaterializeTemporaryExpr |

799 | /// * SubstNonTypeTemplateParmExpr |

800 | Expr *IgnoreParenImpCasts() LLVM_READONLY; |

801 | const Expr *IgnoreParenImpCasts() const { |

802 | return const_cast<Expr *>(this)->IgnoreParenImpCasts(); |

803 | } |

804 | |

805 | /// Skip past any parentheses and casts which might surround this expression |

806 | /// until reaching a fixed point. Skips: |

807 | /// * What IgnoreParens() skips |

808 | /// * What IgnoreCasts() skips |

809 | Expr *IgnoreParenCasts() LLVM_READONLY; |

810 | const Expr *IgnoreParenCasts() const { |

811 | return const_cast<Expr *>(this)->IgnoreParenCasts(); |

812 | } |

813 | |

814 | /// Skip conversion operators. If this Expr is a call to a conversion |

815 | /// operator, return the argument. |

816 | Expr *IgnoreConversionOperator() LLVM_READONLY; |

817 | const Expr *IgnoreConversionOperator() const { |

818 | return const_cast<Expr *>(this)->IgnoreConversionOperator(); |

819 | } |

820 | |

821 | /// Skip past any parentheses and lvalue casts which might surround this |

822 | /// expression until reaching a fixed point. Skips: |

823 | /// * What IgnoreParens() skips |

824 | /// * What IgnoreCasts() skips, except that only lvalue-to-rvalue |

825 | /// casts are skipped |

826 | /// FIXME: This is intended purely as a temporary workaround for code |

827 | /// that hasn't yet been rewritten to do the right thing about those |

828 | /// casts, and may disappear along with the last internal use. |

829 | Expr *IgnoreParenLValueCasts() LLVM_READONLY; |

830 | const Expr *IgnoreParenLValueCasts() const { |

831 | return const_cast<Expr *>(this)->IgnoreParenLValueCasts(); |

832 | } |

833 | |

834 | /// Skip past any parenthese and casts which do not change the value |

835 | /// (including ptr->int casts of the same size) until reaching a fixed point. |

836 | /// Skips: |

837 | /// * What IgnoreParens() skips |

838 | /// * CastExpr which do not change the value |

839 | /// * SubstNonTypeTemplateParmExpr |

840 | Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY; |

841 | const Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) const { |

842 | return const_cast<Expr *>(this)->IgnoreParenNoopCasts(Ctx); |

843 | } |

844 | |

845 | /// Skip past any parentheses and derived-to-base casts until reaching a |

846 | /// fixed point. Skips: |

847 | /// * What IgnoreParens() skips |

848 | /// * CastExpr which represent a derived-to-base cast (CK_DerivedToBase, |

849 | /// CK_UncheckedDerivedToBase and CK_NoOp) |

850 | Expr *ignoreParenBaseCasts() LLVM_READONLY; |

851 | const Expr *ignoreParenBaseCasts() const { |

852 | return const_cast<Expr *>(this)->ignoreParenBaseCasts(); |

853 | } |

854 | |

855 | /// Determine whether this expression is a default function argument. |

856 | /// |

857 | /// Default arguments are implicitly generated in the abstract syntax tree |

858 | /// by semantic analysis for function calls, object constructions, etc. in |

859 | /// C++. Default arguments are represented by \c CXXDefaultArgExpr nodes; |

860 | /// this routine also looks through any implicit casts to determine whether |

861 | /// the expression is a default argument. |

862 | bool isDefaultArgument() const; |

863 | |

864 | /// Determine whether the result of this expression is a |

865 | /// temporary object of the given class type. |

866 | bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const; |

867 | |

868 | /// Whether this expression is an implicit reference to 'this' in C++. |

869 | bool isImplicitCXXThis() const; |

870 | |

871 | static bool hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs); |

872 | |

873 | /// For an expression of class type or pointer to class type, |

874 | /// return the most derived class decl the expression is known to refer to. |

875 | /// |

876 | /// If this expression is a cast, this method looks through it to find the |

877 | /// most derived decl that can be inferred from the expression. |

878 | /// This is valid because derived-to-base conversions have undefined |

879 | /// behavior if the object isn't dynamically of the derived type. |

880 | const CXXRecordDecl *getBestDynamicClassType() const; |

881 | |

882 | /// Get the inner expression that determines the best dynamic class. |

883 | /// If this is a prvalue, we guarantee that it is of the most-derived type |

884 | /// for the object itself. |

885 | const Expr *getBestDynamicClassTypeExpr() const; |

886 | |

887 | /// Walk outwards from an expression we want to bind a reference to and |

888 | /// find the expression whose lifetime needs to be extended. Record |

889 | /// the LHSs of comma expressions and adjustments needed along the path. |

890 | const Expr *skipRValueSubobjectAdjustments( |

891 | SmallVectorImpl<const Expr *> &CommaLHS, |

892 | SmallVectorImpl<SubobjectAdjustment> &Adjustments) const; |

893 | const Expr *skipRValueSubobjectAdjustments() const { |

894 | SmallVector<const Expr *, 8> CommaLHSs; |

895 | SmallVector<SubobjectAdjustment, 8> Adjustments; |

896 | return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); |

897 | } |

898 | |

899 | static bool classof(const Stmt *T) { |

900 | return T->getStmtClass() >= firstExprConstant && |

901 | T->getStmtClass() <= lastExprConstant; |

902 | } |

903 | }; |

904 | |

905 | //===----------------------------------------------------------------------===// |

906 | // Wrapper Expressions. |

907 | //===----------------------------------------------------------------------===// |

908 | |

909 | /// FullExpr - Represents a "full-expression" node. |

910 | class FullExpr : public Expr { |

911 | protected: |

912 | Stmt *SubExpr; |

913 | |

914 | FullExpr(StmtClass SC, Expr *subexpr) |

915 | : Expr(SC, subexpr->getType(), |

916 | subexpr->getValueKind(), subexpr->getObjectKind(), |

917 | subexpr->isTypeDependent(), subexpr->isValueDependent(), |

918 | subexpr->isInstantiationDependent(), |

919 | subexpr->containsUnexpandedParameterPack()), SubExpr(subexpr) {} |

920 | FullExpr(StmtClass SC, EmptyShell Empty) |

921 | : Expr(SC, Empty) {} |

922 | public: |

923 | const Expr *getSubExpr() const { return cast<Expr>(SubExpr); } |

924 | Expr *getSubExpr() { return cast<Expr>(SubExpr); } |

925 | |

926 | /// As with any mutator of the AST, be very careful when modifying an |

927 | /// existing AST to preserve its invariants. |

928 | void setSubExpr(Expr *E) { SubExpr = E; } |

929 | |

930 | static bool classof(const Stmt *T) { |

931 | return T->getStmtClass() >= firstFullExprConstant && |

932 | T->getStmtClass() <= lastFullExprConstant; |

933 | } |

934 | }; |

935 | |

936 | /// ConstantExpr - An expression that occurs in a constant context. |

937 | class ConstantExpr : public FullExpr { |

938 | ConstantExpr(Expr *subexpr) |

939 | : FullExpr(ConstantExprClass, subexpr) {} |

940 | |

941 | public: |

942 | static ConstantExpr *Create(const ASTContext &Context, Expr *E) { |

943 | assert(!isa<ConstantExpr>(E)); |

944 | return new (Context) ConstantExpr(E); |

945 | } |

946 | |

947 | /// Build an empty constant expression wrapper. |

948 | explicit ConstantExpr(EmptyShell Empty) |

949 | : FullExpr(ConstantExprClass, Empty) {} |

950 | |

951 | SourceLocation getBeginLoc() const LLVM_READONLY { |

952 | return SubExpr->getBeginLoc(); |

953 | } |

954 | SourceLocation getEndLoc() const LLVM_READONLY { |

955 | return SubExpr->getEndLoc(); |

956 | } |

957 | |

958 | static bool classof(const Stmt *T) { |

959 | return T->getStmtClass() == ConstantExprClass; |

960 | } |

961 | |

962 | // Iterators |

963 | child_range children() { return child_range(&SubExpr, &SubExpr+1); } |

964 | const_child_range children() const { |

965 | return const_child_range(&SubExpr, &SubExpr + 1); |

966 | } |

967 | }; |

968 | |

969 | //===----------------------------------------------------------------------===// |

970 | // Primary Expressions. |

971 | //===----------------------------------------------------------------------===// |

972 | |

973 | /// OpaqueValueExpr - An expression referring to an opaque object of a |

974 | /// fixed type and value class. These don't correspond to concrete |

975 | /// syntax; instead they're used to express operations (usually copy |

976 | /// operations) on values whose source is generally obvious from |

977 | /// context. |

978 | class OpaqueValueExpr : public Expr { |

979 | friend class ASTStmtReader; |

980 | Expr *SourceExpr; |

981 | |

982 | public: |

983 | OpaqueValueExpr(SourceLocation Loc, QualType T, ExprValueKind VK, |

984 | ExprObjectKind OK = OK_Ordinary, |

985 | Expr *SourceExpr = nullptr) |

986 | : Expr(OpaqueValueExprClass, T, VK, OK, |

987 | T->isDependentType() || |

988 | (SourceExpr && SourceExpr->isTypeDependent()), |

989 | T->isDependentType() || |

990 | (SourceExpr && SourceExpr->isValueDependent()), |

991 | T->isInstantiationDependentType() || |

992 | (SourceExpr && SourceExpr->isInstantiationDependent()), |

993 | false), |

994 | SourceExpr(SourceExpr) { |

995 | setIsUnique(false); |

996 | OpaqueValueExprBits.Loc = Loc; |

997 | } |

998 | |

999 | /// Given an expression which invokes a copy constructor --- i.e. a |

1000 | /// CXXConstructExpr, possibly wrapped in an ExprWithCleanups --- |

1001 | /// find the OpaqueValueExpr that's the source of the construction. |

1002 | static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr); |

1003 | |

1004 | explicit OpaqueValueExpr(EmptyShell Empty) |

1005 | : Expr(OpaqueValueExprClass, Empty) {} |

1006 | |

1007 | /// Retrieve the location of this expression. |

1008 | SourceLocation getLocation() const { return OpaqueValueExprBits.Loc; } |

1009 | |

1010 | SourceLocation getBeginLoc() const LLVM_READONLY { |

1011 | return SourceExpr ? SourceExpr->getBeginLoc() : getLocation(); |

1012 | } |

1013 | SourceLocation getEndLoc() const LLVM_READONLY { |

1014 | return SourceExpr ? SourceExpr->getEndLoc() : getLocation(); |

1015 | } |

1016 | SourceLocation getExprLoc() const LLVM_READONLY { |

1017 | return SourceExpr ? SourceExpr->getExprLoc() : getLocation(); |

1018 | } |

1019 | |

1020 | child_range children() { |

1021 | return child_range(child_iterator(), child_iterator()); |

1022 | } |

1023 | |

1024 | const_child_range children() const { |

1025 | return const_child_range(const_child_iterator(), const_child_iterator()); |

1026 | } |

1027 | |

1028 | /// The source expression of an opaque value expression is the |

1029 | /// expression which originally generated the value. This is |

1030 | /// provided as a convenience for analyses that don't wish to |

1031 | /// precisely model the execution behavior of the program. |

1032 | /// |

1033 | /// The source expression is typically set when building the |

1034 | /// expression which binds the opaque value expression in the first |

1035 | /// place. |

1036 | Expr *getSourceExpr() const { return SourceExpr; } |

1037 | |

1038 | void setIsUnique(bool V) { |

1039 | assert((!V || SourceExpr) && |

1040 | "unique OVEs are expected to have source expressions"); |

1041 | OpaqueValueExprBits.IsUnique = V; |

1042 | } |

1043 | |

1044 | bool isUnique() const { return OpaqueValueExprBits.IsUnique; } |

1045 | |

1046 | static bool classof(const Stmt *T) { |

1047 | return T->getStmtClass() == OpaqueValueExprClass; |

1048 | } |

1049 | }; |

1050 | |

1051 | /// A reference to a declared variable, function, enum, etc. |

1052 | /// [C99 6.5.1p2] |

1053 | /// |

1054 | /// This encodes all the information about how a declaration is referenced |

1055 | /// within an expression. |

1056 | /// |

1057 | /// There are several optional constructs attached to DeclRefExprs only when |

1058 | /// they apply in order to conserve memory. These are laid out past the end of |

1059 | /// the object, and flags in the DeclRefExprBitfield track whether they exist: |

1060 | /// |

1061 | /// DeclRefExprBits.HasQualifier: |

1062 | /// Specifies when this declaration reference expression has a C++ |

1063 | /// nested-name-specifier. |

1064 | /// DeclRefExprBits.HasFoundDecl: |

1065 | /// Specifies when this declaration reference expression has a record of |

1066 | /// a NamedDecl (different from the referenced ValueDecl) which was found |

1067 | /// during name lookup and/or overload resolution. |

1068 | /// DeclRefExprBits.HasTemplateKWAndArgsInfo: |

1069 | /// Specifies when this declaration reference expression has an explicit |

1070 | /// C++ template keyword and/or template argument list. |

1071 | /// DeclRefExprBits.RefersToEnclosingVariableOrCapture |

1072 | /// Specifies when this declaration reference expression (validly) |

1073 | /// refers to an enclosed local or a captured variable. |

1074 | class DeclRefExpr final |

1075 | : public Expr, |

1076 | private llvm::TrailingObjects<DeclRefExpr, NestedNameSpecifierLoc, |

1077 | NamedDecl *, ASTTemplateKWAndArgsInfo, |

1078 | TemplateArgumentLoc> { |

1079 | friend class ASTStmtReader; |

1080 | friend class ASTStmtWriter; |

1081 | friend TrailingObjects; |

1082 | |

1083 | /// The declaration that we are referencing. |

1084 | ValueDecl *D; |

1085 | |

1086 | /// Provides source/type location info for the declaration name |

1087 | /// embedded in D. |

1088 | DeclarationNameLoc DNLoc; |

1089 | |

1090 | size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>) const { |

1091 | return hasQualifier(); |

1092 | } |

1093 | |

1094 | size_t numTrailingObjects(OverloadToken<NamedDecl *>) const { |

1095 | return hasFoundDecl(); |

1096 | } |

1097 | |

1098 | size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const { |

1099 | return hasTemplateKWAndArgsInfo(); |

1100 | } |

1101 | |

1102 | /// Test whether there is a distinct FoundDecl attached to the end of |

1103 | /// this DRE. |

1104 | bool hasFoundDecl() const { return DeclRefExprBits.HasFoundDecl; } |

1105 | |

1106 | DeclRefExpr(const ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc, |

1107 | SourceLocation TemplateKWLoc, ValueDecl *D, |

1108 | bool RefersToEnlosingVariableOrCapture, |

1109 | const DeclarationNameInfo &NameInfo, NamedDecl *FoundD, |

1110 | const TemplateArgumentListInfo *TemplateArgs, QualType T, |

1111 | ExprValueKind VK); |

1112 | |

1113 | /// Construct an empty declaration reference expression. |

1114 | explicit DeclRefExpr(EmptyShell Empty) : Expr(DeclRefExprClass, Empty) {} |

1115 | |

1116 | /// Computes the type- and value-dependence flags for this |

1117 | /// declaration reference expression. |

1118 | void computeDependence(const ASTContext &Ctx); |

1119 | |

1120 | public: |

1121 | DeclRefExpr(const ASTContext &Ctx, ValueDecl *D, |

1122 | bool RefersToEnclosingVariableOrCapture, QualType T, |

1123 | ExprValueKind VK, SourceLocation L, |

1124 | const DeclarationNameLoc &LocInfo = DeclarationNameLoc()); |

1125 | |

1126 | static DeclRefExpr * |

1127 | Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, |

1128 | SourceLocation TemplateKWLoc, ValueDecl *D, |

1129 | bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, |

1130 | QualType T, ExprValueKind VK, NamedDecl *FoundD = nullptr, |

1131 | const TemplateArgumentListInfo *TemplateArgs = nullptr); |

1132 | |

1133 | static DeclRefExpr * |

1134 | Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, |

1135 | SourceLocation TemplateKWLoc, ValueDecl *D, |

1136 | bool RefersToEnclosingVariableOrCapture, |

1137 | const DeclarationNameInfo &NameInfo, QualType T, ExprValueKind VK, |

1138 | NamedDecl *FoundD = nullptr, |

1139 | const TemplateArgumentListInfo *TemplateArgs = nullptr); |

1140 | |

1141 | /// Construct an empty declaration reference expression. |

1142 | static DeclRefExpr *CreateEmpty(const ASTContext &Context, bool HasQualifier, |

1143 | bool HasFoundDecl, |

1144 | bool HasTemplateKWAndArgsInfo, |

1145 | unsigned NumTemplateArgs); |

1146 | |

1147 | ValueDecl *getDecl() { return D; } |

1148 | const ValueDecl *getDecl() const { return D; } |

1149 | void setDecl(ValueDecl *NewD) { D = NewD; } |

1150 | |

1151 | DeclarationNameInfo getNameInfo() const { |

1152 | return DeclarationNameInfo(getDecl()->getDeclName(), getLocation(), DNLoc); |

1153 | } |

1154 | |

1155 | SourceLocation getLocation() const { return DeclRefExprBits.Loc; } |

1156 | void setLocation(SourceLocation L) { DeclRefExprBits.Loc = L; } |

1157 | SourceLocation getBeginLoc() const LLVM_READONLY; |

1158 | SourceLocation getEndLoc() const LLVM_READONLY; |

1159 | |

1160 | /// Determine whether this declaration reference was preceded by a |

1161 | /// C++ nested-name-specifier, e.g., \c N::foo. |

1162 | bool hasQualifier() const { return DeclRefExprBits.HasQualifier; } |

1163 | |

1164 | /// If the name was qualified, retrieves the nested-name-specifier |

1165 | /// that precedes the name, with source-location information. |

1166 | NestedNameSpecifierLoc getQualifierLoc() const { |

1167 | if (!hasQualifier()) |

1168 | return NestedNameSpecifierLoc(); |

1169 | return *getTrailingObjects<NestedNameSpecifierLoc>(); |

1170 | } |

1171 | |

1172 | /// If the name was qualified, retrieves the nested-name-specifier |

1173 | /// that precedes the name. Otherwise, returns NULL. |

1174 | NestedNameSpecifier *getQualifier() const { |

1175 | return getQualifierLoc().getNestedNameSpecifier(); |

1176 | } |

1177 | |

1178 | /// Get the NamedDecl through which this reference occurred. |

1179 | /// |

1180 | /// This Decl may be different from the ValueDecl actually referred to in the |

1181 | /// presence of using declarations, etc. It always returns non-NULL, and may |

1182 | /// simple return the ValueDecl when appropriate. |

1183 | |

1184 | NamedDecl *getFoundDecl() { |

1185 | return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D; |

1186 | } |

1187 | |

1188 | /// Get the NamedDecl through which this reference occurred. |

1189 | /// See non-const variant. |

1190 | const NamedDecl *getFoundDecl() const { |

1191 | return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D; |

1192 | } |

1193 | |

1194 | bool hasTemplateKWAndArgsInfo() const { |

1195 | return DeclRefExprBits.HasTemplateKWAndArgsInfo; |

1196 | } |

1197 | |

1198 | /// Retrieve the location of the template keyword preceding |

1199 | /// this name, if any. |

1200 | SourceLocation getTemplateKeywordLoc() const { |

1201 | if (!hasTemplateKWAndArgsInfo()) |

1202 | return SourceLocation(); |

1203 | return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc; |

1204 | } |

1205 | |

1206 | /// Retrieve the location of the left angle bracket starting the |

1207 | /// explicit template argument list following the name, if any. |

1208 | SourceLocation getLAngleLoc() const { |

1209 | if (!hasTemplateKWAndArgsInfo()) |

1210 | return SourceLocation(); |

1211 | return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc; |

1212 | } |

1213 | |

1214 | /// Retrieve the location of the right angle bracket ending the |

1215 | /// explicit template argument list following the name, if any. |

1216 | SourceLocation getRAngleLoc() const { |

1217 | if (!hasTemplateKWAndArgsInfo()) |

1218 | return SourceLocation(); |

1219 | return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc; |

1220 | } |

1221 | |

1222 | /// Determines whether the name in this declaration reference |

1223 | /// was preceded by the template keyword. |

1224 | bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); } |

1225 | |

1226 | /// Determines whether this declaration reference was followed by an |

1227 | /// explicit template argument list. |

1228 | bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); } |

1229 | |

1230 | /// Copies the template arguments (if present) into the given |

1231 | /// structure. |

1232 | void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { |

1233 | if (hasExplicitTemplateArgs()) |

1234 | getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto( |

1235 | getTrailingObjects<TemplateArgumentLoc>(), List); |

1236 | } |

1237 | |

1238 | /// Retrieve the template arguments provided as part of this |

1239 | /// template-id. |

1240 | const TemplateArgumentLoc *getTemplateArgs() const { |

1241 | if (!hasExplicitTemplateArgs()) |

1242 | return nullptr; |

1243 | return getTrailingObjects<TemplateArgumentLoc>(); |

1244 | } |

1245 | |

1246 | /// Retrieve the number of template arguments provided as part of this |

1247 | /// template-id. |

1248 | unsigned getNumTemplateArgs() const { |

1249 | if (!hasExplicitTemplateArgs()) |

1250 | return 0; |

1251 | return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs; |

1252 | } |

1253 | |

1254 | ArrayRef<TemplateArgumentLoc> template_arguments() const { |

1255 | return {getTemplateArgs(), getNumTemplateArgs()}; |

1256 | } |

1257 | |

1258 | /// Returns true if this expression refers to a function that |

1259 | /// was resolved from an overloaded set having size greater than 1. |

1260 | bool hadMultipleCandidates() const { |

1261 | return DeclRefExprBits.HadMultipleCandidates; |

1262 | } |

1263 | /// Sets the flag telling whether this expression refers to |

1264 | /// a function that was resolved from an overloaded set having size |

1265 | /// greater than 1. |

1266 | void setHadMultipleCandidates(bool V = true) { |

1267 | DeclRefExprBits.HadMultipleCandidates = V; |

1268 | } |

1269 | |

1270 | /// Does this DeclRefExpr refer to an enclosing local or a captured |

1271 | /// variable? |

1272 | bool refersToEnclosingVariableOrCapture() const { |

1273 | return DeclRefExprBits.RefersToEnclosingVariableOrCapture; |

1274 | } |

1275 | |

1276 | static bool classof(const Stmt *T) { |

1277 | return T->getStmtClass() == DeclRefExprClass; |

1278 | } |

1279 | |

1280 | // Iterators |

1281 | child_range children() { |

1282 | return child_range(child_iterator(), child_iterator()); |

1283 | } |

1284 | |

1285 | const_child_range children() const { |

1286 | return const_child_range(const_child_iterator(), const_child_iterator()); |

1287 | } |

1288 | }; |

1289 | |

1290 | /// Used by IntegerLiteral/FloatingLiteral to store the numeric without |

1291 | /// leaking memory. |

1292 | /// |

1293 | /// For large floats/integers, APFloat/APInt will allocate memory from the heap |

1294 | /// to represent these numbers. Unfortunately, when we use a BumpPtrAllocator |

1295 | /// to allocate IntegerLiteral/FloatingLiteral nodes the memory associated with |

1296 | /// the APFloat/APInt values will never get freed. APNumericStorage uses |

1297 | /// ASTContext's allocator for memory allocation. |

1298 | class APNumericStorage { |

1299 | union { |

1300 | uint64_t VAL; ///< Used to store the <= 64 bits integer value. |

1301 | uint64_t *pVal; ///< Used to store the >64 bits integer value. |

1302 | }; |

1303 | unsigned BitWidth; |

1304 | |

1305 | bool hasAllocation() const { return llvm::APInt::getNumWords(BitWidth) > 1; } |

1306 | |

1307 | APNumericStorage(const APNumericStorage &) = delete; |

1308 | void operator=(const APNumericStorage &) = delete; |

1309 | |

1310 | protected: |

1311 | APNumericStorage() : VAL(0), BitWidth(0) { } |

1312 | |

1313 | llvm::APInt getIntValue() const { |

1314 | unsigned NumWords = llvm::APInt::getNumWords(BitWidth); |

1315 | if (NumWords > 1) |

1316 | return llvm::APInt(BitWidth, NumWords, pVal); |

1317 | else |

1318 | return llvm::APInt(BitWidth, VAL); |

1319 | } |

1320 | void setIntValue(const ASTContext &C, const llvm::APInt &Val); |

1321 | }; |

1322 | |

1323 | class APIntStorage : private APNumericStorage { |

1324 | public: |

1325 | llvm::APInt getValue() const { return getIntValue(); } |

1326 | void setValue(const ASTContext &C, const llvm::APInt &Val) { |

1327 | setIntValue(C, Val); |

1328 | } |

1329 | }; |

1330 | |

1331 | class APFloatStorage : private APNumericStorage { |

1332 | public: |

1333 | llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const { |

1334 | return llvm::APFloat(Semantics, getIntValue()); |

1335 | } |

1336 | void setValue(const ASTContext &C, const llvm::APFloat &Val) { |

1337 | setIntValue(C, Val.bitcastToAPInt()); |

1338 | } |

1339 | }; |

1340 | |

1341 | class IntegerLiteral : public Expr, public APIntStorage { |

1342 | SourceLocation Loc; |

1343 | |

1344 | /// Construct an empty integer literal. |

1345 | explicit IntegerLiteral(EmptyShell Empty) |

1346 | : Expr(IntegerLiteralClass, Empty) { } |

1347 | |

1348 | public: |

1349 | // type should be IntTy, LongTy, LongLongTy, UnsignedIntTy, UnsignedLongTy, |

1350 | // or UnsignedLongLongTy |

1351 | IntegerLiteral(const ASTContext &C, const llvm::APInt &V, QualType type, |

1352 | SourceLocation l); |

1353 | |

1354 | /// Returns a new integer literal with value 'V' and type 'type'. |

1355 | /// \param type - either IntTy, LongTy, LongLongTy, UnsignedIntTy, |

1356 | /// UnsignedLongTy, or UnsignedLongLongTy which should match the size of V |

1357 | /// \param V - the value that the returned integer literal contains. |

1358 | static IntegerLiteral *Create(const ASTContext &C, const llvm::APInt &V, |

1359 | QualType type, SourceLocation l); |

1360 | /// Returns a new empty integer literal. |

1361 | static IntegerLiteral *Create(const ASTContext &C, EmptyShell Empty); |

1362 | |

1363 | SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; } |

1364 | SourceLocation getEndLoc() const LLVM_READONLY { return Loc; } |

1365 | |

1366 | /// Retrieve the location of the literal. |

1367 | SourceLocation getLocation() const { return Loc; } |

1368 | |

1369 | void setLocation(SourceLocation Location) { Loc = Location; } |

1370 | |

1371 | static bool classof(const Stmt *T) { |

1372 | return T->getStmtClass() == IntegerLiteralClass; |

1373 | } |

1374 | |

1375 | // Iterators |

1376 | child_range children() { |

1377 | return child_range(child_iterator(), child_iterator()); |

1378 | } |

1379 | const_child_range children() const { |

1380 | return const_child_range(const_child_iterator(), const_child_iterator()); |

1381 | } |

1382 | }; |

1383 | |

1384 | class FixedPointLiteral : public Expr, public APIntStorage { |

1385 | SourceLocation Loc; |

1386 | unsigned Scale; |

1387 | |

1388 | /// \brief Construct an empty integer literal. |

1389 | explicit FixedPointLiteral(EmptyShell Empty) |

1390 | : Expr(FixedPointLiteralClass, Empty) {} |

1391 | |

1392 | public: |

1393 | FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type, |

1394 | SourceLocation l, unsigned Scale); |

1395 | |

1396 | // Store the int as is without any bit shifting. |

1397 | static FixedPointLiteral *CreateFromRawInt(const ASTContext &C, |

1398 | const llvm::APInt &V, |

1399 | QualType type, SourceLocation l, |

1400 | unsigned Scale); |

1401 | |

1402 | SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; } |

1403 | SourceLocation getEndLoc() const LLVM_READONLY { return Loc; } |

1404 | |

1405 | /// \brief Retrieve the location of the literal. |

1406 | SourceLocation getLocation() const { return Loc; } |

1407 | |

1408 | void setLocation(SourceLocation Location) { Loc = Location; } |

1409 | |

1410 | static bool classof(const Stmt *T) { |

1411 | return T->getStmtClass() == FixedPointLiteralClass; |

1412 | } |

1413 | |

1414 | std::string getValueAsString(unsigned Radix) const; |

1415 | |

1416 | // Iterators |

1417 | child_range children() { |

1418 | return child_range(child_iterator(), child_iterator()); |

1419 | } |

1420 | const_child_range children() const { |

1421 | return const_child_range(const_child_iterator(), const_child_iterator()); |

1422 | } |

1423 | }; |

1424 | |

1425 | class CharacterLiteral : public Expr { |

1426 | public: |

1427 | enum CharacterKind { |

1428 | Ascii, |

1429 | Wide, |

1430 | UTF8, |

1431 | UTF16, |

1432 | UTF32 |

1433 | }; |

1434 | |

1435 | private: |

1436 | unsigned Value; |

1437 | SourceLocation Loc; |

1438 | public: |

1439 | // type should be IntTy |

1440 | CharacterLiteral(unsigned value, CharacterKind kind, QualType type, |

1441 | SourceLocation l) |

1442 | : Expr(CharacterLiteralClass, type, VK_RValue, OK_Ordinary, false, false, |

1443 | false, false), |

1444 | Value(value), Loc(l) { |

1445 | CharacterLiteralBits.Kind = kind; |

1446 | } |

1447 | |

1448 | /// Construct an empty character literal. |

1449 | CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { } |

1450 | |

1451 | SourceLocation getLocation() const { return Loc; } |

1452 | CharacterKind getKind() const { |

1453 | return static_cast<CharacterKind>(CharacterLiteralBits.Kind); |

1454 | } |

1455 | |

1456 | SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; } |

1457 | SourceLocation getEndLoc() const LLVM_READONLY { return Loc; } |

1458 | |

1459 | unsigned getValue() const { return Value; } |

1460 | |

1461 | void setLocation(SourceLocation Location) { Loc = Location; } |

1462 | void setKind(CharacterKind kind) { CharacterLiteralBits.Kind = kind; } |

1463 | void setValue(unsigned Val) { Value = Val; } |

1464 | |

1465 | static bool classof(const Stmt *T) { |

1466 | return T->getStmtClass() == CharacterLiteralClass; |

1467 | } |

1468 | |

1469 | // Iterators |

1470 | child_range children() { |

1471 | return child_range(child_iterator(), child_iterator()); |

1472 | } |

1473 | const_child_range children() const { |

1474 | return const_child_range(const_child_iterator(), const_child_iterator()); |

1475 | } |

1476 | }; |

1477 | |

1478 | class FloatingLiteral : public Expr, private APFloatStorage { |

1479 | SourceLocation Loc; |

1480 | |

1481 | FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact, |

1482 | QualType Type, SourceLocation L); |

1483 | |

1484 | /// Construct an empty floating-point literal. |

1485 | explicit FloatingLiteral(const ASTContext &C, EmptyShell Empty); |

1486 | |

1487 | public: |

1488 | static FloatingLiteral *Create(const ASTContext &C, const llvm::APFloat &V, |

1489 | bool isexact, QualType Type, SourceLocation L); |

1490 | static FloatingLiteral *Create(const ASTContext &C, EmptyShell Empty); |

1491 | |

1492 | llvm::APFloat getValue() const { |

1493 | return APFloatStorage::getValue(getSemantics()); |

1494 | } |

1495 | void setValue(const ASTContext &C, const llvm::APFloat &Val) { |

1496 | assert(&getSemantics() == &Val.getSemantics() && "Inconsistent semantics"); |

1497 | APFloatStorage::setValue(C, Val); |

1498 | } |

1499 | |

1500 | /// Get a raw enumeration value representing the floating-point semantics of |

1501 | /// this literal (32-bit IEEE, x87, ...), suitable for serialisation. |

1502 | APFloatSemantics getRawSemantics() const { |

1503 | return static_cast<APFloatSemantics>(FloatingLiteralBits.Semantics); |

1504 | } |

1505 | |

1506 | /// Set the raw enumeration value representing the floating-point semantics of |

1507 | /// this literal (32-bit IEEE, x87, ...), suitable for serialisation. |

1508 | void setRawSemantics(APFloatSemantics Sem) { |

1509 | FloatingLiteralBits.Semantics = Sem; |

1510 | } |

1511 | |

1512 | /// Return the APFloat semantics this literal uses. |

1513 | const llvm::fltSemantics &getSemantics() const; |

1514 | |

1515 | /// Set the APFloat semantics this literal uses. |

1516 | void setSemantics(const llvm::fltSemantics &Sem); |

1517 | |

1518 | bool isExact() const { return FloatingLiteralBits.IsExact; } |

1519 | void setExact(bool E) { FloatingLiteralBits.IsExact = E; } |

1520 | |

1521 | /// getValueAsApproximateDouble - This returns the value as an inaccurate |

1522 | /// double. Note that this may cause loss of precision, but is useful for |

1523 | /// debugging dumps, etc. |

1524 | double getValueAsApproximateDouble() const; |

1525 | |

1526 | SourceLocation getLocation() const { return Loc; } |

1527 | void setLocation(SourceLocation L) { Loc = L; } |

1528 | |

1529 | SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; } |

1530 | SourceLocation getEndLoc() const LLVM_READONLY { return Loc; } |

1531 | |

1532 | static bool classof(const Stmt *T) { |

1533 | return T->getStmtClass() == FloatingLiteralClass; |

1534 | } |

1535 | |

1536 | // Iterators |

1537 | child_range children() { |

1538 | return child_range(child_iterator(), child_iterator()); |

1539 | } |

1540 | const_child_range children() const { |

1541 | return const_child_range(const_child_iterator(), const_child_iterator()); |

1542 | } |

1543 | }; |

1544 | |

1545 | /// ImaginaryLiteral - We support imaginary integer and floating point literals, |

1546 | /// like "1.0i". We represent these as a wrapper around FloatingLiteral and |

1547 | /// IntegerLiteral classes. Instances of this class always have a Complex type |

1548 | /// whose element type matches the subexpression. |

1549 | /// |

1550 | class ImaginaryLiteral : public Expr { |

1551 | Stmt *Val; |

1552 | public: |

1553 | ImaginaryLiteral(Expr *val, QualType Ty) |

1554 | : Expr(ImaginaryLiteralClass, Ty, VK_RValue, OK_Ordinary, false, false, |

1555 | false, false), |

1556 | Val(val) {} |

1557 | |

1558 | /// Build an empty imaginary literal. |

1559 | explicit ImaginaryLiteral(EmptyShell Empty) |

1560 | : Expr(ImaginaryLiteralClass, Empty) { } |

1561 | |

1562 | const Expr *getSubExpr() const { return cast<Expr>(Val); } |

1563 | Expr *getSubExpr() { return cast<Expr>(Val); } |

1564 | void setSubExpr(Expr *E) { Val = E; } |

1565 | |

1566 | SourceLocation getBeginLoc() const LLVM_READONLY { |

1567 | return Val->getBeginLoc(); |

1568 | } |

1569 | SourceLocation getEndLoc() const LLVM_READONLY { return Val->getEndLoc(); } |

1570 | |

1571 | static bool classof(const Stmt *T) { |

1572 | return T->getStmtClass() == ImaginaryLiteralClass; |

1573 | } |

1574 | |

1575 | // Iterators |

1576 | child_range children() { return child_range(&Val, &Val+1); } |

1577 | const_child_range children() const { |

1578 | return const_child_range(&Val, &Val + 1); |

1579 | } |

1580 | }; |

1581 | |

1582 | /// StringLiteral - This represents a string literal expression, e.g. "foo" |

1583 | /// or L"bar" (wide strings). The actual string data can be obtained with |

1584 | /// getBytes() and is NOT null-terminated. The length of the string data is |

1585 | /// determined by calling getByteLength(). |

1586 | /// |

1587 | /// The C type for a string is always a ConstantArrayType. In C++, the char |

1588 | /// type is const qualified, in C it is not. |

1589 | /// |

1590 | /// Note that strings in C can be formed by concatenation of multiple string |

1591 | /// literal pptokens in translation phase #6. This keeps track of the locations |

1592 | /// of each of these pieces. |

1593 | /// |

1594 | /// Strings in C can also be truncated and extended by assigning into arrays, |

1595 | /// e.g. with constructs like: |

1596 | /// char X[2] = "foobar"; |

1597 | /// In this case, getByteLength() will return 6, but the string literal will |

1598 | /// have type "char[2]". |

1599 | class StringLiteral final |

1600 | : public Expr, |

1601 | private llvm::TrailingObjects<StringLiteral, unsigned, SourceLocation, |

1602 | char> { |

1603 | friend class ASTStmtReader; |

1604 | friend TrailingObjects; |

1605 | |

1606 | /// StringLiteral is followed by several trailing objects. They are in order: |

1607 | /// |

1608 | /// * A single unsigned storing the length in characters of this string. The |

1609 | /// length in bytes is this length times the width of a single character. |

1610 | /// Always present and stored as a trailing objects because storing it in |

1611 | /// StringLiteral would increase the size of StringLiteral by sizeof(void *) |

1612 | /// due to alignment requirements. If you add some data to StringLiteral, |

1613 | /// consider moving it inside StringLiteral. |

1614 | /// |

1615 | /// * An array of getNumConcatenated() SourceLocation, one for each of the |

1616 | /// token this string is made of. |

1617 | /// |

1618 | /// * An array of getByteLength() char used to store the string data. |

1619 | |

1620 | public: |

1621 | enum StringKind { Ascii, Wide, UTF8, UTF16, UTF32 }; |

1622 | |

1623 | private: |

1624 | unsigned numTrailingObjects(OverloadToken<unsigned>) const { return 1; } |

1625 | unsigned numTrailingObjects(OverloadToken<SourceLocation>) const { |

1626 | return getNumConcatenated(); |

1627 | } |

1628 | |

1629 | unsigned numTrailingObjects(OverloadToken<char>) const { |

1630 | return getByteLength(); |

1631 | } |

1632 | |

1633 | char *getStrDataAsChar() { return getTrailingObjects<char>(); } |

1634 | const char *getStrDataAsChar() const { return getTrailingObjects<char>(); } |

1635 | |

1636 | const uint16_t *getStrDataAsUInt16() const { |

1637 | return reinterpret_cast<const uint16_t *>(getTrailingObjects<char>()); |

1638 | } |

1639 | |

1640 | const uint32_t *getStrDataAsUInt32() const { |

1641 | return reinterpret_cast<const uint32_t *>(getTrailingObjects<char>()); |

1642 | } |

1643 | |

1644 | /// Build a string literal. |

1645 | StringLiteral(const ASTContext &Ctx, StringRef Str, StringKind Kind, |

1646 | bool Pascal, QualType Ty, const SourceLocation *Loc, |

1647 | unsigned NumConcatenated); |

1648 | |

1649 | /// Build an empty string literal. |

1650 | StringLiteral(EmptyShell Empty, unsigned NumConcatenated, unsigned Length, |

1651 | unsigned CharByteWidth); |

1652 | |

1653 | /// Map a target and string kind to the appropriate character width. |

1654 | static unsigned mapCharByteWidth(TargetInfo const &Target, StringKind SK); |

1655 | |

1656 | /// Set one of the string literal token. |

1657 | void setStrTokenLoc(unsigned TokNum, SourceLocation L) { |

1658 | assert(TokNum < getNumConcatenated() && "Invalid tok number"); |

1659 | getTrailingObjects<SourceLocation>()[TokNum] = L; |

1660 | } |

1661 | |

1662 | public: |

1663 | /// This is the "fully general" constructor that allows representation of |

1664 | /// strings formed from multiple concatenated tokens. |

1665 | static StringLiteral *Create(const ASTContext &Ctx, StringRef Str, |

1666 | StringKind Kind, bool Pascal, QualType Ty, |

1667 | const SourceLocation *Loc, |

1668 | unsigned NumConcatenated); |

1669 | |

1670 | /// Simple constructor for string literals made from one token. |

1671 | static StringLiteral *Create(const ASTContext &Ctx, StringRef Str, |

1672 | StringKind Kind, bool Pascal, QualType Ty, |

1673 | SourceLocation Loc) { |

1674 | return Create(Ctx, Str, Kind, Pascal, Ty, &Loc, 1); |

1675 | } |

1676 | |

1677 | /// Construct an empty string literal. |

1678 | static StringLiteral *CreateEmpty(const ASTContext &Ctx, |

1679 | unsigned NumConcatenated, unsigned Length, |

1680 | unsigned CharByteWidth); |

1681 | |

1682 | StringRef getString() const { |

1683 | assert(getCharByteWidth() == 1 && |

1684 | "This function is used in places that assume strings use char"); |

1685 | return StringRef(getStrDataAsChar(), getByteLength()); |

1686 | } |

1687 | |

1688 | /// Allow access to clients that need the byte representation, such as |

1689 | /// ASTWriterStmt::VisitStringLiteral(). |

1690 | StringRef getBytes() const { |

1691 | // FIXME: StringRef may not be the right type to use as a result for this. |

1692 | return StringRef(getStrDataAsChar(), getByteLength()); |

1693 | } |

1694 | |

1695 | void outputString(raw_ostream &OS) const; |

1696 | |

1697 | uint32_t getCodeUnit(size_t i) const { |

1698 | assert(i < getLength() && "out of bounds access"); |

1699 | switch (getCharByteWidth()) { |

1700 | case 1: |

1701 | return static_cast<unsigned char>(getStrDataAsChar()[i]); |

1702 | case 2: |

1703 | return getStrDataAsUInt16()[i]; |

1704 | case 4: |

1705 | return getStrDataAsUInt32()[i]; |

1706 | } |

1707 | llvm_unreachable("Unsupported character width!"); |

1708 | } |

1709 | |

1710 | unsigned getByteLength() const { return getCharByteWidth() * getLength(); } |

1711 | unsigned getLength() const { return *getTrailingObjects<unsigned>(); } |

1712 | unsigned getCharByteWidth() const { return StringLiteralBits.CharByteWidth; } |

1713 | |

1714 | StringKind getKind() const { |

1715 | return static_cast<StringKind>(StringLiteralBits.Kind); |

1716 | } |

1717 | |

1718 | bool isAscii() const { return getKind() == Ascii; } |

1719 | bool isWide() const { return getKind() == Wide; } |

1720 | bool isUTF8() const { return getKind() == UTF8; } |

1721 | bool isUTF16() const { return getKind() == UTF16; } |

1722 | bool isUTF32() const { return getKind() == UTF32; } |

1723 | bool isPascal() const { return StringLiteralBits.IsPascal; } |

1724 | |

1725 | bool containsNonAscii() const { |

1726 | for (auto c : getString()) |

1727 | if (!isASCII(c)) |

1728 | return true; |

1729 | return false; |

1730 | } |

1731 | |

1732 | bool containsNonAsciiOrNull() const { |

1733 | for (auto c : getString()) |

1734 | if (!isASCII(c) || !c) |

1735 | return true; |

1736 | return false; |

1737 | } |

1738 | |

1739 | /// getNumConcatenated - Get the number of string literal tokens that were |

1740 | /// concatenated in translation phase #6 to form this string literal. |

1741 | unsigned getNumConcatenated() const { |

1742 | return StringLiteralBits.NumConcatenated; |

1743 | } |

1744 | |

1745 | /// Get one of the string literal token. |

1746 | SourceLocation getStrTokenLoc(unsigned TokNum) const { |

1747 | assert(TokNum < getNumConcatenated() && "Invalid tok number"); |

1748 | return getTrailingObjects<SourceLocation>()[TokNum]; |

1749 | } |

1750 | |

1751 | /// getLocationOfByte - Return a source location that points to the specified |

1752 | /// byte of this string literal. |

1753 | /// |

1754 | /// Strings are amazingly complex. They can be formed from multiple tokens |

1755 | /// and can have escape sequences in them in addition to the usual trigraph |

1756 | /// and escaped newline business. This routine handles this complexity. |

1757 | /// |

1758 | SourceLocation |

1759 | getLocationOfByte(unsigned ByteNo, const SourceManager &SM, |

1760 | const LangOptions &Features, const TargetInfo &Target, |

1761 | unsigned *StartToken = nullptr, |

1762 | unsigned *StartTokenByteOffset = nullptr) const; |

1763 | |

1764 | typedef const SourceLocation *tokloc_iterator; |

1765 | |

1766 | tokloc_iterator tokloc_begin() const { |

1767 | return getTrailingObjects<SourceLocation>(); |

1768 | } |

1769 | |

1770 | tokloc_iterator tokloc_end() const { |

1771 | return getTrailingObjects<SourceLocation>() + getNumConcatenated(); |

1772 | } |

1773 | |

1774 | SourceLocation getBeginLoc() const LLVM_READONLY { return *tokloc_begin(); } |

1775 | SourceLocation getEndLoc() const LLVM_READONLY { return *(tokloc_end() - 1); } |

1776 | |

1777 | static bool classof(const Stmt *T) { |

1778 | return T->getStmtClass() == StringLiteralClass; |

1779 | } |

1780 | |

1781 | // Iterators |

1782 | child_range children() { |

1783 | return child_range(child_iterator(), child_iterator()); |

1784 | } |

1785 | const_child_range children() const { |

1786 | return const_child_range(const_child_iterator(), const_child_iterator()); |

1787 | } |

1788 | }; |

1789 | |

1790 | /// [C99 6.4.2.2] - A predefined identifier such as __func__. |

1791 | class PredefinedExpr final |

1792 | : public Expr, |

1793 | private llvm::TrailingObjects<PredefinedExpr, Stmt *> { |

1794 | friend class ASTStmtReader; |

1795 | friend TrailingObjects; |

1796 | |

1797 | // PredefinedExpr is optionally followed by a single trailing |

1798 | // "Stmt *" for the predefined identifier. It is present if and only if |

1799 | // hasFunctionName() is true and is always a "StringLiteral *". |

1800 | |

1801 | public: |

1802 | enum IdentKind { |

1803 | Func, |

1804 | Function, |

1805 | LFunction, // Same as Function, but as wide string. |

1806 | FuncDName, |

1807 | FuncSig, |

1808 | LFuncSig, // Same as FuncSig, but as as wide string |

1809 | PrettyFunction, |

1810 | /// The same as PrettyFunction, except that the |

1811 | /// 'virtual' keyword is omitted for virtual member functions. |

1812 | PrettyFunctionNoVirtual |

1813 | }; |

1814 | |

1815 | private: |

1816 | PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK, |

1817 | StringLiteral *SL); |

1818 | |

1819 | explicit PredefinedExpr(EmptyShell Empty, bool HasFunctionName); |

1820 | |

1821 | /// True if this PredefinedExpr has storage for a function name. |

1822 | bool hasFunctionName() const { return PredefinedExprBits.HasFunctionName; } |

1823 | |

1824 | void setFunctionName(StringLiteral *SL) { |

1825 | assert(hasFunctionName() && |

1826 | "This PredefinedExpr has no storage for a function name!"); |

1827 | *getTrailingObjects<Stmt *>() = SL; |

1828 | } |

1829 | |

1830 | public: |

1831 | /// Create a PredefinedExpr. |

1832 | static PredefinedExpr *Create(const ASTContext &Ctx, SourceLocation L, |

1833 | QualType FNTy, IdentKind IK, StringLiteral *SL); |

1834 | |

1835 | /// Create an empty PredefinedExpr. |

1836 | static PredefinedExpr *CreateEmpty(const ASTContext &Ctx, |

1837 | bool HasFunctionName); |

1838 | |

1839 | IdentKind getIdentKind() const { |

1840 | return static_cast<IdentKind>(PredefinedExprBits.Kind); |

1841 | } |

1842 | |

1843 | SourceLocation getLocation() const { return PredefinedExprBits.Loc; } |

1844 | void setLocation(SourceLocation L) { PredefinedExprBits.Loc = L; } |

1845 | |

1846 | StringLiteral *getFunctionName() { |

1847 | return hasFunctionName() |

1848 | ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>()) |

1849 | : nullptr; |

1850 | } |

1851 | |

1852 | const StringLiteral *getFunctionName() const { |

1853 | return hasFunctionName() |

1854 | ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>()) |

1855 | : nullptr; |

1856 | } |

1857 | |

1858 | static StringRef getIdentKindName(IdentKind IK); |

1859 | static std::string ComputeName(IdentKind IK, const Decl *CurrentDecl); |

1860 | |

1861 | SourceLocation getBeginLoc() const { return getLocation(); } |

1862 | SourceLocation getEndLoc() const { return getLocation(); } |

1863 | |

1864 | static bool classof(const Stmt *T) { |

1865 | return T->getStmtClass() == PredefinedExprClass; |

1866 | } |

1867 | |

1868 | // Iterators |

1869 | child_range children() { |

1870 | return child_range(getTrailingObjects<Stmt *>(), |

1871 | getTrailingObjects<Stmt *>() + hasFunctionName()); |

1872 | } |

1873 | }; |

1874 | |

1875 | /// ParenExpr - This represents a parethesized expression, e.g. "(1)". This |

1876 | /// AST node is only formed if full location information is requested. |

1877 | class ParenExpr : public Expr { |

1878 | SourceLocation L, R; |

1879 | Stmt *Val; |

1880 | public: |

1881 | ParenExpr(SourceLocation l, SourceLocation r, Expr *val) |

1882 | : Expr(ParenExprClass, val->getType(), |

1883 | val->getValueKind(), val->getObjectKind(), |

1884 | val->isTypeDependent(), val->isValueDependent(), |

1885 | val->isInstantiationDependent(), |

1886 | val->containsUnexpandedParameterPack()), |

1887 | L(l), R(r), Val(val) {} |

1888 | |

1889 | /// Construct an empty parenthesized expression. |

1890 | explicit ParenExpr(EmptyShell Empty) |

1891 | : Expr(ParenExprClass, Empty) { } |

1892 | |

1893 | const Expr *getSubExpr() const { return cast<Expr>(Val); } |

1894 | Expr *getSubExpr() { return cast<Expr>(Val); } |

1895 | void setSubExpr(Expr *E) { Val = E; } |

1896 | |

1897 | SourceLocation getBeginLoc() const LLVM_READONLY { return L; } |

1898 | SourceLocation getEndLoc() const LLVM_READONLY { return R; } |

1899 | |

1900 | /// Get the location of the left parentheses '('. |

1901 | SourceLocation getLParen() const { return L; } |

1902 | void setLParen(SourceLocation Loc) { L = Loc; } |

1903 | |

1904 | /// Get the location of the right parentheses ')'. |

1905 | SourceLocation getRParen() const { return R; } |

1906 | void setRParen(SourceLocation Loc) { R = Loc; } |

1907 | |

1908 | static bool classof(const Stmt *T) { |

1909 | return T->getStmtClass() == ParenExprClass; |

1910 | } |

1911 | |

1912 | // Iterators |

1913 | child_range children() { return child_range(&Val, &Val+1); } |

1914 | const_child_range children() const { |

1915 | return const_child_range(&Val, &Val + 1); |

1916 | } |

1917 | }; |

1918 | |

1919 | /// UnaryOperator - This represents the unary-expression's (except sizeof and |

1920 | /// alignof), the postinc/postdec operators from postfix-expression, and various |

1921 | /// extensions. |

1922 | /// |

1923 | /// Notes on various nodes: |

1924 | /// |

1925 | /// Real/Imag - These return the real/imag part of a complex operand. If |

1926 | /// applied to a non-complex value, the former returns its operand and the |

1927 | /// later returns zero in the type of the operand. |

1928 | /// |

1929 | class UnaryOperator : public Expr { |

1930 | Stmt *Val; |

1931 | |

1932 | public: |

1933 | typedef UnaryOperatorKind Opcode; |

1934 | |

1935 | UnaryOperator(Expr *input, Opcode opc, QualType type, ExprValueKind VK, |

1936 | ExprObjectKind OK, SourceLocation l, bool CanOverflow) |

1937 | : Expr(UnaryOperatorClass, type, VK, OK, |

1938 | input->isTypeDependent() || type->isDependentType(), |

1939 | input->isValueDependent(), |

1940 | (input->isInstantiationDependent() || |

1941 | type->isInstantiationDependentType()), |

1942 | input->containsUnexpandedParameterPack()), |

1943 | Val(input) { |

1944 | UnaryOperatorBits.Opc = opc; |

1945 | UnaryOperatorBits.CanOverflow = CanOverflow; |

1946 | UnaryOperatorBits.Loc = l; |

1947 | } |

1948 | |

1949 | /// Build an empty unary operator. |

1950 | explicit UnaryOperator(EmptyShell Empty) : Expr(UnaryOperatorClass, Empty) { |

1951 | UnaryOperatorBits.Opc = UO_AddrOf; |

1952 | } |

1953 | |

1954 | Opcode getOpcode() const { |

1955 | return static_cast<Opcode>(UnaryOperatorBits.Opc); |

1956 | } |

1957 | void setOpcode(Opcode Opc) { UnaryOperatorBits.Opc = Opc; } |

1958 | |

1959 | Expr *getSubExpr() const { return cast<Expr>(Val); } |

1960 | void setSubExpr(Expr *E) { Val = E; } |

1961 | |

1962 | /// getOperatorLoc - Return the location of the operator. |

1963 | SourceLocation getOperatorLoc() const { return UnaryOperatorBits.Loc; } |

1964 | void setOperatorLoc(SourceLocation L) { UnaryOperatorBits.Loc = L; } |

1965 | |

1966 | /// Returns true if the unary operator can cause an overflow. For instance, |

1967 | /// signed int i = INT_MAX; i++; |

1968 | /// signed char c = CHAR_MAX; c++; |

1969 | /// Due to integer promotions, c++ is promoted to an int before the postfix |

1970 | /// increment, and the result is an int that cannot overflow. However, i++ |

1971 | /// can overflow. |

1972 | bool canOverflow() const { return UnaryOperatorBits.CanOverflow; } |

1973 | void setCanOverflow(bool C) { UnaryOperatorBits.CanOverflow = C; } |

1974 | |

1975 | /// isPostfix - Return true if this is a postfix operation, like x++. |

1976 | static bool isPostfix(Opcode Op) { |

1977 | return Op == UO_PostInc || Op == UO_PostDec; |

1978 | } |

1979 | |

1980 | /// isPrefix - Return true if this is a prefix operation, like --x. |

1981 | static bool isPrefix(Opcode Op) { |

1982 | return Op == UO_PreInc || Op == UO_PreDec; |

1983 | } |

1984 | |

1985 | bool isPrefix() const { return isPrefix(getOpcode()); } |

1986 | bool isPostfix() const { return isPostfix(getOpcode()); } |

1987 | |

1988 | static bool isIncrementOp(Opcode Op) { |

1989 | return Op == UO_PreInc || Op == UO_PostInc; |

1990 | } |

1991 | bool isIncrementOp() const { |

1992 | return isIncrementOp(getOpcode()); |

1993 | } |

1994 | |

1995 | static bool isDecrementOp(Opcode Op) { |

1996 | return Op == UO_PreDec || Op == UO_PostDec; |

1997 | } |

1998 | bool isDecrementOp() const { |

1999 | return isDecrementOp(getOpcode()); |

2000 | } |

2001 | |

2002 | static bool isIncrementDecrementOp(Opcode Op) { return Op <= UO_PreDec; } |

2003 | bool isIncrementDecrementOp() const { |

2004 | return isIncrementDecrementOp(getOpcode()); |

2005 | } |

2006 | |

2007 | static bool isArithmeticOp(Opcode Op) { |

2008 | return Op >= UO_Plus && Op <= UO_LNot; |

2009 | } |

2010 | bool isArithmeticOp() const { return isArithmeticOp(getOpcode()); } |

2011 | |

2012 | /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it |

2013 | /// corresponds to, e.g. "sizeof" or "[pre]++" |

2014 | static StringRef getOpcodeStr(Opcode Op); |

2015 | |

2016 | /// Retrieve the unary opcode that corresponds to the given |

2017 | /// overloaded operator. |

2018 | static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix); |

2019 | |

2020 | /// Retrieve the overloaded operator kind that corresponds to |

2021 | /// the given unary opcode. |

2022 | static OverloadedOperatorKind getOverloadedOperator(Opcode Opc); |

2023 | |

2024 | SourceLocation getBeginLoc() const LLVM_READONLY { |

2025 | return isPostfix() ? Val->getBeginLoc() : getOperatorLoc(); |

2026 | } |

2027 | SourceLocation getEndLoc() const LLVM_READONLY { |

2028 | return isPostfix() ? getOperatorLoc() : Val->getEndLoc(); |

2029 | } |

2030 | SourceLocation getExprLoc() const { return getOperatorLoc(); } |

2031 | |

2032 | static bool classof(const Stmt *T) { |

2033 | return T->getStmtClass() == UnaryOperatorClass; |

2034 | } |

2035 | |

2036 | // Iterators |

2037 | child_range children() { return child_range(&Val, &Val+1); } |

2038 | const_child_range children() const { |

2039 | return const_child_range(&Val, &Val + 1); |

2040 | } |

2041 | }; |

2042 | |

2043 | /// Helper class for OffsetOfExpr. |

2044 | |

2045 | // __builtin_offsetof(type, identifier(.identifier|[expr])*) |

2046 | class OffsetOfNode { |

2047 | public: |

2048 | /// The kind of offsetof node we have. |

2049 | enum Kind { |

2050 | /// An index into an array. |

2051 | Array = 0x00, |

2052 | /// A field. |

2053 | Field = 0x01, |

2054 | /// A field in a dependent type, known only by its name. |

2055 | Identifier = 0x02, |

2056 | /// An implicit indirection through a C++ base class, when the |

2057 | /// field found is in a base class. |

2058 | Base = 0x03 |

2059 | }; |

2060 | |

2061 | private: |

2062 | enum { MaskBits = 2, Mask = 0x03 }; |

2063 | |

2064 | /// The source range that covers this part of the designator. |

2065 | SourceRange Range; |

2066 | |

2067 | /// The data describing the designator, which comes in three |

2068 | /// different forms, depending on the lower two bits. |

2069 | /// - An unsigned index into the array of Expr*'s stored after this node |

2070 | /// in memory, for [constant-expression] designators. |

2071 | /// - A FieldDecl*, for references to a known field. |

2072 | /// - An IdentifierInfo*, for references to a field with a given name |

2073 | /// when the class type is dependent. |

2074 | /// - A CXXBaseSpecifier*, for references that look at a field in a |

2075 | /// base class. |

2076 | uintptr_t Data; |

2077 | |

2078 | public: |

2079 | /// Create an offsetof node that refers to an array element. |

2080 | OffsetOfNode(SourceLocation LBracketLoc, unsigned Index, |

2081 | SourceLocation RBracketLoc) |

2082 | : Range(LBracketLoc, RBracketLoc), Data((Index << 2) | Array) {} |

2083 | |

2084 | /// Create an offsetof node that refers to a field. |

2085 | OffsetOfNode(SourceLocation DotLoc, FieldDecl *Field, SourceLocation NameLoc) |

2086 | : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc), |

2087 | Data(reinterpret_cast<uintptr_t>(Field) | OffsetOfNode::Field) {} |

2088 | |

2089 | /// Create an offsetof node that refers to an identifier. |

2090 | OffsetOfNode(SourceLocation DotLoc, IdentifierInfo *Name, |

2091 | SourceLocation NameLoc) |

2092 | : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc), |

2093 | Data(reinterpret_cast<uintptr_t>(Name) | Identifier) {} |

2094 | |

2095 | /// Create an offsetof node that refers into a C++ base class. |

2096 | explicit OffsetOfNode(const CXXBaseSpecifier *Base) |

2097 | : Range(), Data(reinterpret_cast<uintptr_t>(Base) | OffsetOfNode::Base) {} |

2098 | |

2099 | /// Determine what kind of offsetof node this is. |

2100 | Kind getKind() const { return static_cast<Kind>(Data & Mask); } |

2101 | |

2102 | /// For an array element node, returns the index into the array |

2103 | /// of expressions. |

2104 | unsigned getArrayExprIndex() const { |

2105 | assert(getKind() == Array); |

2106 | return Data >> 2; |

2107 | } |

2108 | |

2109 | /// For a field offsetof node, returns the field. |

2110 | FieldDecl *getField() const { |

2111 | assert(getKind() == Field); |

2112 | return reinterpret_cast<FieldDecl *>(Data & ~(uintptr_t)Mask); |

2113 | } |

2114 | |

2115 | /// For a field or identifier offsetof node, returns the name of |

2116 | /// the field. |

2117 | IdentifierInfo *getFieldName() const; |

2118 | |

2119 | /// For a base class node, returns the base specifier. |

2120 | CXXBaseSpecifier *getBase() const { |

2121 | assert(getKind() == Base); |

2122 | return reinterpret_cast<CXXBaseSpecifier *>(Data & ~(uintptr_t)Mask); |

2123 | } |

2124 | |

2125 | /// Retrieve the source range that covers this offsetof node. |

2126 | /// |

2127 | /// For an array element node, the source range contains the locations of |

2128 | /// the square brackets. For a field or identifier node, the source range |

2129 | /// contains the location of the period (if there is one) and the |

2130 | /// identifier. |

2131 | SourceRange getSourceRange() const LLVM_READONLY { return Range; } |

2132 | SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); } |

2133 | SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); } |

2134 | }; |

2135 | |

2136 | /// OffsetOfExpr - [C99 7.17] - This represents an expression of the form |

2137 | /// offsetof(record-type, member-designator). For example, given: |

2138 | /// @code |

2139 | /// struct S { |

2140 | /// float f; |

2141 | /// double d; |

2142 | /// }; |

2143 | /// struct T { |

2144 | /// int i; |

2145 | /// struct S s[10]; |

2146 | /// }; |

2147 | /// @endcode |

2148 | /// we can represent and evaluate the expression @c offsetof(struct T, s[2].d). |

2149 | |

2150 | class OffsetOfExpr final |

2151 | : public Expr, |

2152 | private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> { |

2153 | SourceLocation OperatorLoc, RParenLoc; |

2154 | // Base type; |

2155 | TypeSourceInfo *TSInfo; |

2156 | // Number of sub-components (i.e. instances of OffsetOfNode). |

2157 | unsigned NumComps; |

2158 | // Number of sub-expressions (i.e. array subscript expressions). |

2159 | unsigned NumExprs; |

2160 | |

2161 | size_t numTrailingObjects(OverloadToken<OffsetOfNode>) const { |

2162 | return NumComps; |

2163 | } |

2164 | |

2165 | OffsetOfExpr(const ASTContext &C, QualType type, |

2166 | SourceLocation OperatorLoc, TypeSourceInfo *tsi, |

2167 | ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs, |

2168 | SourceLocation RParenLoc); |

2169 | |

2170 | explicit OffsetOfExpr(unsigned numComps, unsigned numExprs) |

2171 | : Expr(OffsetOfExprClass, EmptyShell()), |

2172 | TSInfo(nullptr), NumComps(numComps), NumExprs(numExprs) {} |

2173 | |

2174 | public: |

2175 | |

2176 | static OffsetOfExpr *Create(const ASTContext &C, QualType type, |

2177 | SourceLocation OperatorLoc, TypeSourceInfo *tsi, |

2178 | ArrayRef<OffsetOfNode> comps, |

2179 | ArrayRef<Expr*> exprs, SourceLocation RParenLoc); |

2180 | |

2181 | static OffsetOfExpr *CreateEmpty(const ASTContext &C, |

2182 | unsigned NumComps, unsigned NumExprs); |

2183 | |

2184 | /// getOperatorLoc - Return the location of the operator. |

2185 | SourceLocation getOperatorLoc() const { return OperatorLoc; } |

2186 | void setOperatorLoc(SourceLocation L) { OperatorLoc = L; } |

2187 | |

2188 | /// Return the location of the right parentheses. |

2189 | SourceLocation getRParenLoc() const { return RParenLoc; } |

2190 | void setRParenLoc(SourceLocation R) { RParenLoc = R; } |

2191 | |

2192 | TypeSourceInfo *getTypeSourceInfo() const { |

2193 | return TSInfo; |

2194 | } |

2195 | void setTypeSourceInfo(TypeSourceInfo *tsi) { |

2196 | TSInfo = tsi; |

2197 | } |

2198 | |

2199 | const OffsetOfNode &getComponent(unsigned Idx) const { |

2200 | assert(Idx < NumComps && "Subscript out of range"); |

2201 | return getTrailingObjects<OffsetOfNode>()[Idx]; |

2202 | } |

2203 | |

2204 | void setComponent(unsigned Idx, OffsetOfNode ON) { |

2205 | assert(Idx < NumComps && "Subscript out of range"); |

2206 | getTrailingObjects<OffsetOfNode>()[Idx] = ON; |

2207 | } |

2208 | |

2209 | unsigned getNumComponents() const { |

2210 | return NumComps; |

2211 | } |

2212 | |

2213 | Expr* getIndexExpr(unsigned Idx) { |

2214 | assert(Idx < NumExprs && "Subscript out of range"); |

2215 | return getTrailingObjects<Expr *>()[Idx]; |

2216 | } |

2217 | |

2218 | const Expr *getIndexExpr(unsigned Idx) const { |

2219 | assert(Idx < NumExprs && "Subscript out of range"); |

2220 | return getTrailingObjects<Expr *>()[Idx]; |

2221 | } |

2222 | |

2223 | void setIndexExpr(unsigned Idx, Expr* E) { |

2224 | assert(Idx < NumComps && "Subscript out of range"); |

2225 | getTrailingObjects<Expr *>()[Idx] = E; |

2226 | } |

2227 | |

2228 | unsigned getNumExpressions() const { |

2229 | return NumExprs; |

2230 | } |

2231 | |

2232 | SourceLocation getBeginLoc() const LLVM_READONLY { return OperatorLoc; } |

2233 | SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; } |

2234 | |

2235 | static bool classof(const Stmt *T) { |

2236 | return T->getStmtClass() == OffsetOfExprClass; |

2237 | } |

2238 | |

2239 | // Iterators |

2240 | child_range children() { |

2241 | Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>()); |

2242 | return child_range(begin, begin + NumExprs); |

2243 | } |

2244 | const_child_range children() const { |

2245 | Stmt *const *begin = |

2246 | reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>()); |

2247 | return const_child_range(begin, begin + NumExprs); |

2248 | } |

2249 | friend TrailingObjects; |

2250 | }; |

2251 | |

2252 | /// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) |

2253 | /// expression operand. Used for sizeof/alignof (C99 6.5.3.4) and |

2254 | /// vec_step (OpenCL 1.1 6.11.12). |

2255 | class UnaryExprOrTypeTraitExpr : public Expr { |

2256 | union { |

2257 | TypeSourceInfo *Ty; |

2258 | Stmt *Ex; |

2259 | } Argument; |

2260 | SourceLocation OpLoc, RParenLoc; |

2261 | |

2262 | public: |

2263 | UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo, |

2264 | QualType resultType, SourceLocation op, |

2265 | SourceLocation rp) : |

2266 | Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary, |

2267 | false, // Never type-dependent (C++ [temp.dep.expr]p3). |

2268 | // Value-dependent if the argument is type-dependent. |

2269 | TInfo->getType()->isDependentType(), |

2270 | TInfo->getType()->isInstantiationDependentType(), |

2271 | TInfo->getType()->containsUnexpandedParameterPack()), |

2272 | OpLoc(op), RParenLoc(rp) { |

2273 | UnaryExprOrTypeTraitExprBits.Kind = ExprKind; |

2274 | UnaryExprOrTypeTraitExprBits.IsType = true; |

2275 | Argument.Ty = TInfo; |

2276 | } |

2277 | |

2278 | UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, Expr *E, |

2279 | QualType resultType, SourceLocation op, |

2280 | SourceLocation rp); |

2281 | |

2282 | /// Construct an empty sizeof/alignof expression. |

2283 | explicit UnaryExprOrTypeTraitExpr(EmptyShell Empty) |

2284 | : Expr(UnaryExprOrTypeTraitExprClass, Empty) { } |

2285 | |

2286 | UnaryExprOrTypeTrait getKind() const { |

2287 | return static_cast<UnaryExprOrTypeTrait>(UnaryExprOrTypeTraitExprBits.Kind); |

2288 | } |

2289 | void setKind(UnaryExprOrTypeTrait K) { UnaryExprOrTypeTraitExprBits.Kind = K;} |

2290 | |

2291 | bool isArgumentType() const { return UnaryExprOrTypeTraitExprBits.IsType; } |

2292 | QualType getArgumentType() const { |

2293 | return getArgumentTypeInfo()->getType(); |

2294 | } |

2295 | TypeSourceInfo *getArgumentTypeInfo() const { |

2296 | assert(isArgumentType() && "calling getArgumentType() when arg is expr"); |

2297 | return Argument.Ty; |

2298 | } |

2299 | Expr *getArgumentExpr() { |

2300 | assert(!isArgumentType() && "calling getArgumentExpr() when arg is type"); |

2301 | return static_cast<Expr*>(Argument.Ex); |

2302 | } |

2303 | const Expr *getArgumentExpr() const { |

2304 | return const_cast<UnaryExprOrTypeTraitExpr*>(this)->getArgumentExpr(); |

2305 | } |

2306 | |

2307 | void setArgument(Expr *E) { |

2308 | Argument.Ex = E; |

2309 | UnaryExprOrTypeTraitExprBits.IsType = false; |

2310 | } |

2311 | void setArgument(TypeSourceInfo *TInfo) { |

2312 | Argument.Ty = TInfo; |

2313 | UnaryExprOrTypeTraitExprBits.IsType = true; |

2314 | } |

2315 | |

2316 | /// Gets the argument type, or the type of the argument expression, whichever |

2317 | /// is appropriate. |

2318 | QualType getTypeOfArgument() const { |

2319 | return isArgumentType() ? getArgumentType() : getArgumentExpr()->getType(); |

2320 | } |

2321 | |

2322 | SourceLocation getOperatorLoc() const { return OpLoc; } |

2323 | void setOperatorLoc(SourceLocation L) { OpLoc = L; } |

2324 | |

2325 | SourceLocation getRParenLoc() const { return RParenLoc; } |

2326 | void setRParenLoc(SourceLocation L) { RParenLoc = L; } |

2327 | |

2328 | SourceLocation getBeginLoc() const LLVM_READONLY { return OpLoc; } |

2329 | SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; } |

2330 | |

2331 | static bool classof(const Stmt *T) { |

2332 | return T->getStmtClass() == UnaryExprOrTypeTraitExprClass; |

2333 | } |

2334 | |

2335 | // Iterators |

2336 | child_range children(); |

2337 | const_child_range children() const; |

2338 | }; |

2339 | |

2340 | //===----------------------------------------------------------------------===// |

2341 | // Postfix Operators. |

2342 | //===----------------------------------------------------------------------===// |

2343 | |

2344 | /// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting. |

2345 | class ArraySubscriptExpr : public Expr { |

2346 | enum { LHS, RHS, END_EXPR }; |

2347 | Stmt *SubExprs[END_EXPR]; |

2348 | |

2349 | bool lhsIsBase() const { return getRHS()->getType()->isIntegerType(); } |

2350 | |

2351 | public: |

2352 | ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t, |

2353 | ExprValueKind VK, ExprObjectKind OK, |

2354 | SourceLocation rbracketloc) |

2355 | : Expr(ArraySubscriptExprClass, t, VK, OK, |

2356 | lhs->isTypeDependent() || rhs->isTypeDependent(), |

2357 | lhs->isValueDependent() || rhs->isValueDependent(), |

2358 | (lhs->isInstantiationDependent() || |

2359 | rhs->isInstantiationDependent()), |

2360 | (lhs->containsUnexpandedParameterPack() || |

2361 | rhs->containsUnexpandedParameterPack())) { |

2362 | SubExprs[LHS] = lhs; |

2363 | SubExprs[RHS] = rhs; |

2364 | ArraySubscriptExprBits.RBracketLoc = rbracketloc; |

2365 | } |

2366 | |

2367 | /// Create an empty array subscript expression. |

2368 | explicit ArraySubscriptExpr(EmptyShell Shell) |

2369 | : Expr(ArraySubscriptExprClass, Shell) { } |

2370 | |

2371 | /// An array access can be written A[4] or 4[A] (both are equivalent). |

2372 | /// - getBase() and getIdx() always present the normalized view: A[4]. |

2373 | /// In this case getBase() returns "A" and getIdx() returns "4". |

2374 | /// - getLHS() and getRHS() present the syntactic view. e.g. for |

2375 | /// 4[A] getLHS() returns "4". |

2376 | /// Note: Because vector element access is also written A[4] we must |

2377 | /// predicate the format conversion in getBase and getIdx only on the |

2378 | /// the type of the RHS, as it is possible for the LHS to be a vector of |

2379 | /// integer type |

2380 | Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); } |

2381 | const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); } |

2382 | void setLHS(Expr *E) { SubExprs[LHS] = E; } |

2383 | |

2384 | Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); } |

2385 | const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); } |

2386 | void setRHS(Expr *E) { SubExprs[RHS] = E; } |

2387 | |

2388 | Expr *getBase() { return lhsIsBase() ? getLHS() : getRHS(); } |

2389 | const Expr *getBase() const { return lhsIsBase() ? getLHS() : getRHS(); } |

2390 | |

2391 | Expr *getIdx() { return lhsIsBase() ? getRHS() : getLHS(); } |

2392 | const Expr *getIdx() const { return lhsIsBase() ? getRHS() : getLHS(); } |

2393 | |

2394 | SourceLocation getBeginLoc() const LLVM_READONLY { |

2395 | return getLHS()->getBeginLoc(); |

2396 | } |

2397 | SourceLocation getEndLoc() const { return getRBracketLoc(); } |

2398 | |

2399 | SourceLocation getRBracketLoc() const { |

2400 | return ArraySubscriptExprBits.RBracketLoc; |

2401 | } |

2402 | void setRBracketLoc(SourceLocation L) { |

2403 | ArraySubscriptExprBits.RBracketLoc = L; |

2404 | } |

2405 | |

2406 | SourceLocation getExprLoc() const LLVM_READONLY { |

2407 | return getBase()->getExprLoc(); |

2408 | } |

2409 | |

2410 | static bool classof(const Stmt *T) { |

2411 | return T->getStmtClass() == ArraySubscriptExprClass; |

2412 | } |

2413 | |

2414 | // Iterators |

2415 | child_range children() { |

2416 | return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR); |

2417 | } |

2418 | const_child_range children() const { |

2419 | return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR); |

2420 | } |

2421 | }; |

2422 | |

2423 | /// CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]). |

2424 | /// CallExpr itself represents a normal function call, e.g., "f(x, 2)", |

2425 | /// while its subclasses may represent alternative syntax that (semantically) |

2426 | /// results in a function call. For example, CXXOperatorCallExpr is |

2427 | /// a subclass for overloaded operator calls that use operator syntax, e.g., |

2428 | /// "str1 + str2" to resolve to a function call. |

2429 | class CallExpr : public Expr { |

2430 | enum { FN = 0, PREARGS_START = 1 }; |

2431 | |

2432 | /// The number of arguments in the call expression. |

2433 | unsigned NumArgs; |

2434 | |

2435 | /// The location of the right parenthese. This has a different meaning for |

2436 | /// the derived classes of CallExpr. |

2437 | SourceLocation RParenLoc; |

2438 | |

2439 | void updateDependenciesFromArg(Expr *Arg); |

2440 | |

2441 | // CallExpr store some data in trailing objects. However since CallExpr |

2442 | // is used a base of other expression classes we cannot use |

2443 | // llvm::TrailingObjects. Instead we manually perform the pointer arithmetic |

2444 | // and casts. |

2445 | // |

2446 | // The trailing objects are in order: |

2447 | // |

2448 | // * A single "Stmt *" for the callee expression. |

2449 | // |

2450 | // * An array of getNumPreArgs() "Stmt *" for the pre-argument expressions. |

2451 | // |

2452 | // * An array of getNumArgs() "Stmt *" for the argument expressions. |

2453 | // |

2454 | // Note that we store the offset in bytes from the this pointer to the start |

2455 | // of the trailing objects. It would be perfectly possible to compute it |

2456 | // based on the dynamic kind of the CallExpr. However 1.) we have plenty of |

2457 | // space in the bit-fields of Stmt. 2.) It was benchmarked to be faster to |

2458 | // compute this once and then load the offset from the bit-fields of Stmt, |

2459 | // instead of re-computing the offset each time the trailing objects are |

2460 | // accessed. |

2461 | |

2462 | /// Return a pointer to the start of the trailing array of "Stmt *". |

2463 | Stmt **getTrailingStmts() { |

2464 | return reinterpret_cast<Stmt **>(reinterpret_cast<char *>(this) + |

2465 | CallExprBits.OffsetToTrailingObjects); |

2466 | } |

2467 | Stmt *const *getTrailingStmts() const { |

2468 | return const_cast<CallExpr *>(this)->getTrailingStmts(); |

2469 | } |

2470 | |

2471 | /// Map a statement class to the appropriate offset in bytes from the |

2472 | /// this pointer to the trailing objects. |

2473 | static unsigned offsetToTrailingObjects(StmtClass SC); |

2474 | |

2475 | public: |

2476 | enum class ADLCallKind : bool { NotADL, UsesADL }; |

2477 | static constexpr ADLCallKind NotADL = ADLCallKind::NotADL; |

2478 | static constexpr ADLCallKind UsesADL = ADLCallKind::UsesADL; |

2479 | |

2480 | protected: |

2481 | /// Build a call expression, assuming that appropriate storage has been |

2482 | /// allocated for the trailing objects. |

2483 | CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs, |

2484 | ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK, |

2485 | SourceLocation RParenLoc, unsigned MinNumArgs, ADLCallKind UsesADL); |

2486 | |

2487 | /// Build an empty call expression, for deserialization. |

2488 | CallExpr(StmtClass SC, unsigned NumPreArgs, unsigned NumArgs, |

2489 | EmptyShell Empty); |

2490 | |

2491 | /// Return the size in bytes needed for the trailing objects. |

2492 | /// Used by the derived classes to allocate the right amount of storage. |

2493 | static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs) { |

2494 | return (1 + NumPreArgs + NumArgs) * sizeof(Stmt *); |

2495 | } |

2496 | |

2497 | Stmt *getPreArg(unsigned I) { |

2498 | assert(I < getNumPreArgs() && "Prearg access out of range!"); |

2499 | return getTrailingStmts()[PREARGS_START + I]; |

2500 | } |

2501 | const Stmt *getPreArg(unsigned I) const { |

2502 | assert(I < getNumPreArgs() && "Prearg access out of range!"); |

2503 | return getTrailingStmts()[PREARGS_START + I]; |

2504 | } |

2505 | void setPreArg(unsigned I, Stmt *PreArg) { |

2506 | assert(I < getNumPreArgs() && "Prearg access out of range!"); |

2507 | getTrailingStmts()[PREARGS_START + I] = PreArg; |

2508 | } |

2509 | |

2510 | unsigned getNumPreArgs() const { return CallExprBits.NumPreArgs; } |

2511 | |

2512 | public: |

2513 | /// Create a call expression. Fn is the callee expression, Args is the |

2514 | /// argument array, Ty is the type of the call expression (which is *not* |

2515 | /// the return type in general), VK is the value kind of the call expression |

2516 | /// (lvalue, rvalue, ...), and RParenLoc is the location of the right |

2517 | /// parenthese in the call expression. MinNumArgs specifies the minimum |

2518 | /// number of arguments. The actual number of arguments will be the greater |

2519 | /// of Args.size() and MinNumArgs. This is used in a few places to allocate |

2520 | /// enough storage for the default arguments. UsesADL specifies whether the |

2521 | /// callee was found through argument-dependent lookup. |

2522 | /// |

2523 | /// Note that you can use CreateTemporary if you need a temporary call |

2524 | /// expression on the stack. |

2525 | static CallExpr *Create(const ASTContext &Ctx, Expr *Fn, |

2526 | ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK, |

2527 | SourceLocation RParenLoc, unsigned MinNumArgs = 0, |

2528 | ADLCallKind UsesADL = NotADL); |

2529 | |

2530 | /// Create a temporary call expression with no arguments in the memory |

2531 | /// pointed to by Mem. Mem must points to at least sizeof(CallExpr) |

2532 | /// + sizeof(Stmt *) bytes of storage, aligned to alignof(CallExpr): |

2533 | /// |

2534 | /// \code{.cpp} |

2535 | /// llvm::AlignedCharArray<alignof(CallExpr), |

2536 | /// sizeof(CallExpr) + sizeof(Stmt *)> Buffer; |

2537 | /// CallExpr *TheCall = CallExpr::CreateTemporary(Buffer.buffer, etc); |

2538 | /// \endcode |

2539 | static CallExpr *CreateTemporary(void *Mem, Expr *Fn, QualType Ty, |

2540 | ExprValueKind VK, SourceLocation RParenLoc, |

2541 | ADLCallKind UsesADL = NotADL); |

2542 | |

2543 | /// Create an empty call expression, for deserialization. |

2544 | static CallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, |

2545 | EmptyShell Empty); |

2546 | |

2547 | Expr *getCallee() { return cast<Expr>(getTrailingStmts()[FN]); } |

2548 | const Expr *getCallee() const { return cast<Expr>(getTrailingStmts()[FN]); } |

2549 | void setCallee(Expr *F) { getTrailingStmts()[FN] = F; } |

2550 | |

2551 | ADLCallKind getADLCallKind() const { |

2552 | return static_cast<ADLCallKind>(CallExprBits.UsesADL); |

2553 | } |

2554 | void setADLCallKind(ADLCallKind V = UsesADL) { |

2555 | CallExprBits.UsesADL = static_cast<bool>(V); |

2556 | } |

2557 | bool usesADL() const { return getADLCallKind() == UsesADL; } |

2558 | |

2559 | Decl *getCalleeDecl() { return getCallee()->getReferencedDeclOfCallee(); } |

2560 | const Decl *getCalleeDecl() const { |

2561 | return getCallee()->getReferencedDeclOfCallee(); |

2562 | } |

2563 | |

2564 | /// If the callee is a FunctionDecl, return it. Otherwise return null. |

2565 | FunctionDecl *getDirectCallee() { |

2566 | return dyn_cast_or_null<FunctionDecl>(getCalleeDecl()); |

2567 | } |

2568 | const FunctionDecl *getDirectCallee() const { |

2569 | return dyn_cast_or_null<FunctionDecl>(getCalleeDecl()); |

2570 | } |

2571 | |

2572 | /// getNumArgs - Return the number of actual arguments to this call. |

2573 | unsigned getNumArgs() const { return NumArgs; } |

2574 | |

2575 | /// Retrieve the call arguments. |

2576 | Expr **getArgs() { |

2577 | return reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START + |

2578 | getNumPreArgs()); |

2579 | } |

2580 | const Expr *const *getArgs() const { |

2581 | return reinterpret_cast<const Expr *const *>( |

2582 | getTrailingStmts() + PREARGS_START + getNumPreArgs()); |

2583 | } |

2584 | |

2585 | /// getArg - Return the specified argument. |

2586 | Expr *getArg(unsigned Arg) { |

2587 | assert(Arg < getNumArgs() && "Arg access out of range!"); |

2588 | return getArgs()[Arg]; |

2589 | } |

2590 | const Expr *getArg(unsigned Arg) const { |

2591 | assert(Arg < getNumArgs() && "Arg access out of range!"); |

2592 | return getArgs()[Arg]; |

2593 | } |

2594 | |

2595 | /// setArg - Set the specified argument. |

2596 | void setArg(unsigned Arg, Expr *ArgExpr) { |

2597 | assert(Arg < getNumArgs() && "Arg access out of range!"); |

2598 | getArgs()[Arg] = ArgExpr; |

2599 | } |

2600 | |

2601 | /// Reduce the number of arguments in this call expression. This is used for |

2602 | /// example during error recovery to drop extra arguments. There is no way |

2603 | /// to perform the opposite because: 1.) We don't track how much storage |

2604 | /// we have for the argument array 2.) This would potentially require growing |

2605 | /// the argument array, something we cannot support since the arguments are |

2606 | /// stored in a trailing array. |

2607 | void shrinkNumArgs(unsigned NewNumArgs) { |

2608 | assert((NewNumArgs <= getNumArgs()) && |

2609 | "shrinkNumArgs cannot increase the number of arguments!"); |

2610 | NumArgs = NewNumArgs; |

2611 | } |

2612 | |

2613 | typedef ExprIterator arg_iterator; |

2614 | typedef ConstExprIterator const_arg_iterator; |

2615 | typedef llvm::iterator_range<arg_iterator> arg_range; |

2616 | typedef llvm::iterator_range<const_arg_iterator> const_arg_range; |

2617 | |

2618 | arg_range arguments() { return arg_range(arg_begin(), arg_end()); } |

2619 | const_arg_range arguments() const { |

2620 | return const_arg_range(arg_begin(), arg_end()); |

2621 | } |

2622 | |

2623 | arg_iterator arg_begin() { |

2624 | return getTrailingStmts() + PREARGS_START + getNumPreArgs(); |

2625 | } |

2626 | arg_iterator arg_end() { return arg_begin() + getNumArgs(); } |

2627 | |

2628 | const_arg_iterator arg_begin() const { |

2629 | return getTrailingStmts() + PREARGS_START + getNumPreArgs(); |

2630 | } |

2631 | const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); } |

2632 | |

2633 | /// This method provides fast access to all the subexpressions of |

2634 | /// a CallExpr without going through the slower virtual child_iterator |

2635 | /// interface. This provides efficient reverse iteration of the |

2636 | /// subexpressions. This is currently used for CFG construction. |

2637 | ArrayRef<Stmt *> getRawSubExprs() { |

2638 | return llvm::makeArrayRef(getTrailingStmts(), |

2639 | PREARGS_START + getNumPreArgs() + getNumArgs()); |

2640 | } |

2641 | |

2642 | /// getNumCommas - Return the number of commas that must have been present in |

2643 | /// this function call. |

2644 | unsigned getNumCommas() const { return getNumArgs() ? getNumArgs() - 1 : 0; } |

2645 | |

2646 | /// getBuiltinCallee - If this is a call to a builtin, return the builtin ID |

2647 | /// of the callee. If not, return 0. |

2648 | unsigned getBuiltinCallee() const; |

2649 | |

2650 | /// Returns \c true if this is a call to a builtin which does not |

2651 | /// evaluate side-effects within its arguments. |

2652 | bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const; |

2653 | |

2654 | /// getCallReturnType - Get the return type of the call expr. This is not |

2655 | /// always the type of the expr itself, if the return type is a reference |

2656 | /// type. |

2657 | QualType getCallReturnType(const ASTContext &Ctx) const; |

2658 | |

2659 | /// Returns the WarnUnusedResultAttr that is either declared on the called |

2660 | /// function, or its return type declaration. |

2661 | const Attr *getUnusedResultAttr(const ASTContext &Ctx) const; |

2662 | |

2663 | /// Returns true if this call expression should warn on unused results. |

2664 | bool hasUnusedResultAttr(const ASTContext &Ctx) const { |

2665 | return getUnusedResultAttr(Ctx) != nullptr; |

2666 | } |

2667 | |

2668 | SourceLocation getRParenLoc() const { return RParenLoc; } |

2669 | void setRParenLoc(SourceLocation L) { RParenLoc = L; } |

2670 | |

2671 | SourceLocation getBeginLoc() const LLVM_READONLY; |

2672 | SourceLocation getEndLoc() const LLVM_READONLY; |

2673 | |

2674 | /// Return true if this is a call to __assume() or __builtin_assume() with |

2675 | /// a non-value-dependent constant parameter evaluating as false. |

2676 | bool isBuiltinAssumeFalse(const ASTContext &Ctx) const; |

2677 | |

2678 | bool isCallToStdMove() const { |

2679 | const FunctionDecl *FD = getDirectCallee(); |

2680 | return getNumArgs() == 1 && FD && FD->isInStdNamespace() && |

2681 | FD->getIdentifier() && FD->getIdentifier()->isStr("move"); |

2682 | } |

2683 | |

2684 | static bool classof(const Stmt *T) { |

2685 | return T->getStmtClass() >= firstCallExprConstant && |

2686 | T->getStmtClass() <= lastCallExprConstant; |

2687 | } |

2688 | |

2689 | // Iterators |

2690 | child_range children() { |

2691 | return child_range(getTrailingStmts(), getTrailingStmts() + PREARGS_START + |

2692 | getNumPreArgs() + getNumArgs()); |

2693 | } |

2694 | |

2695 | const_child_range children() const { |

2696 | return const_child_range(getTrailingStmts(), |

2697 | getTrailingStmts() + PREARGS_START + |

2698 | getNumPreArgs() + getNumArgs()); |

2699 | } |

2700 | }; |

2701 | |

2702 | /// Extra data stored in some MemberExpr objects. |

2703 | struct MemberExprNameQualifier { |

2704 | /// The nested-name-specifier that qualifies the name, including |

2705 | /// source-location information. |

2706 | NestedNameSpecifierLoc QualifierLoc; |

2707 | |

2708 | /// The DeclAccessPair through which the MemberDecl was found due to |

2709 | /// name qualifiers. |

2710 | DeclAccessPair FoundDecl; |

2711 | }; |

2712 | |

2713 | /// MemberExpr - [C99 6.5.2.3] Structure and Union Members. X->F and X.F. |

2714 | /// |

2715 | class MemberExpr final |

2716 | : public Expr, |

2717 | private llvm::TrailingObjects<MemberExpr, MemberExprNameQualifier, |

2718 | ASTTemplateKWAndArgsInfo, |

2719 | TemplateArgumentLoc> { |

2720 | friend class ASTReader; |

2721 | friend class ASTStmtWriter; |

2722 | friend TrailingObjects; |

2723 | |

2724 | /// Base - the expression for the base pointer or structure references. In |

2725 | /// X.F, this is "X". |

2726 | Stmt *Base; |

2727 | |

2728 | /// MemberDecl - This is the decl being referenced by the field/member name. |

2729 | /// In X.F, this is the decl referenced by F. |

2730 | ValueDecl *MemberDecl; |

2731 | |

2732 | /// MemberDNLoc - Provides source/type location info for the |

2733 | /// declaration name embedded in MemberDecl. |

2734 | DeclarationNameLoc MemberDNLoc; |

2735 | |

2736 | /// MemberLoc - This is the location of the member name. |

2737 | SourceLocation MemberLoc; |

2738 | |

2739 | size_t numTrailingObjects(OverloadToken<MemberExprNameQualifier>) const { |

2740 | return hasQualifierOrFoundDecl(); |

2741 | } |

2742 | |

2743 | size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const { |

2744 | return hasTemplateKWAndArgsInfo(); |

2745 | } |

2746 | |

2747 | bool hasQualifierOrFoundDecl() const { |

2748 | return MemberExprBits.HasQualifierOrFoundDecl; |

2749 | } |

2750 | |

2751 | bool hasTemplateKWAndArgsInfo() const { |

2752 | return MemberExprBits.HasTemplateKWAndArgsInfo; |

2753 | } |

2754 | |

2755 | public: |

2756 | MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc, |

2757 | ValueDecl *memberdecl, const DeclarationNameInfo &NameInfo, |

2758 | QualType ty, ExprValueKind VK, ExprObjectKind OK) |

2759 | : Expr(MemberExprClass, ty, VK, OK, base->isTypeDependent(), |

2760 | base->isValueDependent(), base->isInstantiationDependent(), |

2761 | base->containsUnexpandedParameterPack()), |

2762 | Base(base), MemberDecl(memberdecl), MemberDNLoc(NameInfo.getInfo()), |

2763 | MemberLoc(NameInfo.getLoc()) { |

2764 | assert(memberdecl->getDeclName() == NameInfo.getName()); |

2765 | MemberExprBits.IsArrow = isarrow; |

2766 | MemberExprBits.HasQualifierOrFoundDecl = false; |

2767 | MemberExprBits.HasTemplateKWAndArgsInfo = false; |

2768 | MemberExprBits.HadMultipleCandidates = false; |

2769 | MemberExprBits.OperatorLoc = operatorloc; |

2770 | } |

2771 | |

2772 | // NOTE: this constructor should be used only when it is known that |

2773 | // the member name can not provide additional syntactic info |

2774 | // (i.e., source locations for C++ operator names or type source info |

2775 | // for constructors, destructors and conversion operators). |

2776 | MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc, |

2777 | ValueDecl *memberdecl, SourceLocation l, QualType ty, |

2778 | ExprValueKind VK, ExprObjectKind OK) |

2779 | : Expr(MemberExprClass, ty, VK, OK, base->isTypeDependent(), |

2780 | base->isValueDependent(), base->isInstantiationDependent(), |

2781 | base->containsUnexpandedParameterPack()), |

2782 | Base(base), MemberDecl(memberdecl), MemberDNLoc(), MemberLoc(l) { |

2783 | MemberExprBits.IsArrow = isarrow; |

2784 | MemberExprBits.HasQualifierOrFoundDecl = false; |

2785 | MemberExprBits.HasTemplateKWAndArgsInfo = false; |

2786 | MemberExprBits.HadMultipleCandidates = false; |

2787 | MemberExprBits.OperatorLoc = operatorloc; |

2788 | } |

2789 | |

2790 | static MemberExpr *Create(const ASTContext &C, Expr *base, bool isarrow, |

2791 | SourceLocation OperatorLoc, |

2792 | NestedNameSpecifierLoc QualifierLoc, |

2793 | SourceLocation TemplateKWLoc, ValueDecl *memberdecl, |

2794 | DeclAccessPair founddecl, |

2795 | DeclarationNameInfo MemberNameInfo, |

2796 | const TemplateArgumentListInfo *targs, QualType ty, |

2797 | ExprValueKind VK, ExprObjectKind OK); |

2798 | |

2799 | void setBase(Expr *E) { Base = E; } |

2800 | Expr *getBase() const { return cast<Expr>(Base); } |

2801 | |

2802 | /// Retrieve the member declaration to which this expression refers. |

2803 | /// |

2804 | /// The returned declaration will be a FieldDecl or (in C++) a VarDecl (for |

2805 | /// static data members), a CXXMethodDecl, or an EnumConstantDecl. |

2806 | ValueDecl *getMemberDecl() const { return MemberDecl; } |

2807 | void setMemberDecl(ValueDecl *D) { MemberDecl = D; } |

2808 | |

2809 | /// Retrieves the declaration found by lookup. |

2810 | DeclAccessPair getFoundDecl() const { |

2811 | if (!hasQualifierOrFoundDecl()) |

2812 | return DeclAccessPair::make(getMemberDecl(), |

2813 | getMemberDecl()->getAccess()); |

2814 | return getTrailingObjects<MemberExprNameQualifier>()->FoundDecl; |

2815 | } |

2816 | |

2817 | /// Determines whether this member expression actually had |

2818 | /// a C++ nested-name-specifier prior to the name of the member, e.g., |

2819 | /// x->Base::foo. |

2820 | bool hasQualifier() const { return getQualifier() != nullptr; } |

2821 | |

2822 | /// If the member name was qualified, retrieves the |

2823 | /// nested-name-specifier that precedes the member name, with source-location |

2824 | /// information. |

2825 | NestedNameSpecifierLoc getQualifierLoc() const { |

2826 | if (!hasQualifierOrFoundDecl()) |

2827 | return NestedNameSpecifierLoc(); |

2828 | return getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc; |

2829 | } |

2830 | |

2831 | /// If the member name was qualified, retrieves the |

2832 | /// nested-name-specifier that precedes the member name. Otherwise, returns |

2833 | /// NULL. |

2834 | NestedNameSpecifier *getQualifier() const { |

2835 | return getQualifierLoc().getNestedNameSpecifier(); |

2836 | } |

2837 | |

2838 | /// Retrieve the location of the template keyword preceding |

2839 | /// the member name, if any. |

2840 | SourceLocation getTemplateKeywordLoc() const { |

2841 | if (!hasTemplateKWAndArgsInfo()) |

2842 | return SourceLocation(); |

2843 | return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc; |

2844 | } |

2845 | |

2846 | /// Retrieve the location of the left angle bracket starting the |

2847 | /// explicit template argument list following the member name, if any. |

2848 | SourceLocation getLAngleLoc() const { |

2849 | if (!hasTemplateKWAndArgsInfo()) |

2850 | return SourceLocation(); |

2851 | return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc; |

2852 | } |

2853 | |

2854 | /// Retrieve the location of the right angle bracket ending the |

2855 | /// explicit template argument list following the member name, if any. |

2856 | SourceLocation getRAngleLoc() const { |

2857 | if (!hasTemplateKWAndArgsInfo()) |

2858 | return SourceLocation(); |

2859 | return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc; |

2860 | } |

2861 | |

2862 | /// Determines whether the member name was preceded by the template keyword. |

2863 | bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); } |

2864 | |

2865 | /// Determines whether the member name was followed by an |

2866 | /// explicit template argument list. |

2867 | bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); } |

2868 | |

2869 | /// Copies the template arguments (if present) into the given |

2870 | /// structure. |

2871 | void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { |

2872 | if (hasExplicitTemplateArgs()) |

2873 | getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto( |

2874 | getTrailingObjects<TemplateArgumentLoc>(), List); |

2875 | } |

2876 | |

2877 | /// Retrieve the template arguments provided as part of this |

2878 | /// template-id. |

2879 | const TemplateArgumentLoc *getTemplateArgs() const { |

2880 | if (!hasExplicitTemplateArgs()) |

2881 | return nullptr; |

2882 | |

2883 | return getTrailingObjects<TemplateArgumentLoc>(); |

2884 | } |

2885 | |

2886 | /// Retrieve the number of template arguments provided as part of this |

2887 | /// template-id. |

2888 | unsigned getNumTemplateArgs() const { |

2889 | if (!hasExplicitTemplateArgs()) |

2890 | return 0; |

2891 | |

2892 | return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs; |

2893 | } |

2894 | |

2895 | ArrayRef<TemplateArgumentLoc> template_arguments() const { |

2896 | return {getTemplateArgs(), getNumTemplateArgs()}; |

2897 | } |

2898 | |

2899 | /// Retrieve the member declaration name info. |

2900 | DeclarationNameInfo getMemberNameInfo() const { |

2901 | return DeclarationNameInfo(MemberDecl->getDeclName(), |

2902 | MemberLoc, MemberDNLoc); |

2903 | } |

2904 | |

2905 | SourceLocation getOperatorLoc() const { return MemberExprBits.OperatorLoc; } |

2906 | |

2907 | bool isArrow() const { return MemberExprBits.IsArrow; } |

2908 | void setArrow(bool A) { MemberExprBits.IsArrow = A; } |

2909 | |

2910 | /// getMemberLoc - Return the location of the "member", in X->F, it is the |

2911 | /// location of 'F'. |

2912 | SourceLocation getMemberLoc() const { return MemberLoc; } |

2913 | void setMemberLoc(SourceLocation L) { MemberLoc = L; } |

2914 | |

2915 | SourceLocation getBeginLoc() const LLVM_READONLY; |

2916 | SourceLocation getEndLoc() const LLVM_READONLY; |

2917 | |

2918 | SourceLocation getExprLoc() const LLVM_READONLY { return MemberLoc; } |

2919 | |

2920 | /// Determine whether the base of this explicit is implicit. |

2921 | bool isImplicitAccess() const { |

2922 | return getBase() && getBase()->isImplicitCXXThis(); |

2923 | } |

2924 | |

2925 | /// Returns true if this member expression refers to a method that |

2926 | /// was resolved from an overloaded set having size greater than 1. |

2927 | bool hadMultipleCandidates() const { |

2928 | return MemberExprBits.HadMultipleCandidates; |

2929 | } |

2930 | /// Sets the flag telling whether this expression refers to |

2931 | /// a method that was resolved from an overloaded set having size |

2932 | /// greater than 1. |

2933 | void setHadMultipleCandidates(bool V = true) { |

2934 | MemberExprBits.HadMultipleCandidates = V; |

2935 | } |

2936 | |

2937 | /// Returns true if virtual dispatch is performed. |

2938 | /// If the member access is fully qualified, (i.e. X::f()), virtual |

2939 | /// dispatching is not performed. In -fapple-kext mode qualified |

2940 | /// calls to virtual method will still go through the vtable. |

2941 | bool performsVirtualDispatch(const LangOptions &LO) const { |

2942 | return LO.AppleKext || !hasQualifier(); |

2943 | } |

2944 | |

2945 | static bool classof(const Stmt *T) { |

2946 | return T->getStmtClass() == MemberExprClass; |

2947 | } |

2948 | |

2949 | // Iterators |

2950 | child_range children() { return child_range(&Base, &Base+1); } |

2951 | const_child_range children() const { |

2952 | return const_child_range(&Base, &Base + 1); |

2953 | } |

2954 | }; |

2955 | |

2956 | /// CompoundLiteralExpr - [C99 6.5.2.5] |

2957 | /// |

2958 | class CompoundLiteralExpr : public Expr { |

2959 | /// LParenLoc - If non-null, this is the location of the left paren in a |

2960 | /// compound literal like "(int){4}". This can be null if this is a |

2961 | /// synthesized compound expression. |

2962 | SourceLocation LParenLoc; |

2963 | |

2964 | /// The type as written. This can be an incomplete array type, in |

2965 | /// which case the actual expression type will be different. |

2966 | /// The int part of the pair stores whether this expr is file scope. |

2967 | llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfoAndScope; |

2968 | Stmt *Init; |

2969 | public: |

2970 | CompoundLiteralExpr( |