Ted Kremenek | f8e32cf | 2008-06-20 21:40:36 +0000 | [diff] [blame] | 1 | //===--- ParentMap.cpp - Mappings from Stmts to their Parents ---*- C++ -*-===// |
| 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 defines the ParentMap class. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "clang/AST/ParentMap.h" |
Daniel Dunbar | acc5f3e | 2008-08-11 06:23:49 +0000 | [diff] [blame] | 15 | #include "clang/AST/Decl.h" |
Ted Kremenek | f8e32cf | 2008-06-20 21:40:36 +0000 | [diff] [blame] | 16 | #include "clang/AST/Expr.h" |
| 17 | #include "llvm/ADT/DenseMap.h" |
| 18 | |
| 19 | using namespace clang; |
| 20 | |
| 21 | typedef llvm::DenseMap<Stmt*, Stmt*> MapTy; |
| 22 | |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 23 | enum OpaqueValueMode { |
| 24 | OV_Transparent, |
| 25 | OV_Opaque |
| 26 | }; |
| 27 | |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 28 | static void BuildParentMap(MapTy& M, Stmt* S, |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 29 | OpaqueValueMode OVMode = OV_Transparent) { |
| 30 | |
| 31 | switch (S->getStmtClass()) { |
| 32 | case Stmt::PseudoObjectExprClass: { |
| 33 | assert(OVMode == OV_Transparent && "Should not appear alongside OVEs"); |
| 34 | PseudoObjectExpr *POE = cast<PseudoObjectExpr>(S); |
| 35 | |
Jordan Rose | b9fdfb5 | 2013-05-18 02:27:09 +0000 | [diff] [blame] | 36 | // If we are rebuilding the map, clear out any existing state. |
| 37 | if (M[POE->getSyntacticForm()]) |
| 38 | for (Stmt::child_range I = S->children(); I; ++I) |
| 39 | M[*I] = 0; |
| 40 | |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 41 | M[POE->getSyntacticForm()] = S; |
| 42 | BuildParentMap(M, POE->getSyntacticForm(), OV_Transparent); |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 43 | |
| 44 | for (PseudoObjectExpr::semantics_iterator I = POE->semantics_begin(), |
| 45 | E = POE->semantics_end(); |
| 46 | I != E; ++I) { |
| 47 | M[*I] = S; |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 48 | BuildParentMap(M, *I, OV_Opaque); |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 49 | } |
| 50 | break; |
| 51 | } |
| 52 | case Stmt::BinaryConditionalOperatorClass: { |
| 53 | assert(OVMode == OV_Transparent && "Should not appear alongside OVEs"); |
| 54 | BinaryConditionalOperator *BCO = cast<BinaryConditionalOperator>(S); |
| 55 | |
| 56 | M[BCO->getCommon()] = S; |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 57 | BuildParentMap(M, BCO->getCommon(), OV_Transparent); |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 58 | |
| 59 | M[BCO->getCond()] = S; |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 60 | BuildParentMap(M, BCO->getCond(), OV_Opaque); |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 61 | |
| 62 | M[BCO->getTrueExpr()] = S; |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 63 | BuildParentMap(M, BCO->getTrueExpr(), OV_Opaque); |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 64 | |
| 65 | M[BCO->getFalseExpr()] = S; |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 66 | BuildParentMap(M, BCO->getFalseExpr(), OV_Transparent); |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 67 | |
| 68 | break; |
| 69 | } |
Jordan Rose | b9fdfb5 | 2013-05-18 02:27:09 +0000 | [diff] [blame] | 70 | case Stmt::OpaqueValueExprClass: { |
| 71 | // FIXME: This isn't correct; it assumes that multiple OpaqueValueExprs |
| 72 | // share a single source expression, but in the AST a single |
| 73 | // OpaqueValueExpr is shared among multiple parent expressions. |
| 74 | // The right thing to do is to give the OpaqueValueExpr its syntactic |
| 75 | // parent, then not reassign that when traversing the semantic expressions. |
| 76 | OpaqueValueExpr *OVE = cast<OpaqueValueExpr>(S); |
Serge Pavlov | fa047c5 | 2013-05-18 04:32:15 +0000 | [diff] [blame^] | 77 | if (OVMode == OV_Transparent || !M[OVE->getSourceExpr()]) { |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 78 | M[OVE->getSourceExpr()] = S; |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 79 | BuildParentMap(M, OVE->getSourceExpr(), OV_Transparent); |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 80 | } |
| 81 | break; |
Jordan Rose | b9fdfb5 | 2013-05-18 02:27:09 +0000 | [diff] [blame] | 82 | } |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 83 | default: |
| 84 | for (Stmt::child_range I = S->children(); I; ++I) { |
| 85 | if (*I) { |
| 86 | M[*I] = S; |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 87 | BuildParentMap(M, *I, OVMode); |
Jordan Rose | 2b1b025 | 2012-08-06 21:28:11 +0000 | [diff] [blame] | 88 | } |
Ted Kremenek | f8e32cf | 2008-06-20 21:40:36 +0000 | [diff] [blame] | 89 | } |
Jordan Rose | 1e5101e | 2012-10-06 01:19:36 +0000 | [diff] [blame] | 90 | break; |
Jordan Rose | 2b1b025 | 2012-08-06 21:28:11 +0000 | [diff] [blame] | 91 | } |
Ted Kremenek | f8e32cf | 2008-06-20 21:40:36 +0000 | [diff] [blame] | 92 | } |
| 93 | |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 94 | ParentMap::ParentMap(Stmt* S) : Impl(0) { |
Ted Kremenek | f8e32cf | 2008-06-20 21:40:36 +0000 | [diff] [blame] | 95 | if (S) { |
| 96 | MapTy *M = new MapTy(); |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 97 | BuildParentMap(*M, S); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 98 | Impl = M; |
Ted Kremenek | f8e32cf | 2008-06-20 21:40:36 +0000 | [diff] [blame] | 99 | } |
| 100 | } |
| 101 | |
| 102 | ParentMap::~ParentMap() { |
| 103 | delete (MapTy*) Impl; |
| 104 | } |
| 105 | |
Ted Kremenek | d6543f8 | 2010-11-15 20:54:24 +0000 | [diff] [blame] | 106 | void ParentMap::addStmt(Stmt* S) { |
| 107 | if (S) { |
Jordan Rose | bb51899 | 2013-05-18 02:26:50 +0000 | [diff] [blame] | 108 | BuildParentMap(*(MapTy*) Impl, S); |
Ted Kremenek | d6543f8 | 2010-11-15 20:54:24 +0000 | [diff] [blame] | 109 | } |
| 110 | } |
| 111 | |
Ted Kremenek | f8e32cf | 2008-06-20 21:40:36 +0000 | [diff] [blame] | 112 | Stmt* ParentMap::getParent(Stmt* S) const { |
| 113 | MapTy* M = (MapTy*) Impl; |
| 114 | MapTy::iterator I = M->find(S); |
| 115 | return I == M->end() ? 0 : I->second; |
| 116 | } |
Ted Kremenek | b930d7a | 2009-04-01 06:52:48 +0000 | [diff] [blame] | 117 | |
Ted Kremenek | b1b9f68 | 2009-05-11 19:49:27 +0000 | [diff] [blame] | 118 | Stmt *ParentMap::getParentIgnoreParens(Stmt *S) const { |
| 119 | do { S = getParent(S); } while (S && isa<ParenExpr>(S)); |
| 120 | return S; |
| 121 | } |
| 122 | |
Ted Kremenek | f4e532b | 2011-02-12 00:17:19 +0000 | [diff] [blame] | 123 | Stmt *ParentMap::getParentIgnoreParenCasts(Stmt *S) const { |
| 124 | do { |
| 125 | S = getParent(S); |
| 126 | } |
| 127 | while (S && (isa<ParenExpr>(S) || isa<CastExpr>(S))); |
| 128 | |
| 129 | return S; |
| 130 | } |
| 131 | |
Argyrios Kyrtzidis | 18fd0c6 | 2011-07-27 05:28:18 +0000 | [diff] [blame] | 132 | Stmt *ParentMap::getParentIgnoreParenImpCasts(Stmt *S) const { |
| 133 | do { |
| 134 | S = getParent(S); |
| 135 | } while (S && isa<Expr>(S) && cast<Expr>(S)->IgnoreParenImpCasts() != S); |
| 136 | |
| 137 | return S; |
| 138 | } |
| 139 | |
John McCall | f85e193 | 2011-06-15 23:02:42 +0000 | [diff] [blame] | 140 | Stmt *ParentMap::getOuterParenParent(Stmt *S) const { |
| 141 | Stmt *Paren = 0; |
| 142 | while (isa<ParenExpr>(S)) { |
| 143 | Paren = S; |
| 144 | S = getParent(S); |
| 145 | }; |
| 146 | return Paren; |
| 147 | } |
| 148 | |
Ted Kremenek | b930d7a | 2009-04-01 06:52:48 +0000 | [diff] [blame] | 149 | bool ParentMap::isConsumedExpr(Expr* E) const { |
| 150 | Stmt *P = getParent(E); |
| 151 | Stmt *DirectChild = E; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 152 | |
Ted Kremenek | b930d7a | 2009-04-01 06:52:48 +0000 | [diff] [blame] | 153 | // Ignore parents that are parentheses or casts. |
Ted Kremenek | ade9eca | 2009-05-05 22:16:12 +0000 | [diff] [blame] | 154 | while (P && (isa<ParenExpr>(P) || isa<CastExpr>(P))) { |
Ted Kremenek | b930d7a | 2009-04-01 06:52:48 +0000 | [diff] [blame] | 155 | DirectChild = P; |
| 156 | P = getParent(P); |
| 157 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 158 | |
Ted Kremenek | b930d7a | 2009-04-01 06:52:48 +0000 | [diff] [blame] | 159 | if (!P) |
| 160 | return false; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 161 | |
Ted Kremenek | b930d7a | 2009-04-01 06:52:48 +0000 | [diff] [blame] | 162 | switch (P->getStmtClass()) { |
| 163 | default: |
| 164 | return isa<Expr>(P); |
| 165 | case Stmt::DeclStmtClass: |
| 166 | return true; |
| 167 | case Stmt::BinaryOperatorClass: { |
| 168 | BinaryOperator *BE = cast<BinaryOperator>(P); |
Ted Kremenek | 24ae89a | 2009-04-09 05:34:31 +0000 | [diff] [blame] | 169 | // If it is a comma, only the right side is consumed. |
Ted Kremenek | e42ac98 | 2009-04-08 18:49:36 +0000 | [diff] [blame] | 170 | // If it isn't a comma, both sides are consumed. |
John McCall | 2de56d1 | 2010-08-25 11:45:40 +0000 | [diff] [blame] | 171 | return BE->getOpcode()!=BO_Comma ||DirectChild==BE->getRHS(); |
Ted Kremenek | b930d7a | 2009-04-01 06:52:48 +0000 | [diff] [blame] | 172 | } |
| 173 | case Stmt::ForStmtClass: |
| 174 | return DirectChild == cast<ForStmt>(P)->getCond(); |
| 175 | case Stmt::WhileStmtClass: |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 176 | return DirectChild == cast<WhileStmt>(P)->getCond(); |
Ted Kremenek | b930d7a | 2009-04-01 06:52:48 +0000 | [diff] [blame] | 177 | case Stmt::DoStmtClass: |
| 178 | return DirectChild == cast<DoStmt>(P)->getCond(); |
| 179 | case Stmt::IfStmtClass: |
| 180 | return DirectChild == cast<IfStmt>(P)->getCond(); |
| 181 | case Stmt::IndirectGotoStmtClass: |
| 182 | return DirectChild == cast<IndirectGotoStmt>(P)->getTarget(); |
| 183 | case Stmt::SwitchStmtClass: |
| 184 | return DirectChild == cast<SwitchStmt>(P)->getCond(); |
| 185 | case Stmt::ReturnStmtClass: |
| 186 | return true; |
| 187 | } |
| 188 | } |
| 189 | |