clang  6.0.0svn
StmtCXX.cpp
Go to the documentation of this file.
1 //===--- StmtCXX.cpp - Classes for representing C++ statements ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the subclesses of Stmt class declared in StmtCXX.h
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/StmtCXX.h"
15 
16 #include "clang/AST/ASTContext.h"
17 
18 using namespace clang;
19 
21  if (ExceptionDecl)
22  return ExceptionDecl->getType();
23  return QualType();
24 }
25 
27  Stmt *tryBlock, ArrayRef<Stmt *> handlers) {
28  std::size_t Size = sizeof(CXXTryStmt);
29  Size += ((handlers.size() + 1) * sizeof(Stmt *));
30 
31  void *Mem = C.Allocate(Size, alignof(CXXTryStmt));
32  return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers);
33 }
34 
36  unsigned numHandlers) {
37  std::size_t Size = sizeof(CXXTryStmt);
38  Size += ((numHandlers + 1) * sizeof(Stmt *));
39 
40  void *Mem = C.Allocate(Size, alignof(CXXTryStmt));
41  return new (Mem) CXXTryStmt(Empty, numHandlers);
42 }
43 
44 CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
45  ArrayRef<Stmt *> handlers)
46  : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
47  Stmt **Stmts = reinterpret_cast<Stmt **>(this + 1);
48  Stmts[0] = tryBlock;
49  std::copy(handlers.begin(), handlers.end(), Stmts + 1);
50 }
51 
53  DeclStmt *BeginStmt, DeclStmt *EndStmt,
54  Expr *Cond, Expr *Inc, DeclStmt *LoopVar,
55  Stmt *Body, SourceLocation FL,
57  SourceLocation RPL)
58  : Stmt(CXXForRangeStmtClass), ForLoc(FL), CoawaitLoc(CAL), ColonLoc(CL),
59  RParenLoc(RPL) {
60  SubExprs[RANGE] = Range;
61  SubExprs[BEGINSTMT] = BeginStmt;
62  SubExprs[ENDSTMT] = EndStmt;
63  SubExprs[COND] = Cond;
64  SubExprs[INC] = Inc;
65  SubExprs[LOOPVAR] = LoopVar;
66  SubExprs[BODY] = Body;
67 }
68 
70  DeclStmt *RangeStmt = getRangeStmt();
71  VarDecl *RangeDecl = dyn_cast_or_null<VarDecl>(RangeStmt->getSingleDecl());
72  assert(RangeDecl && "for-range should have a single var decl");
73  return RangeDecl->getInit();
74 }
75 
77  return const_cast<CXXForRangeStmt *>(this)->getRangeInit();
78 }
79 
81  Decl *LV = cast<DeclStmt>(getLoopVarStmt())->getSingleDecl();
82  assert(LV && "No loop variable in CXXForRangeStmt");
83  return cast<VarDecl>(LV);
84 }
85 
87  return const_cast<CXXForRangeStmt *>(this)->getLoopVariable();
88 }
89 
91  const ASTContext &C, CoroutineBodyStmt::CtorArgs const &Args) {
92  std::size_t Size = totalSizeToAlloc<Stmt *>(
93  CoroutineBodyStmt::FirstParamMove + Args.ParamMoves.size());
94 
95  void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt));
96  return new (Mem) CoroutineBodyStmt(Args);
97 }
98 
100  unsigned NumParams) {
101  std::size_t Size = totalSizeToAlloc<Stmt *>(
102  CoroutineBodyStmt::FirstParamMove + NumParams);
103 
104  void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt));
105  auto *Result = new (Mem) CoroutineBodyStmt(CtorArgs());
106  Result->NumParams = NumParams;
107  auto *ParamBegin = Result->getStoredStmts() + SubStmt::FirstParamMove;
108  std::uninitialized_fill(ParamBegin, ParamBegin + NumParams,
109  static_cast<Stmt *>(nullptr));
110  return Result;
111 }
112 
113 CoroutineBodyStmt::CoroutineBodyStmt(CoroutineBodyStmt::CtorArgs const &Args)
114  : Stmt(CoroutineBodyStmtClass), NumParams(Args.ParamMoves.size()) {
115  Stmt **SubStmts = getStoredStmts();
116  SubStmts[CoroutineBodyStmt::Body] = Args.Body;
117  SubStmts[CoroutineBodyStmt::Promise] = Args.Promise;
118  SubStmts[CoroutineBodyStmt::InitSuspend] = Args.InitialSuspend;
119  SubStmts[CoroutineBodyStmt::FinalSuspend] = Args.FinalSuspend;
120  SubStmts[CoroutineBodyStmt::OnException] = Args.OnException;
121  SubStmts[CoroutineBodyStmt::OnFallthrough] = Args.OnFallthrough;
122  SubStmts[CoroutineBodyStmt::Allocate] = Args.Allocate;
123  SubStmts[CoroutineBodyStmt::Deallocate] = Args.Deallocate;
124  SubStmts[CoroutineBodyStmt::ReturnValue] = Args.ReturnValue;
125  SubStmts[CoroutineBodyStmt::ResultDecl] = Args.ResultDecl;
126  SubStmts[CoroutineBodyStmt::ReturnStmt] = Args.ReturnStmt;
127  SubStmts[CoroutineBodyStmt::ReturnStmtOnAllocFailure] =
129  std::copy(Args.ParamMoves.begin(), Args.ParamMoves.end(),
130  const_cast<Stmt **>(getParamMoves().data()));
131 }
Defines the clang::ASTContext interface.
A (possibly-)qualified type.
Definition: Type.h:614
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:60
Stmt - This represents one statement.
Definition: Stmt.h:60
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:771
Stmt(StmtClass SC, EmptyShell)
Construct an empty statement.
Definition: Stmt.h:349
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
QualType getCaughtType() const
Definition: StmtCXX.cpp:20
CXXForRangeStmt - This represents C++0x [stmt.ranged]&#39;s ranged for statement, represented as &#39;for (ra...
Definition: StmtCXX.h:128
Expr - This represents one expression.
Definition: Expr.h:106
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:65
The result type of a method or function.
static CoroutineBodyStmt * Create(const ASTContext &C, CtorArgs const &Args)
Definition: StmtCXX.cpp:90
Encodes a location in the source.
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:467
ArrayRef< Stmt * > ParamMoves
Definition: StmtCXX.h:342
A placeholder type used to construct an empty shell of a type, that will be filled in later (e...
Definition: Stmt.h:308
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:625
CXXForRangeStmt(DeclStmt *Range, DeclStmt *Begin, DeclStmt *End, Expr *Cond, Expr *Inc, DeclStmt *LoopVar, Stmt *Body, SourceLocation FL, SourceLocation CAL, SourceLocation CL, SourceLocation RPL)
Definition: StmtCXX.cpp:52
Dataflow Directional Tag Classes.
const Expr * getInit() const
Definition: Decl.h:1159
const Decl * getSingleDecl() const
Definition: Stmt.h:485
Represents the body of a coroutine.
Definition: StmtCXX.h:299
DeclStmt * getRangeStmt()
Definition: StmtCXX.h:154
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, Stmt *tryBlock, ArrayRef< Stmt *> handlers)
Definition: StmtCXX.cpp:26
VarDecl * getLoopVariable()
Definition: StmtCXX.cpp:80
DeclStmt * getLoopVarStmt()
Definition: StmtCXX.h:161
QualType getType() const
Definition: Decl.h:602
SourceLocation ColonLoc
Location of &#39;:&#39;.
Definition: OpenMPClause.h:90