6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-26 07:24:25 +00:00
Code Issues Projects Releases Wiki Activity

* Rename UnlinkUndistinguishableShadowNodes & RemoveUnreachableShadowNodes

Browse Source 
to reflect that they can eliminate arbitrary nodes.
* Rename the ShadowNodeEliminate.cpp file to EliminateNodes.cpp for the
  same reason


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2020 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2002-03-28 19:16:48 +00:00
parent d38cadb13d
commit 7d093d4231
3 changed files with 16 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/Analysis/DataStructure/ComputeClosure.cpp
View File

@ -193,10 +193,10 @@ void FunctionDSGraph::computeClosure(const DataStructure &DS) {
// Eliminate shadow nodes that are not distinguishable from some other // Eliminate shadow nodes that are not distinguishable from some other
// node in the graph... // node in the graph...
// //
Changed = UnlinkUndistinguishableShadowNodes(); Changed = UnlinkUndistinguishableNodes();
// Eliminate shadow nodes that are now extraneous due to linking... // Eliminate shadow nodes that are now extraneous due to linking...
Changed |= RemoveUnreachableShadowNodes(); Changed |= RemoveUnreachableNodes();
} }
//if (F == Func) return; // Only do one self inlining //if (F == Func) return; // Only do one self inlining

23
lib/Analysis/DataStructure/EliminateNodes.cpp
View File

@ -1,16 +1,17 @@
//===- ShadowNodeEliminate.cpp - Optimize away shadow nodes ---------------===// //===- EliminateNodes.cpp - Prune unneccesary nodes in the graph ----------===//
// //
// This file contains two shadow node optimizations: // This file contains two node optimizations:
// 1. UnlinkUndistinguishableShadowNodes - Often, after unification, shadow // 1. UnlinkUndistinguishableNodes - Often, after unification, shadow
// nodes are left around that should not exist anymore. An example is when // nodes are left around that should not exist anymore. An example is when
// a shadow gets unified with a 'new' node, the following graph gets // a shadow gets unified with a 'new' node, the following graph gets
// generated: %X -> Shadow, %X -> New. Since all of the edges to the // generated: %X -> Shadow, %X -> New. Since all of the edges to the
// shadow node also all go to the New node, we can eliminate the shadow. // shadow node also all go to the New node, we can eliminate the shadow.
// //
// 2. RemoveUnreachableShadowNodes - Remove shadow nodes that are not // 2. RemoveUnreachableNodes - Remove shadow and allocation nodes that are not
// reachable from some other node in the graph. Unreachable shadow nodes // reachable from some other node in the graph. Unreachable nodes are left
// are left lying around because other transforms don't go to the trouble // lying around often because a method only refers to some allocations with
// or removing them, since this pass exists. // scalar values or an alloca, then when it is inlined, these references
// disappear and the nodes become homeless and prunable.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -57,7 +58,7 @@ bool ShadowDSNode::isEquivalentTo(DSNode *Node) const {
// has exactly the same incoming links to it and if the node considers itself // has exactly the same incoming links to it and if the node considers itself
// to be the same as the other node... // to be the same as the other node...
// //
bool isIndistinguishableNode(DSNode *DN) { static bool isIndistinguishableNode(DSNode *DN) {
if (DN->getReferrers().empty()) { // No referrers... if (DN->getReferrers().empty()) { // No referrers...
if (isa<ShadowDSNode>(DN) || isa<AllocDSNode>(DN)) if (isa<ShadowDSNode>(DN) || isa<AllocDSNode>(DN))
return true; // Node is trivially dead return true; // Node is trivially dead
@ -127,10 +128,10 @@ bool removeIndistinguishableNode(std::vector<NodeTy*> &Nodes) {
return Changed; return Changed;
} }
// UnlinkUndistinguishableShadowNodes - Eliminate shadow nodes that are not // UnlinkUndistinguishableNodes - Eliminate shadow nodes that are not
// distinguishable from some other node in the graph... // distinguishable from some other node in the graph...
// //
bool FunctionDSGraph::UnlinkUndistinguishableShadowNodes() { bool FunctionDSGraph::UnlinkUndistinguishableNodes() {
// Loop over all of the shadow nodes, checking to see if they are // Loop over all of the shadow nodes, checking to see if they are
// indistinguishable from some other node. If so, eliminate the node! // indistinguishable from some other node. If so, eliminate the node!
// //
@ -192,7 +193,7 @@ static void MarkReferredNodesReachable(DSNode *N,
AllocNodes, ReachableAllocNodes); AllocNodes, ReachableAllocNodes);
} }
bool FunctionDSGraph::RemoveUnreachableShadowNodes() { bool FunctionDSGraph::RemoveUnreachableNodes() {
bool Changed = false; bool Changed = false;
while (1) { while (1) {

4
lib/Analysis/DataStructure/FunctionRepBuilder.cpp
View File

@ -339,10 +339,10 @@ FunctionDSGraph::FunctionDSGraph(Function *F) : Func(F) {
// Eliminate shadow nodes that are not distinguishable from some other // Eliminate shadow nodes that are not distinguishable from some other
// node in the graph... // node in the graph...
// //
Changed = UnlinkUndistinguishableShadowNodes(); Changed = UnlinkUndistinguishableNodes();
// Eliminate shadow nodes that are now extraneous due to linking... // Eliminate shadow nodes that are now extraneous due to linking...
Changed |= RemoveUnreachableShadowNodes(); Changed |= RemoveUnreachableNodes();
} }
} }