| 1 | //===--- CFGStmtMap.h - Map from Stmt* to CFGBlock* -----------*- 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 | // This file defines the CFGStmtMap class, which defines a mapping from |
|---|
| 10 | // Stmt* to CFGBlock* |
|---|
| 11 | // |
|---|
| 12 | //===----------------------------------------------------------------------===// |
|---|
| 13 | |
|---|
| 14 | #include "llvm/ADT/DenseMap.h" |
|---|
| 15 | #include "clang/AST/ParentMap.h" |
|---|
| 16 | #include "clang/Analysis/CFG.h" |
|---|
| 17 | #include "clang/Analysis/CFGStmtMap.h" |
|---|
| 18 | #include <optional> |
|---|
| 19 | |
|---|
| 20 | using namespace clang; |
|---|
| 21 | |
|---|
| 22 | typedef llvm::DenseMap<const Stmt*, CFGBlock*> SMap; |
|---|
| 23 | static SMap *AsMap(void *m) { return (SMap*) m; } |
|---|
| 24 | |
|---|
| 25 | CFGStmtMap::~CFGStmtMap() { delete AsMap(m: M); } |
|---|
| 26 | |
|---|
| 27 | CFGBlock *CFGStmtMap::getBlock(Stmt *S) { |
|---|
| 28 | SMap *SM = AsMap(m: M); |
|---|
| 29 | Stmt *X = S; |
|---|
| 30 | |
|---|
| 31 | // If 'S' isn't in the map, walk the ParentMap to see if one of its ancestors |
|---|
| 32 | // is in the map. |
|---|
| 33 | while (X) { |
|---|
| 34 | SMap::iterator I = SM->find(Val: X); |
|---|
| 35 | if (I != SM->end()) { |
|---|
| 36 | CFGBlock *B = I->second; |
|---|
| 37 | // Memoize this lookup. |
|---|
| 38 | if (X != S) |
|---|
| 39 | (*SM)[X] = B; |
|---|
| 40 | return B; |
|---|
| 41 | } |
|---|
| 42 | |
|---|
| 43 | X = PM->getParentIgnoreParens(X); |
|---|
| 44 | } |
|---|
| 45 | |
|---|
| 46 | return nullptr; |
|---|
| 47 | } |
|---|
| 48 | |
|---|
| 49 | static void Accumulate(SMap &SM, CFGBlock *B) { |
|---|
| 50 | // First walk the block-level expressions. |
|---|
| 51 | for (CFGBlock::iterator I = B->begin(), E = B->end(); I != E; ++I) { |
|---|
| 52 | const CFGElement &CE = *I; |
|---|
| 53 | std::optional<CFGStmt> CS = CE.getAs<CFGStmt>(); |
|---|
| 54 | if (!CS) |
|---|
| 55 | continue; |
|---|
| 56 | |
|---|
| 57 | CFGBlock *&Entry = SM[CS->getStmt()]; |
|---|
| 58 | // If 'Entry' is already initialized (e.g., a terminator was already), |
|---|
| 59 | // skip. |
|---|
| 60 | if (Entry) |
|---|
| 61 | continue; |
|---|
| 62 | |
|---|
| 63 | Entry = B; |
|---|
| 64 | |
|---|
| 65 | } |
|---|
| 66 | |
|---|
| 67 | // Look at the label of the block. |
|---|
| 68 | if (Stmt *Label = B->getLabel()) |
|---|
| 69 | SM[Label] = B; |
|---|
| 70 | |
|---|
| 71 | // Finally, look at the terminator. If the terminator was already added |
|---|
| 72 | // because it is a block-level expression in another block, overwrite |
|---|
| 73 | // that mapping. |
|---|
| 74 | if (Stmt *Term = B->getTerminatorStmt()) |
|---|
| 75 | SM[Term] = B; |
|---|
| 76 | } |
|---|
| 77 | |
|---|
| 78 | CFGStmtMap *CFGStmtMap::Build(CFG *C, ParentMap *PM) { |
|---|
| 79 | if (!C || !PM) |
|---|
| 80 | return nullptr; |
|---|
| 81 | |
|---|
| 82 | SMap *SM = new SMap(); |
|---|
| 83 | |
|---|
| 84 | // Walk all blocks, accumulating the block-level expressions, labels, |
|---|
| 85 | // and terminators. |
|---|
| 86 | for (CFG::iterator I = C->begin(), E = C->end(); I != E; ++I) |
|---|
| 87 | Accumulate(SM&: *SM, B: *I); |
|---|
| 88 | |
|---|
| 89 | return new CFGStmtMap(PM, SM); |
|---|
| 90 | } |
|---|
| 91 | |
|---|
| 92 | |
|---|
