Lines Matching full:instruction
119 Expression create_expression(Instruction* I);
168 Expression ValueTable::create_expression(Instruction *I) {
172 for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end();
180 assert(I->getNumOperands() == 2 && "Unsupported commutative instruction!");
205 assert((Opcode == Instruction::ICmp || Opcode == Instruction::FCmp) &&
235 e.opcode = Instruction::Add;
239 e.opcode = Instruction::Sub;
243 e.opcode = Instruction::Mul;
262 for (Instruction::op_iterator OI = EI->op_begin(), OE = EI->op_end();
338 // Check to see if we have a single dominating call instruction that is
346 // instruction dependencies.
398 if (!isa<Instruction>(V)) {
403 Instruction* I = cast<Instruction>(V);
406 case Instruction::Call:
408 case Instruction::Add:
409 case Instruction::FAdd:
410 case Instruction::Sub:
411 case Instruction::FSub:
412 case Instruction::Mul:
413 case Instruction::FMul:
414 case Instruction::UDiv:
415 case Instruction::SDiv:
416 case Instruction::FDiv:
417 case Instruction::URem:
418 case Instruction::SRem:
419 case Instruction::FRem:
420 case Instruction::Shl:
421 case Instruction::LShr:
422 case Instruction::AShr:
423 case Instruction::And:
424 case Instruction::Or:
425 case Instruction::Xor:
426 case Instruction::ICmp:
427 case Instruction::FCmp:
428 case Instruction::Trunc:
429 case Instruction::ZExt:
430 case Instruction::SExt:
431 case Instruction::FPToUI:
432 case Instruction::FPToSI:
433 case Instruction::UIToFP:
434 case Instruction::SIToFP:
435 case Instruction::FPTrunc:
436 case Instruction::FPExt:
437 case Instruction::PtrToInt:
438 case Instruction::IntToPtr:
439 case Instruction::BitCast:
440 case Instruction::Select:
441 case Instruction::ExtractElement:
442 case Instruction::InsertElement:
443 case Instruction::ShuffleVector:
444 case Instruction::InsertValue:
445 case Instruction::GetElementPtr:
448 case Instruction::ExtractValue:
473 /// instruction realizing that comparison to hand.
611 SmallVector<Instruction*, 8> InstrsToErase;
626 /// This removes the specified instruction from
628 void markInstructionForDeletion(Instruction *I) {
654 /// value number, and remove the given instruction if encountered.
655 void removeFromLeaderTable(uint32_t N, Instruction *I, BasicBlock *BB) {
706 bool processInstruction(Instruction *I);
711 bool performScalarPRE(Instruction *I);
712 bool performScalarPREInsertion(Instruction *Instr, BasicBlock *Pred,
716 void verifyRemoved(const Instruction *I) const;
863 Instruction *InsertPt,
1121 Instruction *InsertPt, const DataLayout &DL){
1159 Type *LoadTy, Instruction *InsertPt,
1219 Type *LoadTy, Instruction *InsertPt,
1369 static bool isLifetimeStart(const Instruction *Inst) {
1428 // If this is a clobber and L is the first instruction in its block, then
1429 // we have the first instruction in the entry block.
1462 Instruction *DepInst = DepInfo.getInst();
1616 SmallVector<Instruction*, 8> NewInsts;
1645 Instruction *I = NewInsts.pop_back_val();
1675 Instruction *NewLoad = new LoadInst(LoadPtr, LI->getName()+".pre", false,
1738 if (Instruction *I = dyn_cast<Instruction>(OI->get()))
1781 static void patchReplacementInstruction(Instruction *I, Value *Repl) {
1793 if (Instruction *ReplInst = dyn_cast<Instruction>(Repl)) {
1815 static void patchAndReplaceAllUsesWith(Instruction *I, Value *Repl) {
1865 // If this is a clobber and L is the first instruction in its block, then
1866 // we have the first instruction in the entry block.
1902 // fast print dep, using operator<< on instruction is too slow.
1905 Instruction *I = Dep.getInst();
1917 // fast print dep, using operator<< on instruction is too slow.
1925 Instruction *DepInst = Dep.getInst();
2095 assert((isa<Argument>(LHS) || isa<Instruction>(LHS)) && "Unexpected value!");
2103 (isa<Instruction>(LHS) && isa<Instruction>(RHS))) {
2113 // If value numbering later sees that an instruction in the scope is equal
2117 // if RHS is an instruction (if an instruction in the scope is morphed into
2122 if (RootDominatesEnd && !isa<Instruction>(RHS))
2180 // applicable via an instruction-level fast-math-flag or some other
2190 // Since we don't have the instruction "A < B" immediately to hand, work
2192 // appropriate instruction (if any).
2196 // looking for an instruction realizing it: there cannot be one!
2199 if (NotCmp && isa<Instruction>(NotCmp)) {
2206 // Ensure that any instruction in scope that gets the "A < B" value number
2220 /// When calculating availability, handle an instruction
2222 bool GVN::processInstruction(Instruction *I) {
2227 // If the instruction can be easily simplified then do so now in preference
2229 // example if it determines that %y is equal to %x then the instruction
2406 // (and incrementing BI before processing an instruction).
2430 for (SmallVectorImpl<Instruction *>::iterator I = InstrsToErase.begin(),
2449 bool GVN::performScalarPREInsertion(Instruction *Instr, BasicBlock *Pred,
2480 // Update the availability map to include the new instruction.
2485 bool GVN::performScalarPRE(Instruction *CurInst) {
2554 // We may have a case where all predecessors have the instruction,
2557 Instruction *PREInstr = nullptr;
2575 // If we failed insertion, make sure we remove the instruction.
2582 // Either we should have filled in the PRE instruction, or we should
2644 Instruction *CurInst = BI++;
2710 /// Verify that the specified instruction does not occur in our
2712 void GVN::verifyRemoved(const Instruction *Inst) const {
2715 // Walk through the value number scope to make sure the instruction isn't
2841 // performPRE() will trigger assert if it comes across an instruction without
2844 // dead code than checking if instruction involved is dead or not.
2851 Instruction *Inst = &*II;
