diff options
Diffstat (limited to 'lib/Transforms/Scalar/InstructionCombining.cpp')
-rw-r--r-- | lib/Transforms/Scalar/InstructionCombining.cpp | 322 |
1 files changed, 164 insertions, 158 deletions
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 6032ab9..7092989 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -36,11 +36,11 @@ namespace { // Worklist of all of the instructions that need to be simplified. std::vector<Instruction*> WorkList; - void AddUsesToWorkList(Instruction *I) { + void AddUsesToWorkList(Instruction &I) { // The instruction was simplified, add all users of the instruction to // the work lists because they might get more simplified now... // - for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); + for (Value::use_iterator UI = I.use_begin(), UE = I.use_end(); UI != UE; ++UI) WorkList.push_back(cast<Instruction>(*UI)); } @@ -48,7 +48,7 @@ namespace { public: const char *getPassName() const { return "Instruction Combining"; } - virtual bool runOnFunction(Function *F); + virtual bool runOnFunction(Function &F); virtual void getAnalysisUsage(AnalysisUsage &AU) const { AU.preservesCFG(); @@ -61,37 +61,37 @@ namespace { // I - Change was made, I is still valid // otherwise - Change was made, replace I with returned instruction // - Instruction *visitNot(UnaryOperator *I); - Instruction *visitAdd(BinaryOperator *I); - Instruction *visitSub(BinaryOperator *I); - Instruction *visitMul(BinaryOperator *I); - Instruction *visitDiv(BinaryOperator *I); - Instruction *visitRem(BinaryOperator *I); - Instruction *visitAnd(BinaryOperator *I); - Instruction *visitOr (BinaryOperator *I); - Instruction *visitXor(BinaryOperator *I); - Instruction *visitSetCondInst(BinaryOperator *I); - Instruction *visitShiftInst(Instruction *I); - Instruction *visitCastInst(CastInst *CI); - Instruction *visitPHINode(PHINode *PN); - Instruction *visitGetElementPtrInst(GetElementPtrInst *GEP); - Instruction *visitMemAccessInst(MemAccessInst *MAI); + Instruction *visitNot(UnaryOperator &I); + Instruction *visitAdd(BinaryOperator &I); + Instruction *visitSub(BinaryOperator &I); + Instruction *visitMul(BinaryOperator &I); + Instruction *visitDiv(BinaryOperator &I); + Instruction *visitRem(BinaryOperator &I); + Instruction *visitAnd(BinaryOperator &I); + Instruction *visitOr (BinaryOperator &I); + Instruction *visitXor(BinaryOperator &I); + Instruction *visitSetCondInst(BinaryOperator &I); + Instruction *visitShiftInst(Instruction &I); + Instruction *visitCastInst(CastInst &CI); + Instruction *visitPHINode(PHINode &PN); + Instruction *visitGetElementPtrInst(GetElementPtrInst &GEP); + Instruction *visitMemAccessInst(MemAccessInst &MAI); // visitInstruction - Specify what to return for unhandled instructions... - Instruction *visitInstruction(Instruction *I) { return 0; } + Instruction *visitInstruction(Instruction &I) { return 0; } }; } -Instruction *InstCombiner::visitNot(UnaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitNot(UnaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... // not (not X) = X - if (Instruction *Op = dyn_cast<Instruction>(I->getOperand(0))) + if (Instruction *Op = dyn_cast<Instruction>(I.getOperand(0))) if (Op->getOpcode() == Instruction::Not) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op->getOperand(0)); - return I; + I.replaceAllUsesWith(Op->getOperand(0)); + return &I; } return 0; } @@ -100,9 +100,9 @@ Instruction *InstCombiner::visitNot(UnaryOperator *I) { // Make sure that this instruction has a constant on the right hand side if it // has any constant arguments. If not, fix it an return true. // -static bool SimplifyBinOp(BinaryOperator *I) { - if (isa<Constant>(I->getOperand(0)) && !isa<Constant>(I->getOperand(1))) - return !I->swapOperands(); +static bool SimplifyBinOp(BinaryOperator &I) { + if (isa<Constant>(I.getOperand(0)) && !isa<Constant>(I.getOperand(1))) + return !I.swapOperands(); return false; } @@ -118,16 +118,16 @@ static inline Value *dyn_castNegInst(Value *V) { return 0; } -Instruction *InstCombiner::visitAdd(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead add instructions... +Instruction *InstCombiner::visitAdd(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead add instructions... bool Changed = SimplifyBinOp(I); - Value *LHS = I->getOperand(0), *RHS = I->getOperand(1); + Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); // Eliminate 'add int %X, 0' - if (RHS == Constant::getNullValue(I->getType())) { + if (RHS == Constant::getNullValue(I.getType())) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(LHS); - return I; + I.replaceAllUsesWith(LHS); + return &I; } // -A + B --> B - A @@ -150,33 +150,33 @@ Instruction *InstCombiner::visitAdd(BinaryOperator *I) { // %Z = add int %X, 2 // if (Constant *Val = *Op2 + *cast<Constant>(ILHS->getOperand(1))) { - I->setOperand(0, ILHS->getOperand(0)); - I->setOperand(1, Val); - return I; + I.setOperand(0, ILHS->getOperand(0)); + I.setOperand(1, Val); + return &I; } } } } - return Changed ? I : 0; + return Changed ? &I : 0; } -Instruction *InstCombiner::visitSub(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead add instructions... - Value *Op0 = I->getOperand(0), *Op1 = I->getOperand(1); +Instruction *InstCombiner::visitSub(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead add instructions... + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); if (Op0 == Op1) { // sub X, X -> 0 AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Constant::getNullValue(I->getType())); - return I; + I.replaceAllUsesWith(Constant::getNullValue(I.getType())); + return &I; } // If this is a subtract instruction with a constant RHS, convert it to an add // instruction of a negative constant // if (Constant *Op2 = dyn_cast<Constant>(Op1)) - if (Constant *RHS = *Constant::getNullValue(I->getType()) - *Op2) // 0 - RHS - return BinaryOperator::create(Instruction::Add, Op0, RHS, I->getName()); + if (Constant *RHS = *Constant::getNullValue(I.getType()) - *Op2) // 0 - RHS + return BinaryOperator::create(Instruction::Add, Op0, RHS, I.getName()); // If this is a 'C = x-B', check to see if 'B = -A', so that C = x+A... if (Value *V = dyn_castNegInst(Op1)) @@ -198,59 +198,59 @@ Instruction *InstCombiner::visitSub(BinaryOperator *I) { return 0; } -Instruction *InstCombiner::visitMul(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitMul(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... bool Changed = SimplifyBinOp(I); - Value *Op1 = I->getOperand(0); + Value *Op1 = I.getOperand(0); // Simplify add instructions with a constant RHS... - if (Constant *Op2 = dyn_cast<Constant>(I->getOperand(1))) { - if (I->getType()->isIntegral() && cast<ConstantInt>(Op2)->equalsInt(1)){ + if (Constant *Op2 = dyn_cast<Constant>(I.getOperand(1))) { + if (I.getType()->isIntegral() && cast<ConstantInt>(Op2)->equalsInt(1)){ // Eliminate 'mul int %X, 1' AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op1); - return I; + I.replaceAllUsesWith(Op1); + return &I; - } else if (I->getType()->isIntegral() && + } else if (I.getType()->isIntegral() && cast<ConstantInt>(Op2)->equalsInt(2)) { // Convert 'mul int %X, 2' to 'add int %X, %X' - return BinaryOperator::create(Instruction::Add, Op1, Op1, I->getName()); + return BinaryOperator::create(Instruction::Add, Op1, Op1, I.getName()); } else if (Op2->isNullValue()) { // Eliminate 'mul int %X, 0' - AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op2); // Set this value to zero directly - return I; + AddUsesToWorkList(I); // Add all modified instrs to worklist + I.replaceAllUsesWith(Op2); // Set this value to zero directly + return &I; } } - return Changed ? I : 0; + return Changed ? &I : 0; } -Instruction *InstCombiner::visitDiv(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitDiv(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... // div X, 1 == X - if (ConstantInt *RHS = dyn_cast<ConstantInt>(I->getOperand(1))) + if (ConstantInt *RHS = dyn_cast<ConstantInt>(I.getOperand(1))) if (RHS->equalsInt(1)) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(I->getOperand(0)); - return I; + I.replaceAllUsesWith(I.getOperand(0)); + return &I; } return 0; } -Instruction *InstCombiner::visitRem(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitRem(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... // rem X, 1 == 0 - if (ConstantInt *RHS = dyn_cast<ConstantInt>(I->getOperand(1))) + if (ConstantInt *RHS = dyn_cast<ConstantInt>(I.getOperand(1))) if (RHS->equalsInt(1)) { - AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Constant::getNullValue(I->getType())); - return I; + AddUsesToWorkList(I); // Add all modified instrs to worklist + I.replaceAllUsesWith(Constant::getNullValue(I.getType())); + return &I; } return 0; } @@ -273,123 +273,123 @@ static Constant *getMaxValue(const Type *Ty) { } -Instruction *InstCombiner::visitAnd(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitAnd(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... bool Changed = SimplifyBinOp(I); - Value *Op0 = I->getOperand(0), *Op1 = I->getOperand(1); + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); // and X, X = X and X, 0 == 0 - if (Op0 == Op1 || Op1 == Constant::getNullValue(I->getType())) { - AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op1); - return I; + if (Op0 == Op1 || Op1 == Constant::getNullValue(I.getType())) { + AddUsesToWorkList(I); // Add all modified instrs to worklist + I.replaceAllUsesWith(Op1); + return &I; } // and X, -1 == X if (Constant *RHS = dyn_cast<Constant>(Op1)) - if (RHS == getMaxValue(I->getType())) { + if (RHS == getMaxValue(I.getType())) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op0); - return I; + I.replaceAllUsesWith(Op0); + return &I; } - return Changed ? I : 0; + return Changed ? &I : 0; } -Instruction *InstCombiner::visitOr(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitOr(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... bool Changed = SimplifyBinOp(I); - Value *Op0 = I->getOperand(0), *Op1 = I->getOperand(1); + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); // or X, X = X or X, 0 == X - if (Op0 == Op1 || Op1 == Constant::getNullValue(I->getType())) { + if (Op0 == Op1 || Op1 == Constant::getNullValue(I.getType())) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op0); - return I; + I.replaceAllUsesWith(Op0); + return &I; } // or X, -1 == -1 if (Constant *RHS = dyn_cast<Constant>(Op1)) - if (RHS == getMaxValue(I->getType())) { + if (RHS == getMaxValue(I.getType())) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op1); - return I; + I.replaceAllUsesWith(Op1); + return &I; } - return Changed ? I : 0; + return Changed ? &I : 0; } -Instruction *InstCombiner::visitXor(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitXor(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... bool Changed = SimplifyBinOp(I); - Value *Op0 = I->getOperand(0), *Op1 = I->getOperand(1); + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); // xor X, X = 0 if (Op0 == Op1) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Constant::getNullValue(I->getType())); - return I; + I.replaceAllUsesWith(Constant::getNullValue(I.getType())); + return &I; } // xor X, 0 == X - if (Op1 == Constant::getNullValue(I->getType())) { + if (Op1 == Constant::getNullValue(I.getType())) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op0); - return I; + I.replaceAllUsesWith(Op0); + return &I; } - return Changed ? I : 0; + return Changed ? &I : 0; } // isTrueWhenEqual - Return true if the specified setcondinst instruction is // true when both operands are equal... // -static bool isTrueWhenEqual(Instruction *I) { - return I->getOpcode() == Instruction::SetEQ || - I->getOpcode() == Instruction::SetGE || - I->getOpcode() == Instruction::SetLE; +static bool isTrueWhenEqual(Instruction &I) { + return I.getOpcode() == Instruction::SetEQ || + I.getOpcode() == Instruction::SetGE || + I.getOpcode() == Instruction::SetLE; } -Instruction *InstCombiner::visitSetCondInst(BinaryOperator *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... bool Changed = SimplifyBinOp(I); // setcc X, X - if (I->getOperand(0) == I->getOperand(1)) { + if (I.getOperand(0) == I.getOperand(1)) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(ConstantBool::get(isTrueWhenEqual(I))); - return I; + I.replaceAllUsesWith(ConstantBool::get(isTrueWhenEqual(I))); + return &I; } // setcc <global*>, 0 - Global value addresses are never null! - if (isa<GlobalValue>(I->getOperand(0)) && - isa<ConstantPointerNull>(I->getOperand(1))) { + if (isa<GlobalValue>(I.getOperand(0)) && + isa<ConstantPointerNull>(I.getOperand(1))) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(ConstantBool::get(!isTrueWhenEqual(I))); - return I; + I.replaceAllUsesWith(ConstantBool::get(!isTrueWhenEqual(I))); + return &I; } - return Changed ? I : 0; + return Changed ? &I : 0; } -Instruction *InstCombiner::visitShiftInst(Instruction *I) { - if (I->use_empty()) return 0; // Don't fix dead instructions... - assert(I->getOperand(1)->getType() == Type::UByteTy); - Value *Op0 = I->getOperand(0), *Op1 = I->getOperand(1); +Instruction *InstCombiner::visitShiftInst(Instruction &I) { + if (I.use_empty()) return 0; // Don't fix dead instructions... + assert(I.getOperand(1)->getType() == Type::UByteTy); + Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); // shl X, 0 == X and shr X, 0 == X // shl 0, X == 0 and shr 0, X == 0 if (Op1 == Constant::getNullValue(Type::UByteTy) || Op0 == Constant::getNullValue(Op0->getType())) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Op0); - return I; + I.replaceAllUsesWith(Op0); + return &I; } // shl int X, 32 = 0 and shr sbyte Y, 9 = 0, ... just don't eliminate shr of @@ -398,10 +398,10 @@ Instruction *InstCombiner::visitShiftInst(Instruction *I) { if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(Op1)) { unsigned TypeBits = Op0->getType()->getPrimitiveSize()*8; if (CUI->getValue() >= TypeBits && - !(Op0->getType()->isSigned() && I->getOpcode() == Instruction::Shr)) { + !(Op0->getType()->isSigned() && I.getOpcode() == Instruction::Shr)) { AddUsesToWorkList(I); // Add all modified instrs to worklist - I->replaceAllUsesWith(Constant::getNullValue(Op0->getType())); - return I; + I.replaceAllUsesWith(Constant::getNullValue(Op0->getType())); + return &I; } } return 0; @@ -411,12 +411,12 @@ Instruction *InstCombiner::visitShiftInst(Instruction *I) { // isEliminableCastOfCast - Return true if it is valid to eliminate the CI // instruction. // -static inline bool isEliminableCastOfCast(const CastInst *CI, +static inline bool isEliminableCastOfCast(const CastInst &CI, const CastInst *CSrc) { - assert(CI->getOperand(0) == CSrc); + assert(CI.getOperand(0) == CSrc); const Type *SrcTy = CSrc->getOperand(0)->getType(); const Type *MidTy = CSrc->getType(); - const Type *DstTy = CI->getType(); + const Type *DstTy = CI.getType(); // It is legal to eliminate the instruction if casting A->B->A if (SrcTy == DstTy) return true; @@ -437,27 +437,27 @@ static inline bool isEliminableCastOfCast(const CastInst *CI, // CastInst simplification // -Instruction *InstCombiner::visitCastInst(CastInst *CI) { - if (CI->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitCastInst(CastInst &CI) { + if (CI.use_empty()) return 0; // Don't fix dead instructions... // If the user is casting a value to the same type, eliminate this cast // instruction... - if (CI->getType() == CI->getOperand(0)->getType() && !CI->use_empty()) { + if (CI.getType() == CI.getOperand(0)->getType() && !CI.use_empty()) { AddUsesToWorkList(CI); // Add all modified instrs to worklist - CI->replaceAllUsesWith(CI->getOperand(0)); - return CI; + CI.replaceAllUsesWith(CI.getOperand(0)); + return &CI; } // If casting the result of another cast instruction, try to eliminate this // one! // - if (CastInst *CSrc = dyn_cast<CastInst>(CI->getOperand(0))) + if (CastInst *CSrc = dyn_cast<CastInst>(CI.getOperand(0))) if (isEliminableCastOfCast(CI, CSrc)) { // This instruction now refers directly to the cast's src operand. This // has a good chance of making CSrc dead. - CI->setOperand(0, CSrc->getOperand(0)); - return CI; + CI.setOperand(0, CSrc->getOperand(0)); + return &CI; } return 0; @@ -466,28 +466,28 @@ Instruction *InstCombiner::visitCastInst(CastInst *CI) { // PHINode simplification // -Instruction *InstCombiner::visitPHINode(PHINode *PN) { - if (PN->use_empty()) return 0; // Don't fix dead instructions... +Instruction *InstCombiner::visitPHINode(PHINode &PN) { + if (PN.use_empty()) return 0; // Don't fix dead instructions... // If the PHI node only has one incoming value, eliminate the PHI node... - if (PN->getNumIncomingValues() == 1) { + if (PN.getNumIncomingValues() == 1) { AddUsesToWorkList(PN); // Add all modified instrs to worklist - PN->replaceAllUsesWith(PN->getIncomingValue(0)); - return PN; + PN.replaceAllUsesWith(PN.getIncomingValue(0)); + return &PN; } return 0; } -Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst *GEP) { +Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) { // Is it getelementptr %P, uint 0 - // If so, elminate the noop. - if (GEP->getNumOperands() == 2 && !GEP->use_empty() && - GEP->getOperand(1) == Constant::getNullValue(Type::UIntTy)) { + // If so, eliminate the noop. + if (GEP.getNumOperands() == 2 && !GEP.use_empty() && + GEP.getOperand(1) == Constant::getNullValue(Type::UIntTy)) { AddUsesToWorkList(GEP); // Add all modified instrs to worklist - GEP->replaceAllUsesWith(GEP->getOperand(0)); - return GEP; + GEP.replaceAllUsesWith(GEP.getOperand(0)); + return &GEP; } return visitMemAccessInst(GEP); @@ -498,36 +498,36 @@ Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst *GEP) { // getelementptr instruction, combine the indices of the GEP into this // instruction // -Instruction *InstCombiner::visitMemAccessInst(MemAccessInst *MAI) { +Instruction *InstCombiner::visitMemAccessInst(MemAccessInst &MAI) { GetElementPtrInst *Src = - dyn_cast<GetElementPtrInst>(MAI->getPointerOperand()); + dyn_cast<GetElementPtrInst>(MAI.getPointerOperand()); if (!Src) return 0; std::vector<Value *> Indices; // Only special case we have to watch out for is pointer arithmetic on the // 0th index of MAI. - unsigned FirstIdx = MAI->getFirstIndexOperandNumber(); - if (FirstIdx == MAI->getNumOperands() || - (FirstIdx == MAI->getNumOperands()-1 && - MAI->getOperand(FirstIdx) == ConstantUInt::get(Type::UIntTy, 0))) { + unsigned FirstIdx = MAI.getFirstIndexOperandNumber(); + if (FirstIdx == MAI.getNumOperands() || + (FirstIdx == MAI.getNumOperands()-1 && + MAI.getOperand(FirstIdx) == ConstantUInt::get(Type::UIntTy, 0))) { // Replace the index list on this MAI with the index on the getelementptr Indices.insert(Indices.end(), Src->idx_begin(), Src->idx_end()); - } else if (*MAI->idx_begin() == ConstantUInt::get(Type::UIntTy, 0)) { + } else if (*MAI.idx_begin() == ConstantUInt::get(Type::UIntTy, 0)) { // Otherwise we can do the fold if the first index of the GEP is a zero Indices.insert(Indices.end(), Src->idx_begin(), Src->idx_end()); - Indices.insert(Indices.end(), MAI->idx_begin()+1, MAI->idx_end()); + Indices.insert(Indices.end(), MAI.idx_begin()+1, MAI.idx_end()); } if (Indices.empty()) return 0; // Can't do the fold? - switch (MAI->getOpcode()) { + switch (MAI.getOpcode()) { case Instruction::GetElementPtr: - return new GetElementPtrInst(Src->getOperand(0), Indices, MAI->getName()); + return new GetElementPtrInst(Src->getOperand(0), Indices, MAI.getName()); case Instruction::Load: - return new LoadInst(Src->getOperand(0), Indices, MAI->getName()); + return new LoadInst(Src->getOperand(0), Indices, MAI.getName()); case Instruction::Store: - return new StoreInst(MAI->getOperand(0), Src->getOperand(0), Indices); + return new StoreInst(MAI.getOperand(0), Src->getOperand(0), Indices); default: assert(0 && "Unknown memaccessinst!"); break; @@ -537,7 +537,7 @@ Instruction *InstCombiner::visitMemAccessInst(MemAccessInst *MAI) { } -bool InstCombiner::runOnFunction(Function *F) { +bool InstCombiner::runOnFunction(Function &F) { bool Changed = false; WorkList.insert(WorkList.end(), inst_begin(F), inst_end(F)); @@ -547,7 +547,7 @@ bool InstCombiner::runOnFunction(Function *F) { WorkList.pop_back(); // Now that we have an instruction, try combining it to simplify it... - Instruction *Result = visit(I); + Instruction *Result = visit(*I); if (Result) { ++NumCombined; // Should we replace the old instruction with a new one? @@ -562,10 +562,16 @@ bool InstCombiner::runOnFunction(Function *F) { } ReplaceInstWithInst(I, Result); + } else { + // FIXME: + // FIXME: + // FIXME: This should DCE the instruction to simplify the cases above. + // FIXME: + // FIXME: } WorkList.push_back(Result); - AddUsesToWorkList(Result); + AddUsesToWorkList(*Result); Changed = true; } } |