1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
//===-- DomPrinter.h - Dom printer external interface ------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines external functions that can be called to explicitly
// instantiate the dominance tree printer.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_DOMPRINTER_H
#define LLVM_ANALYSIS_DOMPRINTER_H
#include "llvm/Analysis/DOTGraphTraitsPass.h"
#include "llvm/Analysis/PostDominators.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/PassManager.h"
namespace llvm {
template <>
struct DOTGraphTraits<DomTreeNode *> : public DefaultDOTGraphTraits {
DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
std::string getNodeLabel(DomTreeNode *Node, DomTreeNode *Graph) {
BasicBlock *BB = Node->getBlock();
if (!BB)
return "Post dominance root node";
if (isSimple())
return DOTGraphTraits<DOTFuncInfo *>::getSimpleNodeLabel(BB, nullptr);
return DOTGraphTraits<DOTFuncInfo *>::getCompleteNodeLabel(BB, nullptr);
}
};
template <>
struct DOTGraphTraits<DominatorTree *>
: public DOTGraphTraits<DomTreeNode *> {
DOTGraphTraits(bool isSimple = false)
: DOTGraphTraits<DomTreeNode *>(isSimple) {}
static std::string getGraphName(DominatorTree *DT) {
return "Dominator tree";
}
std::string getNodeLabel(DomTreeNode *Node, DominatorTree *G) {
return DOTGraphTraits<DomTreeNode *>::getNodeLabel(Node,
G->getRootNode());
}
};
template<>
struct DOTGraphTraits<PostDominatorTree *>
: public DOTGraphTraits<DomTreeNode*> {
DOTGraphTraits (bool isSimple=false)
: DOTGraphTraits<DomTreeNode*>(isSimple) {}
static std::string getGraphName(PostDominatorTree *DT) {
return "Post dominator tree";
}
std::string getNodeLabel(DomTreeNode *Node,
PostDominatorTree *G) {
return DOTGraphTraits<DomTreeNode*>::getNodeLabel(Node, G->getRootNode());
}
};
struct DomViewer final : DOTGraphTraitsViewer<DominatorTreeAnalysis, false> {
DomViewer() : DOTGraphTraitsViewer<DominatorTreeAnalysis, false>("dom") {}
};
struct DomOnlyViewer final : DOTGraphTraitsViewer<DominatorTreeAnalysis, true> {
DomOnlyViewer()
: DOTGraphTraitsViewer<DominatorTreeAnalysis, true>("domonly") {}
};
struct PostDomViewer final
: DOTGraphTraitsViewer<PostDominatorTreeAnalysis, false> {
PostDomViewer()
: DOTGraphTraitsViewer<PostDominatorTreeAnalysis, false>("postdom") {}
};
struct PostDomOnlyViewer final
: DOTGraphTraitsViewer<PostDominatorTreeAnalysis, true> {
PostDomOnlyViewer()
: DOTGraphTraitsViewer<PostDominatorTreeAnalysis, true>("postdomonly") {}
};
struct DomPrinter final : DOTGraphTraitsPrinter<DominatorTreeAnalysis, false> {
DomPrinter() : DOTGraphTraitsPrinter<DominatorTreeAnalysis, false>("dom") {}
};
struct DomOnlyPrinter final
: DOTGraphTraitsPrinter<DominatorTreeAnalysis, true> {
DomOnlyPrinter()
: DOTGraphTraitsPrinter<DominatorTreeAnalysis, true>("domonly") {}
};
struct PostDomPrinter final
: DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, false> {
PostDomPrinter()
: DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, false>("postdom") {}
};
struct PostDomOnlyPrinter final
: DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, true> {
PostDomOnlyPrinter()
: DOTGraphTraitsPrinter<PostDominatorTreeAnalysis, true>("postdomonly") {}
};
} // namespace llvm
namespace llvm {
class FunctionPass;
FunctionPass *createDomPrinterWrapperPassPass();
FunctionPass *createDomOnlyPrinterWrapperPassPass();
FunctionPass *createDomViewerWrapperPassPass();
FunctionPass *createDomOnlyViewerWrapperPassPass();
FunctionPass *createPostDomPrinterWrapperPassPass();
FunctionPass *createPostDomOnlyPrinterWrapperPassPass();
FunctionPass *createPostDomViewerWrapperPassPass();
FunctionPass *createPostDomOnlyViewerWrapperPassPass();
} // End llvm namespace
#endif
|
