Initial steps towards cleaning up integer arithmetic IR.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 273 matching lines @@
   BinarySmiOpInstr* smi_shift_left = NULL;
   if (bit_and_instr->InputAt(0)->IsSingleUse()) {
     smi_shift_left = AsSmiShiftLeftInstruction(left_instr);
   }
   if ((smi_shift_left == NULL) && (bit_and_instr->InputAt(1)->IsSingleUse())) {
     smi_shift_left = AsSmiShiftLeftInstruction(right_instr);
   }
   if (smi_shift_left == NULL) return;
 
   // Pattern recognized.
-  smi_shift_left->set_is_truncating(true);
+  smi_shift_left->mark_truncating();
   ASSERT(bit_and_instr->IsBinarySmiOp() || bit_and_instr->IsBinaryMintOp());
   if (bit_and_instr->IsBinaryMintOp()) {
     // Replace Mint op with Smi op.
     BinarySmiOpInstr* smi_op = new(I) BinarySmiOpInstr(
         Token::kBIT_AND,
         new(I) Value(left_instr),
         new(I) Value(right_instr),
-        Isolate::kNoDeoptId,  // BIT_AND cannot deoptimize.
-        Scanner::kNoSourcePos);
+        Isolate::kNoDeoptId);  // BIT_AND cannot deoptimize.
     bit_and_instr->ReplaceWith(smi_op, current_iterator());
   }
 }
 
 
 
 // Used by TryMergeDivMod.
 // Inserts a load-indexed instruction between a TRUNCDIV or MOD instruction,
 // and the using instruction. This is an intermediate step before merging.
 void FlowGraphOptimizer::AppendLoadIndexedForMerged(Definition* instr,
@@ skipping 1928 matching lines @@
                                           call->token_pos()),
                      call->env(),
                      FlowGraph::kEffect);
         ConstantInstr* constant =
             flow_graph()->GetConstant(Smi::Handle(I,
                 Smi::New(Smi::Cast(obj).Value() - 1)));
         BinarySmiOpInstr* bin_op =
             new(I) BinarySmiOpInstr(Token::kBIT_AND,
                                     new(I) Value(left),
                                     new(I) Value(constant),
-                                    call->deopt_id(),
-                                    call->token_pos());

[Cutch, 2014/09/11 17:41:53]

Why are we dropping the token position?

[Vyacheslav Egorov (Google), 2014/09/11 19:50:47]

Because it was not used anywhere. Remains of ancient times.

