|
150
|
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
|
|
|
37 void StmtIteratorBase::NextVA() {
|
|
|
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
|
|
|
74 bool StmtIteratorBase::HandleDecl(Decl* D) {
|
|
|
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
|
|
|
99 StmtIteratorBase::StmtIteratorBase(Decl** dgi, Decl** dge)
|
|
|
100 : DGI(dgi), RawVAPtr(DeclGroupMode), DGE(dge) {
|
|
|
101 NextDecl(false);
|
|
|
102 }
|
|
|
103
|
|
|
104 StmtIteratorBase::StmtIteratorBase(const VariableArrayType* t)
|
|
|
105 : DGI(nullptr), RawVAPtr(SizeOfTypeVAMode) {
|
|
|
106 RawVAPtr |= reinterpret_cast<uintptr_t>(t);
|
|
|
107 }
|
|
|
108
|
|
|
109 Stmt*& StmtIteratorBase::GetDeclExpr() const {
|
|
|
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 }
|
