Lines Matching full:instruction
113 Expression create_expression(Instruction* I);
162 Expression ValueTable::create_expression(Instruction *I) {
166 for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end();
174 assert(I->getNumOperands() == 2 && "Unsupported commutative instruction!");
199 assert((Opcode == Instruction::ICmp || Opcode == Instruction::FCmp) &&
229 e.opcode = Instruction::Add;
233 e.opcode = Instruction::Sub;
237 e.opcode = Instruction::Mul;
256 for (Instruction::op_iterator OI = EI->op_begin(), OE = EI->op_end();
332 // Check to see if we have a single dominating call instruction that is
340 // instruction dependencies.
392 if (!isa<Instruction>(V)) {
397 Instruction* I = cast<Instruction>(V);
400 case Instruction::Call:
402 case Instruction::Add:
403 case Instruction::FAdd:
404 case Instruction::Sub:
405 case Instruction::FSub:
406 case Instruction::Mul:
407 case Instruction::FMul:
408 case Instruction::UDiv:
409 case Instruction::SDiv:
410 case Instruction::FDiv:
411 case Instruction::URem:
412 case Instruction::SRem:
413 case Instruction::FRem:
414 case Instruction::Shl:
415 case Instruction::LShr:
416 case Instruction::AShr:
417 case Instruction::And:
418 case Instruction::Or:
419 case Instruction::Xor:
420 case Instruction::ICmp:
421 case Instruction::FCmp:
422 case Instruction::Trunc:
423 case Instruction::ZExt:
424 case Instruction::SExt:
425 case Instruction::FPToUI:
426 case Instruction::FPToSI:
427 case Instruction::UIToFP:
428 case Instruction::SIToFP:
429 case Instruction::FPTrunc:
430 case Instruction::FPExt:
431 case Instruction::PtrToInt:
432 case Instruction::IntToPtr:
433 case Instruction::BitCast:
434 case Instruction::Select:
435 case Instruction::ExtractElement:
436 case Instruction::InsertElement:
437 case Instruction::ShuffleVector:
438 case Instruction::InsertValue:
439 case Instruction::GetElementPtr:
442 case Instruction::ExtractValue:
467 /// instruction realizing that comparison to hand.
592 SmallVector<Instruction*, 8> InstrsToErase;
607 /// markInstructionForDeletion - This removes the specified instruction from
609 void markInstructionForDeletion(Instruction *I) {
637 /// value number, and remove the given instruction if encountered.
638 void removeFromLeaderTable(uint32_t N, Instruction *I, BasicBlock *BB) {
688 bool processInstruction(Instruction *I);
695 void verifyRemoved(const Instruction *I) const;
840 Instruction *InsertPt,
1095 Instruction *InsertPt, const DataLayout &TD){
1133 Type *LoadTy, Instruction *InsertPt,
1193 Type *LoadTy, Instruction *InsertPt,
1339 static bool isLifetimeStart(const Instruction *Inst) {
1390 // If this is a clobber and L is the first instruction in its block, then
1391 // we have the first instruction in the entry block.
1425 Instruction *DepInst = DepInfo.getInst();
1571 SmallVector<Instruction*, 8> NewInsts;
1601 Instruction *I = NewInsts.pop_back_val();
1632 Instruction *NewLoad = new LoadInst(LoadPtr, LI->getName()+".pre", false,
1728 static void patchReplacementInstruction(Instruction *I, Value *Repl) {
1740 if (Instruction *ReplInst = dyn_cast<Instruction>(Repl)) {
1760 llvm_unreachable("MD_prof in a non terminator instruction");
1770 static void patchAndReplaceAllUsesWith(Instruction *I, Value *Repl) {
1820 // If this is a clobber and L is the first instruction in its block, then
1821 // we have the first instruction in the entry block.
1859 // fast print dep, using operator<< on instruction is too slow.
1862 Instruction *I = Dep.getInst();
1874 // fast print dep, using operator<< on instruction is too slow.
1882 Instruction *DepInst = Dep.getInst();
2053 assert((isa<Argument>(LHS) || isa<Instruction>(LHS)) && "Unexpected value!");
2061 (isa<Instruction>(LHS) && isa<Instruction>(RHS))) {
2071 // If value numbering later sees that an instruction in the scope is equal
2075 // if RHS is an instruction (if an instruction in the scope is morphed into
2080 if (RootDominatesEnd && !isa<Instruction>(RHS))
2132 // Since we don't have the instruction "A < B" immediately to hand, work out
2134 // instruction (if any).
2138 // looking for an instruction realizing it: there cannot be one!
2141 if (NotCmp && isa<Instruction>(NotCmp)) {
2148 // Ensure that any instruction in scope that gets the "A < B" value number
2162 /// processInstruction - When calculating availability, handle an instruction
2164 bool GVN::processInstruction(Instruction *I) {
2169 // If the instruction can be easily simplified then do so now in preference
2171 // example if it determines that %y is equal to %x then the instruction
2335 // (and incrementing BI before processing an instruction).
2356 for (SmallVectorImpl<Instruction *>::iterator I = InstrsToErase.begin(),
2391 Instruction *CurInst = BI++;
2477 Instruction *PREInstr = CurInst->clone();
2507 // Update the availability map to include the new instruction.
2613 /// verifyRemoved - Verify that the specified instruction does not occur in our
2615 void GVN::verifyRemoved(const Instruction *Inst) const {
2618 // Walk through the value number scope to make sure the instruction isn't
