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

MergeFunctions Pass, introduced total ordering among GEP operations.

Browse Source 
Patch replaces old isEquivalentGEP implementation, and changes type of
comparison result from bool (equal or not) to {-1, 0, 1} (less, equal, greater).

This patch belongs to patch series that improves MergeFunctions
performance time from O(N*N) to O(N*log(N)).



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@208976 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Stepan Dyatkovskiy 2014-05-16 11:55:02 +00:00
parent b5ce464b4f
commit 75d44de642
1 changed files with 41 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
lib/Transforms/IPO/MergeFunctions.cpp
View File

@ -335,7 +335,22 @@ private:
} }
/// Compare two GEPs for equivalent pointer arithmetic. /// Compare two GEPs for equivalent pointer arithmetic.
bool isEquivalentGEP(const GEPOperator *GEP1, const GEPOperator *GEP2); /// Parts to be compared for each comparison stage,
/// most significant stage first:
/// 1. Address space. As numbers.
/// 2. Constant offset, (if "DataLayout *DL" field is not NULL,
/// using GEPOperator::accumulateConstantOffset method).
/// 3. Pointer operand type (using cmpType method).
/// 4. Number of operands.
/// 5. Compare operands, using cmpValues method.
int cmpGEP(const GEPOperator *GEPL, const GEPOperator *GEPR);
int cmpGEP(const GetElementPtrInst *GEPL, const GetElementPtrInst *GEPR) {
return cmpGEP(cast<GEPOperator>(GEPL), cast<GEPOperator>(GEPR));
}
bool isEquivalentGEP(const GEPOperator *GEP1, const GEPOperator *GEP2) {
return cmpGEP(GEP1, GEP2) == 0;
}
bool isEquivalentGEP(const GetElementPtrInst *GEP1, bool isEquivalentGEP(const GetElementPtrInst *GEP1,
const GetElementPtrInst *GEP2) { const GetElementPtrInst *GEP2) {
return isEquivalentGEP(cast<GEPOperator>(GEP1), cast<GEPOperator>(GEP2)); return isEquivalentGEP(cast<GEPOperator>(GEP1), cast<GEPOperator>(GEP2));
@ -858,36 +873,39 @@ int FunctionComparator::cmpOperation(const Instruction *L,
} }
// Determine whether two GEP operations perform the same underlying arithmetic. // Determine whether two GEP operations perform the same underlying arithmetic.
bool FunctionComparator::isEquivalentGEP(const GEPOperator *GEP1, // Read method declaration comments for more details.
const GEPOperator *GEP2) { int FunctionComparator::cmpGEP(const GEPOperator *GEPL,
unsigned AS = GEP1->getPointerAddressSpace(); const GEPOperator *GEPR) {
if (AS != GEP2->getPointerAddressSpace())
return false;
unsigned int ASL = GEPL->getPointerAddressSpace();
unsigned int ASR = GEPR->getPointerAddressSpace();
if (int Res = cmpNumbers(ASL, ASR))
return Res;
// When we have target data, we can reduce the GEP down to the value in bytes
// added to the address.
if (DL) { if (DL) {
// When we have target data, we can reduce the GEP down to the value in bytes unsigned BitWidth = DL->getPointerSizeInBits(ASL);
// added to the address. APInt OffsetL(BitWidth, 0), OffsetR(BitWidth, 0);
unsigned BitWidth = DL ? DL->getPointerSizeInBits(AS) : 1; if (GEPL->accumulateConstantOffset(*DL, OffsetL) &&
APInt Offset1(BitWidth, 0), Offset2(BitWidth, 0); GEPR->accumulateConstantOffset(*DL, OffsetR))
if (GEP1->accumulateConstantOffset(*DL, Offset1) && return cmpAPInt(OffsetL, OffsetR);
GEP2->accumulateConstantOffset(*DL, Offset2)) {
return Offset1 == Offset2;
}
} }
if (GEP1->getPointerOperand()->getType() != if (int Res = cmpNumbers((uint64_t)GEPL->getPointerOperand()->getType(),
GEP2->getPointerOperand()->getType()) (uint64_t)GEPR->getPointerOperand()->getType()))
return false; return Res;
if (GEP1->getNumOperands() != GEP2->getNumOperands()) if (int Res = cmpNumbers(GEPL->getNumOperands(), GEPR->getNumOperands()))
return false; return Res;
for (unsigned i = 0, e = GEP1->getNumOperands(); i != e; ++i) { for (unsigned i = 0, e = GEPL->getNumOperands(); i != e; ++i) {
if (!enumerate(GEP1->getOperand(i), GEP2->getOperand(i))) if (int Res = cmpValues(GEPL->getOperand(i), GEPR->getOperand(i)))
return false; return Res;
} }
return true; return 0;
} }
/// Compare two values used by the two functions under pair-wise comparison. If /// Compare two values used by the two functions under pair-wise comparison. If