6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-29 10:32:47 +00:00
Code Issues Projects Releases Wiki Activity

Remove generic routines to Support/SetOperations.h

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1715 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-02-05 03:35:31 +00:00
parent edcea4ba4a
commit eb5230c4f9
4 changed files with 2 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
include/llvm/Analysis/LiveVar/ValueSet.h
View File

@ -16,39 +16,4 @@ ostream &operator<<(ostream &out, RAV Val);
typedef std::set<const Value*> ValueSet;
void printSet(const ValueSet &S);
// set_union(A, B) - Compute A := A u B, return whether A changed.
//
template <class E>
bool set_union(std::set<E> &S1, const std::set<E> &S2) {
bool Changed = false;
for (std::set<E>::const_iterator SI = S2.begin(), SE = S2.end();
SI != SE; ++SI)
if (S1.insert(*SI).second)
Changed = true;
return Changed;
}
// set_difference(A, B) - Return A - B
//
template <class E>
std::set<E> set_difference(const std::set<E> &S1, const std::set<E> &S2) {
std::set<E> Result;
for (std::set<E>::const_iterator SI = S1.begin(), SE = S1.end();
SI != SE; ++SI)
if (S2.find(*SI) == S2.end()) // if the element is not in set2
Result.insert(*SI);
return Result;
}
// set_subtract(A, B) - Compute A := A - B
//
template <class E>
void set_subtract(std::set<E> &S1, const std::set<E> &S2) {
for (std::set<E>::const_iterator SI = S2.begin() ; SI != S2.end(); ++SI)
S1.erase(*SI);
}
#endif

35
include/llvm/CodeGen/ValueSet.h
View File

@ -16,39 +16,4 @@ ostream &operator<<(ostream &out, RAV Val);
typedef std::set<const Value*> ValueSet;
void printSet(const ValueSet &S);
// set_union(A, B) - Compute A := A u B, return whether A changed.
//
template <class E>
bool set_union(std::set<E> &S1, const std::set<E> &S2) {
bool Changed = false;
for (std::set<E>::const_iterator SI = S2.begin(), SE = S2.end();
SI != SE; ++SI)
if (S1.insert(*SI).second)
Changed = true;
return Changed;
}
// set_difference(A, B) - Return A - B
//
template <class E>
std::set<E> set_difference(const std::set<E> &S1, const std::set<E> &S2) {
std::set<E> Result;
for (std::set<E>::const_iterator SI = S1.begin(), SE = S1.end();
SI != SE; ++SI)
if (S2.find(*SI) == S2.end()) // if the element is not in set2
Result.insert(*SI);
return Result;
}
// set_subtract(A, B) - Compute A := A - B
//
template <class E>
void set_subtract(std::set<E> &S1, const std::set<E> &S2) {
for (std::set<E>::const_iterator SI = S2.begin() ; SI != S2.end(); ++SI)
S1.erase(*SI);
}
#endif

19
lib/Analysis/PostDominators.cpp
View File

@ -9,27 +9,10 @@
#include "llvm/Method.h"
#include "Support/DepthFirstIterator.h"
#include "Support/STLExtras.h"
#include "Support/SetOperations.h"
#include <algorithm>
using std::set;
//===----------------------------------------------------------------------===//
// Helper Template
//===----------------------------------------------------------------------===//
// set_intersect - Identical to set_intersection, except that it works on
// set<>'s and is nicer to use. Functionally, this iterates through S1,
// removing elements that are not contained in S2.
//
template <class Ty, class Ty2>
void set_intersect(set<Ty> &S1, const set<Ty2> &S2) {
for (typename set<Ty>::iterator I = S1.begin(); I != S1.end();) {
const Ty &E = *I;
++I;
if (!S2.count(E)) S1.erase(E); // Erase element if not in S2
}
}
//===----------------------------------------------------------------------===//
// DominatorSet Implementation
//===----------------------------------------------------------------------===//

19
lib/VMCore/Dominators.cpp
View File

@ -9,27 +9,10 @@
#include "llvm/Method.h"
#include "Support/DepthFirstIterator.h"
#include "Support/STLExtras.h"
#include "Support/SetOperations.h"
#include <algorithm>
using std::set;
//===----------------------------------------------------------------------===//
// Helper Template
//===----------------------------------------------------------------------===//
// set_intersect - Identical to set_intersection, except that it works on
// set<>'s and is nicer to use. Functionally, this iterates through S1,
// removing elements that are not contained in S2.
//
template <class Ty, class Ty2>
void set_intersect(set<Ty> &S1, const set<Ty2> &S2) {
for (typename set<Ty>::iterator I = S1.begin(); I != S1.end();) {
const Ty &E = *I;
++I;
if (!S2.count(E)) S1.erase(E); // Erase element if not in S2
}
}
//===----------------------------------------------------------------------===//
// DominatorSet Implementation
//===----------------------------------------------------------------------===//