clang  10.0.0svn
StmtIterator.cpp
Go to the documentation of this file.
1 //===- StmtIterator.cpp - Iterators for Statements ------------------------===//
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 internal methods for StmtIterator.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/StmtIterator.h"
14 #include "clang/AST/Decl.h"
15 #include "clang/AST/Type.h"
16 #include "clang/Basic/LLVM.h"
17 #include "llvm/Support/Casting.h"
18 #include <cassert>
19 #include <cstdint>
20 
21 using namespace clang;
22 
23 // FIXME: Add support for dependent-sized array types in C++?
24 // Does it even make sense to build a CFG for an uninstantiated template?
25 static inline const VariableArrayType *FindVA(const Type* t) {
26  while (const ArrayType *vt = dyn_cast<ArrayType>(t)) {
27  if (const VariableArrayType *vat = dyn_cast<VariableArrayType>(vt))
28  if (vat->getSizeExpr())
29  return vat;
30 
31  t = vt->getElementType().getTypePtr();
32  }
33 
34  return nullptr;
35 }
36 
38  assert(getVAPtr());
39 
40  const VariableArrayType *p = getVAPtr();
41  p = FindVA(p->getElementType().getTypePtr());
42  setVAPtr(p);
43 
44  if (p)
45  return;
46 
47  if (inDeclGroup()) {
48  if (VarDecl* VD = dyn_cast<VarDecl>(*DGI))
49  if (VD->hasInit())
50  return;
51 
52  NextDecl();
53  }
54  else {
55  assert(inSizeOfTypeVA());
56  RawVAPtr = 0;
57  }
58 }
59 
60 void StmtIteratorBase::NextDecl(bool ImmediateAdvance) {
61  assert(getVAPtr() == nullptr);
62  assert(inDeclGroup());
63 
64  if (ImmediateAdvance)
65  ++DGI;
66 
67  for ( ; DGI != DGE; ++DGI)
68  if (HandleDecl(*DGI))
69  return;
70 
71  RawVAPtr = 0;
72 }
73 
75  if (VarDecl* VD = dyn_cast<VarDecl>(D)) {
76  if (const VariableArrayType* VAPtr = FindVA(VD->getType().getTypePtr())) {
77  setVAPtr(VAPtr);
78  return true;
79  }
80 
81  if (VD->getInit())
82  return true;
83  }
84  else if (TypedefNameDecl* TD = dyn_cast<TypedefNameDecl>(D)) {
85  if (const VariableArrayType* VAPtr =
86  FindVA(TD->getUnderlyingType().getTypePtr())) {
87  setVAPtr(VAPtr);
88  return true;
89  }
90  }
91  else if (EnumConstantDecl* ECD = dyn_cast<EnumConstantDecl>(D)) {
92  if (ECD->getInitExpr())
93  return true;
94  }
95 
96  return false;
97 }
98 
100  : DGI(dgi), RawVAPtr(DeclGroupMode), DGE(dge) {
101  NextDecl(false);
102 }
103 
105  : DGI(nullptr), RawVAPtr(SizeOfTypeVAMode) {
106  RawVAPtr |= reinterpret_cast<uintptr_t>(t);
107 }
108 
110  if (const VariableArrayType* VAPtr = getVAPtr()) {
111  assert(VAPtr->SizeExpr);
112  return const_cast<Stmt*&>(VAPtr->SizeExpr);
113  }
114 
115  assert(inDeclGroup());
116  VarDecl* VD = cast<VarDecl>(*DGI);
117  return *VD->getInitAddress();
118 }
Stmt - This represents one statement.
Definition: Stmt.h:66
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2827
C Language Family Type Representation.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
bool inDeclGroup() const
Definition: StmtIterator.h:48
The base class of the type hierarchy.
Definition: Type.h:1436
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2850
QualType getElementType() const
Definition: Type.h:2885
const VariableArrayType * getVAPtr() const
Definition: StmtIterator.h:60
Represents a variable declaration or definition.
Definition: Decl.h:812
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
void NextDecl(bool ImmediateAdvance=true)
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6148
Stmt ** getInitAddress()
Retrieve the address of the initializer expression.
Definition: Decl.cpp:2216
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c-base.h:62
bool inSizeOfTypeVA() const
Definition: StmtIterator.h:52
Stmt *& GetDeclExpr() const
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2957
Dataflow Directional Tag Classes.
bool HandleDecl(Decl *D)
static const VariableArrayType * FindVA(const Type *t)
void setVAPtr(const VariableArrayType *P)
Definition: StmtIterator.h:64
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3009