From 5653322e729fd2016556fd1d5e54cde20d3012d8 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Tue, 3 Jul 2007 23:51:19 +0000 Subject: [PATCH] Add support for performing GVNPRE on GEP instructions. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@37862 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Scalar/GVNPRE.cpp | 167 ++++++++++++++++++++++++++++++- test/Transforms/GVNPRE/gep.ll | 17 ++++ 2 files changed, 179 insertions(+), 5 deletions(-) create mode 100644 test/Transforms/GVNPRE/gep.ll diff --git a/lib/Transforms/Scalar/GVNPRE.cpp b/lib/Transforms/Scalar/GVNPRE.cpp index d290b9c4abe..be86f3a797f 100644 --- a/lib/Transforms/Scalar/GVNPRE.cpp +++ b/lib/Transforms/Scalar/GVNPRE.cpp @@ -477,6 +477,19 @@ uint32_t ValueTable::lookup_or_add(Value* V) { } else if (CastInst* U = dyn_cast(V)) { Expression e = create_expression(U); + std::map::iterator EI = expressionNumbering.find(e); + if (EI != expressionNumbering.end()) { + valueNumbering.insert(std::make_pair(V, EI->second)); + return EI->second; + } else { + expressionNumbering.insert(std::make_pair(e, nextValueNumber)); + valueNumbering.insert(std::make_pair(V, nextValueNumber)); + + return nextValueNumber++; + } + } else if (GetElementPtrInst* U = dyn_cast(V)) { + Expression e = create_expression(U); + std::map::iterator EI = expressionNumbering.find(e); if (EI != expressionNumbering.end()) { valueNumbering.insert(std::make_pair(V, EI->second)); @@ -798,6 +811,48 @@ Value* GVNPRE::phi_translate(Value* V, BasicBlock* pred, BasicBlock* succ) { } } + // Varargs operators + } else if (GetElementPtrInst* U = dyn_cast(V)) { + Value* newOp1 = 0; + if (isa(U->getPointerOperand())) + newOp1 = phi_translate(U->getPointerOperand(), pred, succ); + else + newOp1 = U->getPointerOperand(); + + if (newOp1 == 0) + return 0; + + bool changed_idx = false; + std::vector newIdx; + for (GetElementPtrInst::op_iterator I = U->idx_begin(), E = U->idx_end(); + I != E; ++I) + if (isa(*I)) { + Value* newVal = phi_translate(*I, pred, succ); + newIdx.push_back(newVal); + if (newVal != *I) + changed_idx = true; + } else { + newIdx.push_back(*I); + } + + if (newOp1 != U->getPointerOperand() || changed_idx) { + Instruction* newVal = new GetElementPtrInst(U->getPointerOperand(), + &newIdx[0], newIdx.size(), + U->getName()+".expr"); + + uint32_t v = VN.lookup_or_add(newVal); + + Value* leader = find_leader(availableOut[pred], v); + if (leader == 0) { + createdExpressions.push_back(newVal); + return newVal; + } else { + VN.erase(newVal); + delete newVal; + return leader; + } + } + // PHI Nodes } else if (PHINode* P = dyn_cast(V)) { if (P->getParent() == succ) @@ -900,6 +955,26 @@ void GVNPRE::clean(SmallPtrSet& set, BitVector& presentInSet) { set.erase(U); presentInSet.flip(VN.lookup(U)); } + + // Handle varargs ops + } else if (GetElementPtrInst* U = dyn_cast(v)) { + bool ptrValid = !isa(U->getPointerOperand()); + ptrValid |= presentInSet.test(VN.lookup(U->getPointerOperand())); + if (ptrValid) + ptrValid = !dependsOnInvoke(U->getPointerOperand()); + + bool varValid = true; + for (GetElementPtrInst::op_iterator I = U->idx_begin(), E = U->idx_end(); + I != E; ++I) + if (varValid) { + varValid &= !isa(*I) || presentInSet.test(VN.lookup(*I)); + varValid &= !dependsOnInvoke(*I); + } + + if (!ptrValid || !varValid) { + set.erase(U); + presentInSet.flip(VN.lookup(U)); + } } } } @@ -972,6 +1047,31 @@ void GVNPRE::topo_sort(SmallPtrSet& set, std::vector& vec) { stack.pop_back(); } + // Handle vararg ops + } else if (GetElementPtrInst* U = dyn_cast(e)) { + Value* p = find_leader(set, VN.lookup(U->getPointerOperand())); + + if (p != 0 && isa(p) && + visited.count(p) == 0) + stack.push_back(p); + else { + bool push_va = false; + for (GetElementPtrInst::op_iterator I = U->idx_begin(), + E = U->idx_end(); I != E; ++I) { + Value * v = find_leader(set, VN.lookup(*I)); + if (v != 0 && isa(v) && visited.count(v) == 0) { + stack.push_back(v); + push_va = true; + } + } + + if (!push_va) { + vec.push_back(e); + visited.insert(e); + stack.pop_back(); + } + } + // Handle opaque ops } else { visited.insert(e); @@ -1022,7 +1122,7 @@ bool GVNPRE::elimination() { if (isa(BI) || isa(BI) || isa(BI) || isa(BI) || isa(BI) || isa(BI) || - isa(BI)) { + isa(BI) || isa(BI)) { Value *leader = find_leader(availableOut[BB], VN.lookup(BI)); if (leader != 0) @@ -1160,6 +1260,34 @@ void GVNPRE::buildsets_availout(BasicBlock::iterator I, expNumbers.set(num); } + // Handle vararg ops + } else if (GetElementPtrInst* U = dyn_cast(I)) { + Value* ptrValue = U->getPointerOperand(); + + VN.lookup_or_add(U); + + unsigned num = VN.lookup_or_add(U); + expNumbers.resize(VN.size()); + availNumbers.resize(VN.size()); + + if (isa(ptrValue)) + if (!expNumbers.test(VN.lookup(ptrValue))) { + currExps.insert(ptrValue); + expNumbers.set(VN.lookup(ptrValue)); + } + + for (GetElementPtrInst::op_iterator OI = U->idx_begin(), OE = U->idx_end(); + OI != OE; ++OI) + if (isa(*OI) && !expNumbers.test(VN.lookup(*OI))) { + currExps.insert(*OI); + expNumbers.set(VN.lookup(*OI)); + } + + if (!expNumbers.test(VN.lookup(U))) { + currExps.insert(U); + expNumbers.set(num); + } + // Handle opaque ops } else if (!I->isTerminator()){ VN.lookup_or_add(I); @@ -1373,7 +1501,8 @@ void GVNPRE::insertion_pre(Value* e, BasicBlock* BB, isa(U->getOperand(0)) || isa(U->getOperand(0)) || isa(U->getOperand(0)) || - isa(U->getOperand(0))) + isa(U->getOperand(0)) || + isa(U->getOperand(0))) s1 = find_leader(availableOut[*PI], VN.lookup(U->getOperand(0))); else s1 = U->getOperand(0); @@ -1392,7 +1521,8 @@ void GVNPRE::insertion_pre(Value* e, BasicBlock* BB, isa(U->getOperand(1)) || isa(U->getOperand(1)) || isa(U->getOperand(1)) || - isa(U->getOperand(1))) { + isa(U->getOperand(1)) || + isa(U->getOperand(1))) { s2 = find_leader(availableOut[*PI], VN.lookup(U->getOperand(1))); } else { s2 = U->getOperand(1); @@ -1409,12 +1539,34 @@ void GVNPRE::insertion_pre(Value* e, BasicBlock* BB, isa(U->getOperand(2)) || isa(U->getOperand(2)) || isa(U->getOperand(2)) || - isa(U->getOperand(2))) { + isa(U->getOperand(2)) || + isa(U->getOperand(2))) { s3 = find_leader(availableOut[*PI], VN.lookup(U->getOperand(2))); } else { s3 = U->getOperand(2); } + // Vararg operators + std::vector sVarargs; + if (GetElementPtrInst* G = dyn_cast(U)) { + for (GetElementPtrInst::op_iterator OI = G->idx_begin(), + OE = G->idx_end(); OI != OE; ++OI) { + if (isa(*OI) || + isa(*OI) || + isa(*OI) || + isa(*OI) || + isa(*OI) || + isa(*OI) || + isa(*OI) || + isa(*OI)) { + sVarargs.push_back(find_leader(availableOut[*PI], + VN.lookup(*OI))); + } else { + sVarargs.push_back(*OI); + } + } + } + Value* newVal = 0; if (BinaryOperator* BO = dyn_cast(U)) newVal = BinaryOperator::create(BO->getOpcode(), s1, s2, @@ -1441,6 +1593,10 @@ void GVNPRE::insertion_pre(Value* e, BasicBlock* BB, newVal = CastInst::create(C->getOpcode(), s1, C->getType(), C->getName()+".gvnpre", (*PI)->getTerminator()); + else if (GetElementPtrInst* G = dyn_cast(U)) + newVal = new GetElementPtrInst(s1, &sVarargs[0], sVarargs.size(), + G->getName()+".gvnpre", + (*PI)->getTerminator()); VN.add(newVal, VN.lookup(U)); @@ -1487,7 +1643,8 @@ unsigned GVNPRE::insertion_mergepoint(std::vector& workList, if (isa(e) || isa(e) || isa(e) || isa(e) || - isa(e) || isa(e) || isa(e)) { + isa(e) || isa(e) || isa(e) || + isa(e)) { if (find_leader(availableOut[D->getIDom()->getBlock()], VN.lookup(e)) != 0) continue; diff --git a/test/Transforms/GVNPRE/gep.ll b/test/Transforms/GVNPRE/gep.ll new file mode 100644 index 00000000000..34bc4c79ab1 --- /dev/null +++ b/test/Transforms/GVNPRE/gep.ll @@ -0,0 +1,17 @@ +; RUN: llvm-as < %s | opt -gvnpre | llvm-dis | grep b.gvnpre + +define i32 @extract({ i32 }* %P) { +entry: ; preds = %cond_false, %entry + br i1 true, label %cond_true, label %cond_false + +cond_true: + br label %end + +cond_false: + %a = getelementptr { i32 }* %P, i32 0, i32 0 + br label %end + +end: + %b = getelementptr { i32 }* %P, i32 0, i32 0 + ret i32 0 +}