+                                    call->deopt_id());
         ReplaceCall(call, bin_op);
         return true;
       }
     }
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     AddCheckSmi(left, call->deopt_id(), call->env(), call);
     AddCheckSmi(right, call->deopt_id(), call->env(), call);
     BinarySmiOpInstr* bin_op =
         new(I) BinarySmiOpInstr(op_kind,
-                                        new(I) Value(left),
-                                        new(I) Value(right),
-                                        call->deopt_id(), call->token_pos());
+                                new(I) Value(left),
+                                new(I) Value(right),
+                                call->deopt_id());
     ReplaceCall(call, bin_op);
   } else {
     ASSERT(operands_type == kSmiCid);
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     AddCheckSmi(left, call->deopt_id(), call->env(), call);
     AddCheckSmi(right, call->deopt_id(), call->env(), call);
     if (left->IsConstant() &&
         ((op_kind == Token::kADD) || (op_kind == Token::kMUL))) {
       // Constant should be on the right side.
       Definition* temp = left;
       left = right;
       right = temp;
     }
     BinarySmiOpInstr* bin_op =
         new(I) BinarySmiOpInstr(
-            op_kind, new(I) Value(left), new(I) Value(right),
-            call->deopt_id(), call->token_pos());
+            op_kind,
+            new(I) Value(left),
+            new(I) Value(right),
+            call->deopt_id());
     ReplaceCall(call, bin_op);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
                                                Token::Kind op_kind) {
   ASSERT(call->ArgumentCount() == 1);
   Definition* input = call->ArgumentAt(0);
@@ skipping 869 matching lines @@
       const int64_t mask_value = mask_literal.AsInt64Value();
       ASSERT(mask_value >= 0);
       if (mask_value > Smi::kMaxValue) {
         // The result will not be Smi.
         return false;
       }
       BinarySmiOpInstr* left_shift =
           new(I) BinarySmiOpInstr(Token::kSHL,
                                   new(I) Value(value),
                                   new(I) Value(count),
-                                  call->deopt_id(), call->token_pos());
-      left_shift->set_is_truncating(true);
+                                  call->deopt_id());
+      left_shift->mark_truncating();
       if ((kBitsPerWord == 32) && (mask_value == 0xffffffffLL)) {
         // No BIT_AND operation needed.
         ReplaceCall(call, left_shift);
       } else {
         InsertBefore(call, left_shift, call->env(), FlowGraph::kValue);
         BinarySmiOpInstr* bit_and =
             new(I) BinarySmiOpInstr(Token::kBIT_AND,
                                     new(I) Value(left_shift),
                                     new(I) Value(int32_mask),
-                                    call->deopt_id(),
-                                    call->token_pos());
+                                    call->deopt_id());
         ReplaceCall(call, bit_and);
       }
       return true;
     }
 
     if (HasTwoMintOrSmi(ic_data) &&
         HasOnlyOneSmi(ICData::Handle(I,
                                      ic_data.AsUnaryClassChecksForArgNr(1)))) {
       if (!FlowGraphCompiler::SupportsUnboxedMints() ||
           ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
@@ skipping 658 matching lines @@
                                    NULL,
                                    FlowGraph::kValue);
 
   intptr_t element_size = Instance::ElementSizeFor(array_cid);
   ConstantInstr* bytes_per_element =
       flow_graph()->GetConstant(Smi::Handle(I, Smi::New(element_size)));
   BinarySmiOpInstr* len_in_bytes =
       new(I) BinarySmiOpInstr(Token::kMUL,
                               new(I) Value(length),
                               new(I) Value(bytes_per_element),
-                              call->deopt_id(), call->token_pos());
+                              call->deopt_id());
   *cursor = flow_graph()->AppendTo(*cursor, len_in_bytes, call->env(),
                                    FlowGraph::kValue);
 
   // adjusted_length = len_in_bytes - (element_size - 1).
   Definition* adjusted_length = len_in_bytes;
   intptr_t adjustment = Instance::ElementSizeFor(view_cid) - 1;
   if (adjustment > 0) {
     ConstantInstr* length_adjustment =
         flow_graph()->GetConstant(Smi::Handle(I, Smi::New(adjustment)));
     adjusted_length =
         new(I) BinarySmiOpInstr(Token::kSUB,
                                 new(I) Value(len_in_bytes),
                                 new(I) Value(length_adjustment),
-                                call->deopt_id(), call->token_pos());
+                                call->deopt_id());
     *cursor = flow_graph()->AppendTo(*cursor, adjusted_length, call->env(),
                                      FlowGraph::kValue);
   }
 
   // Check adjusted_length > 0.
   ConstantInstr* zero =
       flow_graph()->GetConstant(Smi::Handle(I, Smi::New(0)));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    new(I) CheckArrayBoundInstr(
                                        new(I) Value(adjusted_length),
@@ skipping 3800 matching lines @@
 // cannot have constant values.
 void ConstantPropagator::VisitStoreContext(StoreContextInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckStackOverflow(
     CheckStackOverflowInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckClass(CheckClassInstr* instr) { }
 
+
 void ConstantPropagator::VisitCheckClassId(CheckClassIdInstr* instr) { }
 
+
 void ConstantPropagator::VisitGuardFieldClass(GuardFieldClassInstr* instr) { }
 
+
 void ConstantPropagator::VisitGuardFieldLength(GuardFieldLengthInstr* instr) { }
 
+
 void ConstantPropagator::VisitCheckSmi(CheckSmiInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckEitherNonSmi(
     CheckEitherNonSmiInstr* instr) { }
 
 
 void ConstantPropagator::VisitCheckArrayBound(CheckArrayBoundInstr* instr) { }
 
 
+void ConstantPropagator::VisitDeoptimize(DeoptimizeInstr* instr) {
+  // TODO(vegorov) remove all code after DeoptimizeInstr as dead.
+}
+
+
 // --------------------------------------------------------------------------
 // Analysis of definitions.  Compute the constant value.  If it has changed
 // and the definition has input uses, add the definition to the definition
 // worklist so that the used can be processed.
 void ConstantPropagator::VisitPhi(PhiInstr* instr) {
   // Compute the join over all the reachable predecessor values.
   JoinEntryInstr* block = instr->block();
   Object& value = Object::ZoneHandle(I, Unknown());
   for (intptr_t pred_idx = 0; pred_idx < instr->InputCount(); ++pred_idx) {
     if (reachable_->Contains(
@@ skipping 286 matching lines @@
   if (o.IsNull() || IsNonConstant(o)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(o)) {
     const String& str = String::Cast(o);
     const intptr_t result = (str.Length() == 1) ? str.CharAt(0) : -1;
     SetValue(instr, Smi::ZoneHandle(I, Smi::New(result)));
   }
 }
 
 
-
-
 void ConstantPropagator::VisitStringInterpolate(StringInterpolateInstr* instr) {
   SetValue(instr, non_constant_);
-  return;
 }
 
 
 void ConstantPropagator::VisitLoadIndexed(LoadIndexedInstr* instr) {
   const Object& array_obj = instr->array()->definition()->constant_value();
   const Object& index_obj = instr->index()->definition()->constant_value();
   if (IsNonConstant(array_obj) || IsNonConstant(index_obj)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(array_obj) && IsConstant(index_obj)) {
     // Need index to be Smi and array to be either String or an immutable array.
@@ skipping 221 matching lines @@
     AllocateUninitializedContextInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitCloneContext(CloneContextInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::HandleBinaryOp(Definition* instr,
-                                        Token::Kind op_kind,
-                                        const Value& left_val,
-                                        const Value& right_val) {
-  const Object& left = left_val.definition()->constant_value();
-  const Object& right = right_val.definition()->constant_value();
-  if (IsNonConstant(left) || IsNonConstant(right)) {
-    // TODO(srdjan): Add arithmetic simplifications, e.g, add with 0.
-    SetValue(instr, non_constant_);
-  } else if (IsConstant(left) && IsConstant(right)) {
+void ConstantPropagator::VisitBinaryIntegerOp(BinaryIntegerOpInstr* binary_op) {
+  const Object& left = binary_op->left()->definition()->constant_value();
+  const Object& right = binary_op->right()->definition()->constant_value();
+  if (IsConstant(left) && IsConstant(right)) {
     if (left.IsInteger() && right.IsInteger()) {
       const Integer& left_int = Integer::Cast(left);
       const Integer& right_int = Integer::Cast(right);
-      switch (op_kind) {
-        case Token::kTRUNCDIV:
-        case Token::kMOD:
-          // Check right value for zero.
-          if (right_int.AsInt64Value() == 0) {
-            SetValue(instr, non_constant_);
-            break;
-          }
-          // Fall through.
-        case Token::kADD:
-        case Token::kSUB:
-        case Token::kMUL: {
-          Instance& result = Integer::ZoneHandle(I,
-              left_int.ArithmeticOp(op_kind, right_int));
-          if (result.IsNull()) {
-            // TODO(regis): A bigint operation is required. Invoke dart?
-            // Punt for now.
-            SetValue(instr, non_constant_);
-            break;
-          }
-          result = result.CheckAndCanonicalize(NULL);
-          ASSERT(!result.IsNull());
-          SetValue(instr, result);
-          break;
-        }
-        case Token::kSHL:
-        case Token::kSHR:
-          if (left.IsSmi() &&
-              right.IsSmi() &&
-              (Smi::Cast(right).Value() >= 0)) {
-            Instance& result = Integer::ZoneHandle(I,
-                Smi::Cast(left_int).ShiftOp(op_kind, Smi::Cast(right_int)));
-            result = result.CheckAndCanonicalize(NULL);
-            ASSERT(!result.IsNull());
-            SetValue(instr, result);
-          } else {
-            SetValue(instr, non_constant_);
-          }
-          break;
-        case Token::kBIT_AND:
-        case Token::kBIT_OR:
-        case Token::kBIT_XOR: {
-          Instance& result = Integer::ZoneHandle(I,
-              left_int.BitOp(op_kind, right_int));
-          result = result.CheckAndCanonicalize(NULL);
-          ASSERT(!result.IsNull());
-          SetValue(instr, result);
-          break;
-        }
-        case Token::kDIV:
-          SetValue(instr, non_constant_);
-          break;
-        default:
-          UNREACHABLE();
+      const Integer& result =
+          Integer::Handle(I, binary_op->Evaluate(left_int, right_int));
+      if (!result.IsNull()) {
+        SetValue(binary_op, Integer::ZoneHandle(I, result.raw()));
+        return;
       }
-    } else {
-      // TODO(kmillikin): support other types.
-      SetValue(instr, non_constant_);
     }
   }
-}
 
-
-void ConstantPropagator::TruncateInteger(Definition* defn, int64_t mask) {
-  const Object& value = defn->constant_value();
-  if (IsNonConstant(value)) {
-    return;
-  }
-  ASSERT(IsConstant(value));
-  if (!value.IsInteger()) {
-    return;
-  }
-  const Integer& value_int = Integer::Cast(value);
-  int64_t truncated = value_int.AsInt64Value() & mask;
-  Instance& result = Integer::ZoneHandle(I, Integer::New(truncated));
-  result = result.CheckAndCanonicalize(NULL);
-  ASSERT(!result.IsNull());
-  SetValue(defn, result);
+  SetValue(binary_op, non_constant_);
 }
 
 
 void ConstantPropagator::VisitBinarySmiOp(BinarySmiOpInstr* instr) {
-  HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
+  VisitBinaryIntegerOp(instr);
 }
 
 
 void ConstantPropagator::VisitBinaryInt32Op(BinaryInt32OpInstr* instr) {
-  HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
+  VisitBinaryIntegerOp(instr);
+}
+
+
+void ConstantPropagator::VisitBinaryUint32Op(BinaryUint32OpInstr* instr) {
+  VisitBinaryIntegerOp(instr);
+}
+
+
+void ConstantPropagator::VisitShiftUint32Op(ShiftUint32OpInstr* instr) {
+  VisitBinaryIntegerOp(instr);
+}
+
+
+void ConstantPropagator::VisitBinaryMintOp(BinaryMintOpInstr* instr) {
+  VisitBinaryIntegerOp(instr);
+}
+
+
+void ConstantPropagator::VisitShiftMintOp(ShiftMintOpInstr* instr) {
+  VisitBinaryIntegerOp(instr);
 }
 
 
 void ConstantPropagator::VisitBoxInteger(BoxIntegerInstr* instr) {
   // TODO(kmillikin): Handle box operation.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnboxInteger(UnboxIntegerInstr* instr) {
   // TODO(kmillikin): Handle unbox operation.
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitBinaryMintOp(BinaryMintOpInstr* instr) {
-  HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
-}
-
-
-void ConstantPropagator::VisitShiftMintOp(ShiftMintOpInstr* instr) {
-  HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
-}
-
-
 void ConstantPropagator::VisitUnaryMintOp(UnaryMintOpInstr* instr) {
   // TODO(kmillikin): Handle unary operations.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnarySmiOp(UnarySmiOpInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
@@ skipping 455 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnboxedIntConverter(
     UnboxedIntConverterInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitBinaryUint32Op(BinaryUint32OpInstr* instr) {
-  HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
-  TruncateInteger(instr, static_cast<int64_t>(0xFFFFFFFF));
-}
-
-
-void ConstantPropagator::VisitShiftUint32Op(ShiftUint32OpInstr* instr) {
-  HandleBinaryOp(instr, instr->op_kind(), *instr->left(), *instr->right());
-  TruncateInteger(instr, static_cast<int64_t>(0xFFFFFFFF));
-}
-
-
 void ConstantPropagator::VisitUnaryUint32Op(UnaryUint32OpInstr* instr) {
   // TODO(kmillikin): Handle unary operations.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::Analyze() {
   GraphEntryInstr* entry = graph_->graph_entry();
   reachable_->Add(entry->preorder_number());
   block_worklist_.Add(entry);
@@ skipping 1202 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart