RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-04-06 15:21:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Can't spell.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@29383 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng 2006-07-28 06:33:41 +00:00
parent ba27731f35
commit 37e1803a66
1 changed files with 15 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
lib/Target/X86/X86ISelDAGToDAG.cpp
View File

@ -100,7 +100,7 @@ namespace {
X86Lowering(*TM.getTargetLowering()), X86Lowering(*TM.getTargetLowering()),
Subtarget(&TM.getSubtarget<X86Subtarget>()), Subtarget(&TM.getSubtarget<X86Subtarget>()),
DAGSize(0), TopOrder(NULL), IdToOrder(NULL), DAGSize(0), TopOrder(NULL), IdToOrder(NULL),
RMRange(NULL), ReachibilityMatrix(NULL) {} RMRange(NULL), ReachabilityMatrix(NULL) {}
virtual bool runOnFunction(Function &Fn) { virtual bool runOnFunction(Function &Fn) {
// Make sure we re-emit a set of the global base reg if necessary // Make sure we re-emit a set of the global base reg if necessary
@ -125,7 +125,7 @@ namespace {
private: private:
void DetermineTopologicalOrdering(); void DetermineTopologicalOrdering();
void DetermineReachibility(SDNode *f, SDNode *t); void DetermineReachability(SDNode *f, SDNode *t);
void Select(SDOperand &Result, SDOperand N); void Select(SDOperand &Result, SDOperand N);
@ -197,18 +197,18 @@ namespace {
/// particular source node. /// particular source node.
unsigned *RMRange; unsigned *RMRange;
/// ReachibilityMatrix - A N x N matrix representing all pairs reachibility /// ReachabilityMatrix - A N x N matrix representing all pairs reachibility
/// information. One bit per potential edge. /// information. One bit per potential edge.
unsigned char *ReachibilityMatrix; unsigned char *ReachabilityMatrix;
inline void setReachable(SDNode *f, SDNode *t) { inline void setReachable(SDNode *f, SDNode *t) {
unsigned Idx = f->getNodeId() * DAGSize + t->getNodeId(); unsigned Idx = f->getNodeId() * DAGSize + t->getNodeId();
ReachibilityMatrix[Idx / 8] |= 1 << (Idx % 8); ReachabilityMatrix[Idx / 8] |= 1 << (Idx % 8);
} }
inline bool isReachable(SDNode *f, SDNode *t) { inline bool isReachable(SDNode *f, SDNode *t) {
unsigned Idx = f->getNodeId() * DAGSize + t->getNodeId(); unsigned Idx = f->getNodeId() * DAGSize + t->getNodeId();
return ReachibilityMatrix[Idx / 8] & (1 << (Idx % 8)); return ReachabilityMatrix[Idx / 8] & (1 << (Idx % 8));
} }
/// UnfoldableSet - An boolean array representing nodes which have been /// UnfoldableSet - An boolean array representing nodes which have been
@ -239,7 +239,7 @@ bool X86DAGToDAGISel::CanBeFoldedBy(SDNode *N, SDNode *U) {
// If U use can somehow reach N through another path then U can't fold N or // If U use can somehow reach N through another path then U can't fold N or
// it will create a cycle. e.g. In the following diagram, U can reach N // it will create a cycle. e.g. In the following diagram, U can reach N
// through X. If N is foledd into into U, then X is both a predecessor and // through X. If N is folded into into U, then X is both a predecessor and
// a successor of U. // a successor of U.
// //
// [ N ] // [ N ]
@ -249,7 +249,7 @@ bool X86DAGToDAGISel::CanBeFoldedBy(SDNode *N, SDNode *U) {
// / [X] // / [X]
// | ^ // | ^
// [U]--------| // [U]--------|
DetermineReachibility(U, N); DetermineReachability(U, N);
assert(isReachable(U, N) && "Attempting to fold a non-operand node?"); assert(isReachable(U, N) && "Attempting to fold a non-operand node?");
for (SDNode::op_iterator I = U->op_begin(), E = U->op_end(); I != E; ++I) { for (SDNode::op_iterator I = U->op_begin(), E = U->op_end(); I != E; ++I) {
SDNode *P = I->Val; SDNode *P = I->Val;
@ -297,13 +297,13 @@ void X86DAGToDAGISel::DetermineTopologicalOrdering() {
} }
} }
/// DetermineReachibility - Determine reachibility between all pairs of nodes /// DetermineReachability - Determine reachibility between all pairs of nodes
/// between f and t in topological order. /// between f and t in topological order.
void X86DAGToDAGISel::DetermineReachibility(SDNode *f, SDNode *t) { void X86DAGToDAGISel::DetermineReachability(SDNode *f, SDNode *t) {
if (!ReachibilityMatrix) { if (!ReachabilityMatrix) {
unsigned RMSize = (DAGSize * DAGSize + 7) / 8; unsigned RMSize = (DAGSize * DAGSize + 7) / 8;
ReachibilityMatrix = new unsigned char[RMSize]; ReachabilityMatrix = new unsigned char[RMSize];
memset(ReachibilityMatrix, 0, RMSize); memset(ReachabilityMatrix, 0, RMSize);
} }
int Idf = f->getNodeId(); int Idf = f->getNodeId();
@ -360,12 +360,12 @@ void X86DAGToDAGISel::InstructionSelectBasicBlock(SelectionDAG &DAG) {
DEBUG(std::cerr << "===== Instruction selection ends:\n"); DEBUG(std::cerr << "===== Instruction selection ends:\n");
#endif #endif
delete[] ReachibilityMatrix; delete[] ReachabilityMatrix;
delete[] TopOrder; delete[] TopOrder;
delete[] IdToOrder; delete[] IdToOrder;
delete[] RMRange; delete[] RMRange;
delete[] UnfoldableSet; delete[] UnfoldableSet;
ReachibilityMatrix = NULL; ReachabilityMatrix = NULL;
TopOrder = NULL; TopOrder = NULL;
IdToOrder = RMRange = NULL; IdToOrder = RMRange = NULL;
UnfoldableSet = NULL; UnfoldableSet = NULL;