clang  11.0.0git
ByteCodeStmtGen.cpp
Go to the documentation of this file.
1 //===--- ByteCodeStmtGen.cpp - Code generator for 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 #include "ByteCodeStmtGen.h"
10 #include "ByteCodeEmitter.h"
11 #include "ByteCodeGenError.h"
12 #include "Context.h"
13 #include "Function.h"
14 #include "PrimType.h"
15 #include "Program.h"
16 #include "State.h"
17 #include "clang/Basic/LLVM.h"
18 
19 using namespace clang;
20 using namespace clang::interp;
21 
22 namespace clang {
23 namespace interp {
24 
25 /// Scope managing label targets.
26 template <class Emitter> class LabelScope {
27 public:
28  virtual ~LabelScope() { }
29 
30 protected:
32  /// ByteCodeStmtGen instance.
34 };
35 
36 /// Sets the context for break/continue statements.
37 template <class Emitter> class LoopScope final : public LabelScope<Emitter> {
38 public:
39  using LabelTy = typename ByteCodeStmtGen<Emitter>::LabelTy;
41 
43  LabelTy ContinueLabel)
44  : LabelScope<Emitter>(Ctx), OldBreakLabel(Ctx->BreakLabel),
45  OldContinueLabel(Ctx->ContinueLabel) {
46  this->Ctx->BreakLabel = BreakLabel;
47  this->Ctx->ContinueLabel = ContinueLabel;
48  }
49 
51  this->Ctx->BreakLabel = OldBreakLabel;
52  this->Ctx->ContinueLabel = OldContinueLabel;
53  }
54 
55 private:
56  OptLabelTy OldBreakLabel;
57  OptLabelTy OldContinueLabel;
58 };
59 
60 // Sets the context for a switch scope, mapping labels.
61 template <class Emitter> class SwitchScope final : public LabelScope<Emitter> {
62 public:
63  using LabelTy = typename ByteCodeStmtGen<Emitter>::LabelTy;
65  using CaseMap = typename ByteCodeStmtGen<Emitter>::CaseMap;
66 
68  LabelTy BreakLabel, OptLabelTy DefaultLabel)
69  : LabelScope<Emitter>(Ctx), OldBreakLabel(Ctx->BreakLabel),
70  OldDefaultLabel(this->Ctx->DefaultLabel),
71  OldCaseLabels(std::move(this->Ctx->CaseLabels)) {
72  this->Ctx->BreakLabel = BreakLabel;
73  this->Ctx->DefaultLabel = DefaultLabel;
74  this->Ctx->CaseLabels = std::move(CaseLabels);
75  }
76 
78  this->Ctx->BreakLabel = OldBreakLabel;
79  this->Ctx->DefaultLabel = OldDefaultLabel;
80  this->Ctx->CaseLabels = std::move(OldCaseLabels);
81  }
82 
83 private:
84  OptLabelTy OldBreakLabel;
85  OptLabelTy OldDefaultLabel;
86  CaseMap OldCaseLabels;
87 };
88 
89 } // namespace interp
90 } // namespace clang
91 
92 template <class Emitter>
94  // Classify the return type.
95  ReturnType = this->classify(F->getReturnType());
96 
97  // Set up fields and context if a constructor.
98  if (auto *MD = dyn_cast<CXXMethodDecl>(F))
99  return this->bail(MD);
100 
101  if (auto *Body = F->getBody())
102  if (!visitStmt(Body))
103  return false;
104 
105  // Emit a guard return to protect against a code path missing one.
106  if (F->getReturnType()->isVoidType())
107  return this->emitRetVoid(SourceInfo{});
108  else
109  return this->emitNoRet(SourceInfo{});
110 }
111 
112 template <class Emitter>
114  switch (S->getStmtClass()) {
115  case Stmt::CompoundStmtClass:
116  return visitCompoundStmt(cast<CompoundStmt>(S));
117  case Stmt::DeclStmtClass:
118  return visitDeclStmt(cast<DeclStmt>(S));
119  case Stmt::ReturnStmtClass:
120  return visitReturnStmt(cast<ReturnStmt>(S));
121  case Stmt::IfStmtClass:
122  return visitIfStmt(cast<IfStmt>(S));
123  case Stmt::NullStmtClass:
124  return true;
125  default: {
126  if (auto *Exp = dyn_cast<Expr>(S))
127  return this->discard(Exp);
128  return this->bail(S);
129  }
130  }
131 }
132 
133 template <class Emitter>
135  const CompoundStmt *CompoundStmt) {
137  for (auto *InnerStmt : CompoundStmt->body())
138  if (!visitStmt(InnerStmt))
139  return false;
140  return true;
141 }
142 
143 template <class Emitter>
145  for (auto *D : DS->decls()) {
146  // Variable declarator.
147  if (auto *VD = dyn_cast<VarDecl>(D)) {
148  if (!visitVarDecl(VD))
149  return false;
150  continue;
151  }
152 
153  // Decomposition declarator.
154  if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
155  return this->bail(DD);
156  }
157  }
158 
159  return true;
160 }
161 
162 template <class Emitter>
164  if (const Expr *RE = RS->getRetValue()) {
165  ExprScope<Emitter> RetScope(this);
166  if (ReturnType) {
167  // Primitive types are simply returned.
168  if (!this->visit(RE))
169  return false;
170  this->emitCleanup();
171  return this->emitRet(*ReturnType, RS);
172  } else {
173  // RVO - construct the value in the return location.
174  auto ReturnLocation = [this, RE] { return this->emitGetParamPtr(0, RE); };
175  if (!this->visitInitializer(RE, ReturnLocation))
176  return false;
177  this->emitCleanup();
178  return this->emitRetVoid(RS);
179  }
180  } else {
181  this->emitCleanup();
182  if (!this->emitRetVoid(RS))
183  return false;
184  return true;
185  }
186 }
187 
188 template <class Emitter>
190  BlockScope<Emitter> IfScope(this);
191  if (auto *CondInit = IS->getInit())
192  if (!visitStmt(IS->getInit()))
193  return false;
194 
195  if (const DeclStmt *CondDecl = IS->getConditionVariableDeclStmt())
196  if (!visitDeclStmt(CondDecl))
197  return false;
198 
199  if (!this->visitBool(IS->getCond()))
200  return false;
201 
202  if (const Stmt *Else = IS->getElse()) {
203  LabelTy LabelElse = this->getLabel();
204  LabelTy LabelEnd = this->getLabel();
205  if (!this->jumpFalse(LabelElse))
206  return false;
207  if (!visitStmt(IS->getThen()))
208  return false;
209  if (!this->jump(LabelEnd))
210  return false;
211  this->emitLabel(LabelElse);
212  if (!visitStmt(Else))
213  return false;
214  this->emitLabel(LabelEnd);
215  } else {
216  LabelTy LabelEnd = this->getLabel();
217  if (!this->jumpFalse(LabelEnd))
218  return false;
219  if (!visitStmt(IS->getThen()))
220  return false;
221  this->emitLabel(LabelEnd);
222  }
223 
224  return true;
225 }
226 
227 template <class Emitter>
229  auto DT = VD->getType();
230 
231  if (!VD->hasLocalStorage()) {
232  // No code generation required.
233  return true;
234  }
235 
236  // Integers, pointers, primitives.
237  if (Optional<PrimType> T = this->classify(DT)) {
238  auto Off = this->allocateLocalPrimitive(VD, *T, DT.isConstQualified());
239  // Compile the initialiser in its own scope.
240  {
242  if (!this->visit(VD->getInit()))
243  return false;
244  }
245  // Set the value.
246  return this->emitSetLocal(*T, Off, VD);
247  } else {
248  // Composite types - allocate storage and initialize it.
249  if (auto Off = this->allocateLocal(VD)) {
250  return this->visitLocalInitializer(VD->getInit(), *Off);
251  } else {
252  return this->bail(VD);
253  }
254  }
255 }
256 
257 namespace clang {
258 namespace interp {
259 
260 template class ByteCodeStmtGen<ByteCodeEmitter>;
261 
262 } // namespace interp
263 } // namespace clang
Represents a function declaration or definition.
Definition: Decl.h:1783
Sets the context for break/continue statements.
Stmt - This represents one statement.
Definition: Stmt.h:68
typename ByteCodeStmtGen< Emitter >::OptLabelTy OptLabelTy
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1866
Scope managing label targets.
Represents a variable declaration or definition.
Definition: Decl.h:820
QualType getReturnType() const
Definition: Decl.h:2456
LoopScope(ByteCodeStmtGen< Emitter > *Ctx, LabelTy BreakLabel, LabelTy ContinueLabel)
Stmt * getThen()
Definition: Stmt.h:1953
Describes the statement/declaration an opcode was generated from.
Definition: Source.h:81
Compilation context for statements.
Definition: Format.h:2679
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2881
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
typename ByteCodeStmtGen< Emitter >::OptLabelTy OptLabelTy
Stmt * getInit()
Definition: Stmt.h:2009
Expression scope which tracks potentially lifetime extended temporaries which are hoisted to the pare...
Scope for storage declared in a compound statement.
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1364
This represents one expression.
Definition: Expr.h:110
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1045
typename ByteCodeStmtGen< Emitter >::LabelTy LabelTy
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:2668
Expr * getCond()
Definition: Stmt.h:1941
body_range body()
Definition: Stmt.h:1397
Expr * getRetValue()
Definition: Stmt.h:2701
Stmt * getElse()
Definition: Stmt.h:1962
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:1257
ByteCodeStmtGen< Emitter > * Ctx
ByteCodeStmtGen instance.
bool visitFunc(const FunctionDecl *F) override
typename ByteCodeStmtGen< Emitter >::CaseMap CaseMap
Dataflow Directional Tag Classes.
const Expr * getInit() const
Definition: Decl.h:1229
StmtClass getStmtClass() const
Definition: Stmt.h:1148
DeclStmt * getConditionVariableDeclStmt()
If this IfStmt has a condition variable, return the faux DeclStmt associated with the creation of tha...
Definition: Stmt.h:1997
decl_range decls()
Definition: Stmt.h:1305
LabelScope(ByteCodeStmtGen< Emitter > *Ctx)
bool isVoidType() const
Definition: Type.h:6933
typename Emitter::LabelTy LabelTy
Describes a scope block.
Definition: Function.h:32
typename ByteCodeStmtGen< Emitter >::LabelTy LabelTy
QualType getType() const
Definition: Decl.h:630
SwitchScope(ByteCodeStmtGen< Emitter > *Ctx, CaseMap &&CaseLabels, LabelTy BreakLabel, OptLabelTy DefaultLabel)