49   void VisitTypeConversion(HTypeConversion* instruction) OVERRIDE;
50   void VisitNullCheck(HNullCheck* instruction) OVERRIDE;
51   void VisitArrayLength(HArrayLength* instruction) OVERRIDE;
52   void VisitCheckCast(HCheckCast* instruction) OVERRIDE;
53   void VisitAdd(HAdd* instruction) OVERRIDE;
54   void VisitAnd(HAnd* instruction) OVERRIDE;
55   void VisitDiv(HDiv* instruction) OVERRIDE;
56   void VisitMul(HMul* instruction) OVERRIDE;
57   void VisitNeg(HNeg* instruction) OVERRIDE;
58   void VisitNot(HNot* instruction) OVERRIDE;
59   void VisitOr(HOr* instruction) OVERRIDE;
60   void VisitShl(HShl* instruction) OVERRIDE;
61   void VisitShr(HShr* instruction) OVERRIDE;
62   void VisitSub(HSub* instruction) OVERRIDE;
63   void VisitUShr(HUShr* instruction) OVERRIDE;
64   void VisitXor(HXor* instruction) OVERRIDE;
65   void VisitInstanceOf(HInstanceOf* instruction) OVERRIDE;
82     // The simplification of an instruction to another instruction may yield
84     // post order visit, we sometimes need to revisit an instruction index.
89       // New simplifications may be applicable to the instruction at the
135 void InstructionSimplifierVisitor::VisitShift(HBinaryOperation* instruction) {
136   DCHECK(instruction->IsShl() || instruction->IsShr() || instruction->IsUShr());
137   HConstant* input_cst = instruction->GetConstantRight();
138   HInstruction* input_other = instruction->GetLeastConstantLeft();
146       instruction->ReplaceWith(input_other);
147       instruction->GetBlock()->RemoveInstruction(instruction);
148     } else if (instruction->IsShl() && input_cst->IsOne()) {
153       HAdd *add = new(GetGraph()->GetArena()) HAdd(instruction->GetType(),
156       instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, add);
196 void InstructionSimplifierVisitor::VisitInstanceOf(HInstanceOf* instruction) {
197   if (!instruction->InputAt(0)->CanBeNull()) {
198     instruction->ClearMustDoNullCheck();
277 void InstructionSimplifierVisitor::VisitArrayLength(HArrayLength* instruction) {
278   HInstruction* input = instruction->InputAt(0);
280   // with the constant instruction. This helps the bounds check elimination phase.
284       instruction->ReplaceWith(input);
289 void InstructionSimplifierVisitor::VisitArraySet(HArraySet* instruction) {
290   HInstruction* value = instruction->GetValue();
294     if (value->AsArrayGet()->GetArray() == instruction->GetArray()) {
296       instruction->ClearNeedsTypeCheck();
301 void InstructionSimplifierVisitor::VisitTypeConversion(HTypeConversion* instruction) {
302   if (instruction->GetResultType() == instruction->GetInputType()) {
303     // Remove the instruction if it's converting to the same type.
304     instruction->ReplaceWith(instruction->GetInput());
305     instruction->GetBlock()->RemoveInstruction(instruction);
309 void InstructionSimplifierVisitor::VisitAdd(HAdd* instruction) {
310   HConstant* input_cst = instruction->GetConstantRight();
311   HInstruction* input_other = instruction->GetLeastConstantLeft();
320     if (Primitive::IsIntegralType(instruction->GetType())) {
321       instruction->ReplaceWith(input_other);
322       instruction->GetBlock()->RemoveInstruction(instruction);
327   HInstruction* left = instruction->GetLeft();
328   HInstruction* right = instruction->GetRight();
333     if (TryMoveNegOnInputsAfterBinop(instruction)) {
348     // not sure the initial 'NEG' instruction can be removed.
350     HSub* sub = new(GetGraph()->GetArena()) HSub(instruction->GetType(), other, neg->GetInput());
351     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, sub);
357 void InstructionSimplifierVisitor::VisitAnd(HAnd* instruction) {
358   HConstant* input_cst = instruction->GetConstantRight();
359   HInstruction* input_other = instruction->GetLeastConstantLeft();
366     instruction->ReplaceWith(input_other);
367     instruction->GetBlock()->RemoveInstruction(instruction);
374   if (instruction->GetLeft() == instruction->GetRight()) {
379     instruction->ReplaceWith(instruction->GetLeft());
380     instruction->GetBlock()->RemoveInstruction(instruction);
384 void InstructionSimplifierVisitor::VisitDiv(HDiv* instruction) {
385   HConstant* input_cst = instruction->GetConstantRight();
386   HInstruction* input_other = instruction->GetLeastConstantLeft();
387   Primitive::Type type = instruction->GetType();
394     instruction->ReplaceWith(input_other);
395     instruction->GetBlock()->RemoveInstruction(instruction);
404     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(
405         instruction, new (GetGraph()->GetArena()) HNeg(type, input_other));
430       instruction->GetBlock()->ReplaceAndRemoveInstructionWith(
431           instruction, new (GetGraph()->GetArena()) HMul(type, input_other, reciprocal));
438 void InstructionSimplifierVisitor::VisitMul(HMul* instruction) {
439   HConstant* input_cst = instruction->GetConstantRight();
440   HInstruction* input_other = instruction->GetLeastConstantLeft();
441   Primitive::Type type = instruction->GetType();
442   HBasicBlock* block = instruction->GetBlock();
454     instruction->ReplaceWith(input_other);
455     instruction->GetBlock()->RemoveInstruction(instruction);
466     block->ReplaceAndRemoveInstructionWith(instruction, neg);
479     block->ReplaceAndRemoveInstructionWith(instruction,
494       instruction->ReplaceWith(input_cst);
495       instruction->GetBlock()->RemoveInstruction(instruction);
503       block->ReplaceAndRemoveInstructionWith(instruction, shl);
509 void InstructionSimplifierVisitor::VisitNeg(HNeg* instruction) {
510   HInstruction* input = instruction->GetInput();
518     instruction->ReplaceWith(previous_neg->GetInput());
519     instruction->GetBlock()->RemoveInstruction(instruction);
521     // uses since it allows removing the current instruction. But we only delete
540     // to be extended if we are not sure the initial 'SUB' instruction can be
545         new (GetGraph()->GetArena()) HSub(instruction->GetType(), sub->GetRight(), sub->GetLeft());
546     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, new_sub);
554 void InstructionSimplifierVisitor::VisitNot(HNot* instruction) {
555   HInstruction* input = instruction->GetInput();
563     // uses since it allows removing the current instruction. But we only delete
566     instruction->ReplaceWith(previous_not->GetInput());
567     instruction->GetBlock()->RemoveInstruction(instruction);
575 void InstructionSimplifierVisitor::VisitOr(HOr* instruction) {
576   HConstant* input_cst = instruction->GetConstantRight();
577   HInstruction* input_other = instruction->GetLeastConstantLeft();
584     instruction->ReplaceWith(input_other);
585     instruction->GetBlock()->RemoveInstruction(instruction);
592   if (instruction->GetLeft() == instruction->GetRight()) {
597     instruction->ReplaceWith(instruction->GetLeft());
598     instruction->GetBlock()->RemoveInstruction(instruction);
602 void InstructionSimplifierVisitor::VisitShl(HShl* instruction) {
603   VisitShift(instruction);
606 void InstructionSimplifierVisitor::VisitShr(HShr* instruction) {
607   VisitShift(instruction);
610 void InstructionSimplifierVisitor::VisitSub(HSub* instruction) {
611   HConstant* input_cst = instruction->GetConstantRight();
612   HInstruction* input_other = instruction->GetLeastConstantLeft();
614   Primitive::Type type = instruction->GetType();
627     instruction->ReplaceWith(input_other);
628     instruction->GetBlock()->RemoveInstruction(instruction);
632   HBasicBlock* block = instruction->GetBlock();
635   HInstruction* left = instruction->GetLeft();
636   HInstruction* right = instruction->GetRight();
647       block->ReplaceAndRemoveInstructionWith(instruction, neg);
654     if (TryMoveNegOnInputsAfterBinop(instruction)) {
666     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, add);
682     instruction->GetBlock()->InsertInstructionBefore(add, instruction);
683     HNeg* neg = new (GetGraph()->GetArena()) HNeg(instruction->GetType(), add);
684     instruction->GetBlock()->InsertInstructionBefore(neg, instruction);
685     instruction->ReplaceWith(neg);
686     instruction->GetBlock()->RemoveInstruction(instruction);
692 void InstructionSimplifierVisitor::VisitUShr(HUShr* instruction) {
693   VisitShift(instruction);
696 void InstructionSimplifierVisitor::VisitXor(HXor* instruction) {
697   HConstant* input_cst = instruction->GetConstantRight();
698   HInstruction* input_other = instruction->GetLeastConstantLeft();
705     instruction->ReplaceWith(input_other);
706     instruction->GetBlock()->RemoveInstruction(instruction);
715     HNot* bitwise_not = new (GetGraph()->GetArena()) HNot(instruction->GetType(), input_other);
716     instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, bitwise_not);

Indexes created Wed Oct 07 06:49:07 CEST 2015