blob: 5f260a214953a9d6738807d84f998931f6b5f1c2 (
plain)
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
//===- CleanupGCCOutput.cpp - Cleanup GCC Output --------------------------===//
//
// This pass is used to cleanup the output of GCC. GCC's output is
// unneccessarily gross for a couple of reasons. This pass does the following
// things to try to clean it up:
//
// * Eliminate names for GCC types that we know can't be needed by the user.
// * Eliminate names for types that are unused in the entire translation unit
// * Fix various problems that we might have in PHI nodes and casts
//
// Note: This code produces dead declarations, it is a good idea to run DCE
// after this pass.
//
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/CleanupGCCOutput.h"
#include "llvm/Analysis/FindUsedTypes.h"
#include "llvm/Module.h"
#include "llvm/SymbolTable.h"
#include "llvm/DerivedTypes.h"
#include "llvm/iPHINode.h"
#include "llvm/iMemory.h"
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
#include "llvm/Support/CFG.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "Support/StatisticReporter.h"
#include <algorithm>
#include <iostream>
static Statistic<> NumTypeSymtabEntriesKilled("cleangcc\t- Number of unused typenames removed from symtab");
using std::vector;
namespace {
struct CleanupGCCOutput : public FunctionPass {
const char *getPassName() const { return "Cleanup GCC Output"; }
// doPassInitialization - For this pass, it removes global symbol table
// entries for primitive types. These are never used for linking in GCC and
// they make the output uglier to look at, so we nuke them.
//
// Also, initialize instance variables.
//
bool doInitialization(Module &M);
// FIXME:
// FIXME: This FunctionPass should be a PASS!
// FIXME:
bool runOnFunction(Function &F) { return false; }
// doPassFinalization - Strip out type names that are unused by the program
bool doFinalization(Module &M);
// getAnalysisUsage - This function needs FindUsedTypes to do its job...
//
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired(FindUsedTypes::ID);
}
};
}
Pass *createCleanupGCCOutputPass() {
return new CleanupGCCOutput();
}
// ShouldNukSymtabEntry - Return true if this module level symbol table entry
// should be eliminated.
//
static inline bool ShouldNukeSymtabEntry(const std::pair<std::string,Value*>&E){
// Nuke all names for primitive types!
if (cast<Type>(E.second)->isPrimitiveType()) return true;
// Nuke all pointers to primitive types as well...
if (const PointerType *PT = dyn_cast<PointerType>(E.second))
if (PT->getElementType()->isPrimitiveType()) return true;
return false;
}
// doInitialization - For this pass, it removes global symbol table
// entries for primitive types. These are never used for linking in GCC and
// they make the output uglier to look at, so we nuke them.
//
bool CleanupGCCOutput::doInitialization(Module &M) {
bool Changed = false;
if (SymbolTable *ST = M.getSymbolTable()) {
// Check the symbol table for superfluous type entries...
//
// Grab the 'type' plane of the module symbol...
SymbolTable::iterator STI = ST->find(Type::TypeTy);
if (STI != ST->end()) {
// Loop over all entries in the type plane...
SymbolTable::VarMap &Plane = STI->second;
for (SymbolTable::VarMap::iterator PI = Plane.begin(); PI != Plane.end();)
if (ShouldNukeSymtabEntry(*PI)) { // Should we remove this entry?
#if MAP_IS_NOT_BRAINDEAD
PI = Plane.erase(PI); // STD C++ Map should support this!
#else
Plane.erase(PI); // Alas, GCC 2.95.3 doesn't *SIGH*
PI = Plane.begin();
#endif
++NumTypeSymtabEntriesKilled;
Changed = true;
} else {
++PI;
}
}
}
return Changed;
}
bool CleanupGCCOutput::doFinalization(Module &M) {
bool Changed = false;
if (SymbolTable *ST = M.getSymbolTable()) {
const std::set<const Type *> &UsedTypes =
getAnalysis<FindUsedTypes>().getTypes();
// Check the symbol table for superfluous type entries that aren't used in
// the program
//
// Grab the 'type' plane of the module symbol...
SymbolTable::iterator STI = ST->find(Type::TypeTy);
if (STI != ST->end()) {
// Loop over all entries in the type plane...
SymbolTable::VarMap &Plane = STI->second;
for (SymbolTable::VarMap::iterator PI = Plane.begin(); PI != Plane.end();)
if (!UsedTypes.count(cast<Type>(PI->second))) {
#if MAP_IS_NOT_BRAINDEAD
PI = Plane.erase(PI); // STD C++ Map should support this!
#else
Plane.erase(PI); // Alas, GCC 2.95.3 doesn't *SIGH*
PI = Plane.begin(); // N^2 algorithms are fun. :(
#endif
Changed = true;
} else {
++PI;
}
}
}
return Changed;
}
|
