clang 19.0.0git
CFGStmtMap.cpp
Go to the documentation of this file.
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"
18#include <optional>
19
20using namespace clang;
21
22typedef llvm::DenseMap<const Stmt*, CFGBlock*> SMap;
23static SMap *AsMap(void *m) { return (SMap*) m; }
24
26
28 SMap *SM = AsMap(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(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
44 }
45
46 return nullptr;
47}
48
49static 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
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, *I);
88
89 return new CFGStmtMap(PM, SM);
90}
91
#define SM(sm)
Definition: Cuda.cpp:83
static SMap * AsMap(void *m)
Definition: CFGStmtMap.cpp:23
static void Accumulate(SMap &SM, CFGBlock *B)
Definition: CFGStmtMap.cpp:49
llvm::DenseMap< const Stmt *, CFGBlock * > SMap
Definition: CFGStmtMap.cpp:22
Expr * E
#define X(type, name)
Definition: Value.h:143
std::string Label
Represents a single basic block in a source-level CFG.
Definition: CFG.h:604
ElementList::iterator iterator
Definition: CFG.h:894
iterator begin()
Definition: CFG.h:904
Stmt * getLabel()
Definition: CFG.h:1100
Stmt * getTerminatorStmt()
Definition: CFG.h:1081
iterator end()
Definition: CFG.h:905
Represents a top-level expression in a basic block.
Definition: CFG.h:55
std::optional< T > getAs() const
Convert to the specified CFGElement type, returning std::nullopt if this CFGElement is not of the des...
Definition: CFG.h:109
CFGBlock * getBlock(Stmt *S)
Returns the CFGBlock the specified Stmt* appears in.
Definition: CFGStmtMap.cpp:27
static CFGStmtMap * Build(CFG *C, ParentMap *PM)
Returns a new CFGMap for the given CFG.
Definition: CFGStmtMap.cpp:78
Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt.
Definition: CFG.h:1214
Stmt * getParentIgnoreParens(Stmt *) const
Definition: ParentMap.cpp:141
Stmt - This represents one statement.
Definition: Stmt.h:84
The JSON file list parser is used to communicate input to InstallAPI.