A64: Synchronize with r15922.

src/a64/lithium-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 816 matching lines @@
 LInstruction* LChunkBuilder::DoArithmeticT(Token::Value op,
                                            HBinaryOperation* instr) {
   ASSERT((op == Token::ADD) || (op == Token::SUB) || (op == Token::MUL) ||
          (op == Token::DIV) || (op == Token::MOD) || (op == Token::SHR) ||
          (op == Token::SHL) || (op == Token::SAR) || (op == Token::ROR) ||
          (op == Token::BIT_OR) || (op == Token::BIT_AND) ||
          (op == Token::BIT_XOR));
   HValue* left = instr->left();
   HValue* right = instr->right();
 
+  // TODO(jbramley): Once we've implemented smi support for all arithmetic
+  // operations, these assertions should check IsTagged().
   ASSERT(instr->representation().IsSmiOrTagged());
   ASSERT(left->representation().IsSmiOrTagged());
   ASSERT(right->representation().IsSmiOrTagged());
 
   LOperand* left_operand = UseFixed(left, x1);
   LOperand* right_operand = UseFixed(right, x0);
   LArithmeticT* result =
       new(zone()) LArithmeticT(op, left_operand, right_operand);
   return MarkAsCall(DefineFixed(result, x0), instr);
 }
@@ skipping 41 matching lines @@
     index = UseRegisterOrConstantAtStart(instr->index());
     temp = TempRegister();
   }
 
   return DefineAsRegister(
       new(zone()) LAccessArgumentsAt(args, length, index, temp));
 }
 
 
 LInstruction* LChunkBuilder::DoAdd(HAdd* instr) {
-  if (instr->representation().IsInteger32()) {
-    // TODO(all): LAddI instruction should also handle the addition of
-    // two SMI values.
-    ASSERT(instr->left()->representation().IsInteger32());
-    ASSERT(instr->right()->representation().IsInteger32());
+  if (instr->representation().IsSmiOrInteger32()) {
+    ASSERT(instr->left()->representation().Equals(instr->representation()));
+    ASSERT(instr->right()->representation().Equals(instr->representation()));
     LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
     LOperand* right =
         UseRegisterOrConstantAtStart(instr->BetterRightOperand());
-    LInstruction* result = DefineAsRegister(new(zone()) LAddI(left, right));
+    LInstruction* result = instr->representation().IsSmi() ?
+        DefineAsRegister(new(zone()) LAddS(left, right)) :
+        DefineAsRegister(new(zone()) LAddI(left, right));
     if (instr->CheckFlag(HValue::kCanOverflow)) {
       result = AssignEnvironment(result);
     }
     return result;
   } else if (instr->representation().IsDouble()) {
     return DoArithmeticD(Token::ADD, instr);
   } else {
-    ASSERT(instr->representation().IsSmiOrTagged());
+    ASSERT(instr->representation().IsTagged());
     return DoArithmeticT(Token::ADD, instr);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoAllocate(HAllocate* instr) {
   info()->MarkAsDeferredCalling();
   LOperand* size = UseRegisterOrConstant(instr->size());
   LOperand* temp1 = TempRegister();
   LOperand* temp2 = TempRegister();
@@ skipping 32 matching lines @@
 LInstruction* LChunkBuilder::DoArgumentsObject(HArgumentsObject* instr) {
   // There are no real uses of the arguments object.
   // arguments.length and element access are supported directly on
   // stack arguments, and any real arguments object use causes a bailout.
   // So this value is never used.
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoBitwise(HBitwise* instr) {
-  // TODO(all): The latest bleeding_edge handles smi representations too.
-  if (instr->representation().IsInteger32()) {
-    ASSERT(instr->left()->representation().IsInteger32());
-    ASSERT(instr->right()->representation().IsInteger32());
+  if (instr->representation().IsSmiOrInteger32()) {
+    ASSERT(instr->left()->representation().Equals(instr->representation()));
+    ASSERT(instr->right()->representation().Equals(instr->representation()));
 
     LOperand* left = UseRegisterAtStart(instr->BetterLeftOperand());
     LOperand* right =
         UseRegisterOrConstantAtStart(instr->BetterRightOperand());
-    return DefineAsRegister(new(zone()) LBitI(left, right));
+    return instr->representation().IsSmi() ?
+        DefineAsRegister(new(zone()) LBitS(left, right)) :
+        DefineAsRegister(new(zone()) LBitI(left, right));
   } else {
     return DoArithmeticT(instr->op(), instr);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoBitNot(HBitNot* instr) {
   ASSERT(instr->value()->representation().IsInteger32());
   ASSERT(instr->representation().IsInteger32());
   if (instr->HasNoUses()) return NULL;
@@ skipping 255 matching lines @@
 
 LInstruction* LChunkBuilder::DoCheckInstanceType(HCheckInstanceType* instr) {
   LOperand* value = UseRegisterAtStart(instr->value());
   LOperand* temp = TempRegister();
   LInstruction* result = new(zone()) LCheckInstanceType(value, temp);
   return AssignEnvironment(result);
 }
 
 
 LInstruction* LChunkBuilder::DoCheckMaps(HCheckMaps* instr) {
-  LOperand* value = UseRegister(instr->value());
-  LOperand* temp = TempRegister();
-  LInstruction* result = new(zone()) LCheckMaps(value, temp);
-  return AssignEnvironment(result);
+  if (instr->CanOmitMapChecks()) {
+    LOperand* value = UseRegisterAtStart(instr->value());
+    return new(zone()) LCheckMaps(value);
+  } else {
+    LOperand* value = UseRegister(instr->value());
+    LOperand* temp = TempRegister();
+    LInstruction* result = new(zone()) LCheckMaps(value, temp);
+    return AssignEnvironment(result);
+  }
 }
 
 
 LInstruction* LChunkBuilder::DoCheckHeapObject(HCheckHeapObject* instr) {
   LOperand* value = UseRegisterAtStart(instr->value());
   return AssignEnvironment(new(zone()) LCheckNonSmi(value));
 }
 
 
 LInstruction* LChunkBuilder::DoCheckPrototypeMaps(HCheckPrototypeMaps* instr) {
-  // TODO(jbramley): The scratch registers are not needed if
-  // instr->CanOmitPrototypeChecks(). Can we safely test that here?
-  LOperand* temp1 = TempRegister();
-  LOperand* temp2 = TempRegister();
-  return AssignEnvironment(new(zone()) LCheckPrototypeMaps(temp1, temp2));
+  if (instr->CanOmitPrototypeChecks()) {
+    return new(zone()) LCheckPrototypeMaps();
+  } else {
+    LOperand* temp1 = TempRegister();
+    LOperand* temp2 = TempRegister();
+    return AssignEnvironment(new(zone()) LCheckPrototypeMaps(temp1, temp2));
+  }
 }
 
 
 LInstruction* LChunkBuilder::DoCheckSmi(HCheckSmi* instr) {
   LOperand* value = UseRegisterAtStart(instr->value());
   return AssignEnvironment(new(zone()) LCheckSmi(value));
 }
 
 
 LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
@@ skipping 82 matching lines @@
 
 
 LInstruction* LChunkBuilder::DoCompareMap(HCompareMap* instr) {
   ASSERT(instr->value()->representation().IsTagged());
   LOperand* value = UseRegisterAtStart(instr->value());
   LOperand* temp = TempRegister();
   return new(zone()) LCmpMapAndBranch(value, temp);
 }
 
 
-LInstruction* LChunkBuilder::DoCompareConstantEqAndBranch(
-    HCompareConstantEqAndBranch* instr) {
-  UNIMPLEMENTED_INSTRUCTION();
-}
-
-
 LInstruction* LChunkBuilder::DoConstant(HConstant* instr) {
   Representation r = instr->representation();
   if (r.IsSmi()) {
     return DefineAsRegister(new(zone()) LConstantS);
   } else if (r.IsInteger32()) {
     return DefineAsRegister(new(zone()) LConstantI);
   } else if (r.IsDouble()) {
     return DefineAsRegister(new(zone()) LConstantD);
   } else if (r.IsTagged()) {
     return DefineAsRegister(new(zone()) LConstantT);
@@ skipping 299 matching lines @@
 
 
 LInstruction* LChunkBuilder::DoLoadGlobalGeneric(HLoadGlobalGeneric* instr) {
   LOperand* global_object = UseFixed(instr->global_object(), x0);
   LLoadGlobalGeneric* result = new(zone()) LLoadGlobalGeneric(global_object);
   return MarkAsCall(DefineFixed(result, x0), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoLoadKeyed(HLoadKeyed* instr) {
-  ASSERT(instr->key()->representation().IsInteger32() ||
-         instr->key()->representation().IsSmi());
+  ASSERT(instr->key()->representation().IsSmiOrInteger32());
   ElementsKind elements_kind = instr->elements_kind();
   LOperand* elements = UseRegister(instr->elements());
   LOperand* key = UseRegisterOrConstantAtStart(instr->key());
 
   if (!instr->is_external()) {
     if (instr->representation().IsDouble()) {
       LOperand* temp = (!instr->key()->IsConstant() ||
                         instr->RequiresHoleCheck())
              ? TempRegister()
              : NULL;
@@ skipping 104 matching lines @@
   LOperand* divisor = UseRegister(right);
   LOperand* remainder = TempRegister();
   return AssignEnvironment(DefineAsRegister(
           new(zone()) LMathFloorOfDiv(dividend, divisor, remainder)));
 }
 
 
 LInstruction* LChunkBuilder::DoMathMinMax(HMathMinMax* instr) {
   LOperand* left = NULL;
   LOperand* right = NULL;
-  if (instr->representation().IsInteger32()) {
+  if (instr->representation().IsSmiOrInteger32()) {
     ASSERT(instr->left()->representation().IsInteger32());
     ASSERT(instr->right()->representation().IsInteger32());
     left = UseRegisterAtStart(instr->BetterLeftOperand());
     right = UseRegisterOrConstantAtStart(instr->BetterRightOperand());
   } else {
     ASSERT(instr->representation().IsDouble());
     ASSERT(instr->left()->representation().IsDouble());
     ASSERT(instr->right()->representation().IsDouble());
     left = UseRegisterAtStart(instr->left());
     right = UseRegisterAtStart(instr->right());
   }
   return DefineAsRegister(new(zone()) LMathMinMax(left, right));
 }
 
 
 LInstruction* LChunkBuilder::DoMod(HMod* hmod) {
   HValue* hleft = hmod->left();
   HValue* hright = hmod->right();
 
+  // TODO(jbramley): Add smi support.
   if (hmod->representation().IsInteger32()) {
     ASSERT(hleft->representation().IsInteger32());
     ASSERT(hleft->representation().IsInteger32());
     LOperand* left_op;
     LOperand* right_op;
 
     if (hmod->HasPowerOf2Divisor()) {
       left_op = UseRegisterAtStart(hleft);
       right_op = UseConstant(hright);
     } else {
@@ skipping 12 matching lines @@
 
   } else if (hmod->representation().IsSmiOrTagged()) {
     return DoArithmeticT(Token::MOD, hmod);
   } else {
     return DoArithmeticD(Token::MOD, hmod);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoMul(HMul* instr) {
-  if (instr->representation().IsInteger32()) {
-    ASSERT(instr->left()->representation().IsInteger32());
-    ASSERT(instr->right()->representation().IsInteger32());
+  if (instr->representation().IsSmi()) {
+    // TODO(jbramley): Implement LMulConstS, then merge this into the Integer32
+    // case.
+    ASSERT(instr->left()->representation().Equals(instr->representation()));
+    ASSERT(instr->right()->representation().Equals(instr->representation()));
 
     bool can_overflow = instr->CheckFlag(HValue::kCanOverflow);
     bool bailout_on_minus_zero = instr->CheckFlag(HValue::kBailoutOnMinusZero);
+    bool needs_environment = can_overflow || bailout_on_minus_zero;
+
+    LOperand* left = UseRegister(instr->BetterLeftOperand());
+    LOperand* right = UseRegister(instr->BetterRightOperand());
+
+    LMulS* mul = new(zone()) LMulS(left, right);
+    if (needs_environment) AssignEnvironment(mul);
+    return DefineAsRegister(mul);
+  } else if (instr->representation().IsSmiOrInteger32()) {
+    ASSERT(instr->left()->representation().Equals(instr->representation()));
+    ASSERT(instr->right()->representation().Equals(instr->representation()));
+
+    bool can_overflow = instr->CheckFlag(HValue::kCanOverflow);
+    bool bailout_on_minus_zero = instr->CheckFlag(HValue::kBailoutOnMinusZero);
     bool needs_environment = can_overflow || bailout_on_minus_zero;
 
     HValue* least_const = instr->BetterLeftOperand();
     HValue* most_const = instr->BetterRightOperand();
 
     LOperand* left = UseRegisterAtStart(least_const);
 
     // LMulConstI can handle a subset of constants:
     //  With support for overflow detection:
     //    -1, 0, 1, 2
@@ skipping 108 matching lines @@
   LOperand* temp = TempRegister();
   LSeqStringSetChar* result =
       new(zone()) LSeqStringSetChar(instr->encoding(),
                                     string, index, value, temp);
   return DefineAsRegister(result);
 }
 
 
 LInstruction* LChunkBuilder::DoShift(Token::Value op,
                                      HBitwiseBinaryOperation* instr) {
+  // TODO(jbramley): Support smis inline, like integers.
   if (instr->representation().IsSmiOrTagged()) {
     return DoArithmeticT(op, instr);
   }
 
   ASSERT(instr->representation().IsInteger32());
-  ASSERT(instr->left()->representation().IsInteger32());
-  ASSERT(instr->right()->representation().IsInteger32());
+  ASSERT(instr->left()->representation().Equals(instr->representation()));
+  ASSERT(instr->right()->representation().Equals(instr->representation()));
   LOperand* left = UseRegisterAtStart(instr->left());
 
   HValue* right_value = instr->right();
   LOperand* right = NULL;
   int constant_value = 0;
   if (right_value->IsConstant()) {
     right = UseConstant(right_value);
     HConstant* constant = HConstant::cast(right_value);
     constant_value = constant->Integer32Value() & 0x1f;
   } else {
@@ skipping 69 matching lines @@
         SetDeferredLazyDeoptimizationEnvironment(result->environment());
     instruction_pending_deoptimization_environment_ = NULL;
     pending_deoptimization_ast_id_ = BailoutId::None();
     return result;
   }
 
   return NULL;
 }
 
 
-LInstruction* LChunkBuilder::DoSoftDeoptimize(HSoftDeoptimize* instr) {
-  return AssignEnvironment(new(zone()) LDeoptimize);
-}
-
-
 LInstruction* LChunkBuilder::DoStackCheck(HStackCheck* instr) {
   if (instr->is_function_entry()) {
     return MarkAsCall(new(zone()) LStackCheck, instr);
   } else {
     ASSERT(instr->is_backwards_branch());
     return AssignEnvironment(AssignPointerMap(new(zone()) LStackCheck));
   }
 }
 
 
@@ skipping 164 matching lines @@
 
 
 LInstruction* LChunkBuilder::DoStringLength(HStringLength* instr) {
   // TODO(all): This instruction doesn't exist anymore on bleeding_edge.
   LOperand* string = UseRegisterAtStart(instr->value());
   return DefineAsRegister(new(zone()) LStringLength(string));
 }
 
 
 LInstruction* LChunkBuilder::DoSub(HSub* instr) {
+  // TODO(jbramley): Add smi support.
   if (instr->representation().IsInteger32()) {
     ASSERT(instr->left()->representation().IsInteger32());
     ASSERT(instr->right()->representation().IsInteger32());
 
     LOperand *left;
     if (instr->left()->IsConstant() &&
        (HConstant::cast(instr->left())->Integer32Value() == 0)) {
       left = UseConstant(instr->left());
     } else {
       left = UseRegisterAtStart(instr->left());
@@ skipping 33 matching lines @@
 
 LInstruction* LChunkBuilder::DoToFastProperties(HToFastProperties* instr) {
   LOperand* object = UseFixed(instr->value(), x0);
   LToFastProperties* result = new(zone()) LToFastProperties(object);
   return MarkAsCall(DefineFixed(result, x0), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoTransitionElementsKind(
     HTransitionElementsKind* instr) {
+  LOperand* object = UseRegister(instr->object());
   if (IsSimpleMapChangeTransition(instr->from_kind(), instr->to_kind())) {
-    LOperand* object = UseRegister(instr->object());
     LTransitionElementsKind* result =
         new(zone()) LTransitionElementsKind(object, TempRegister(),
                                             TempRegister());
     return result;
-  } else if (FLAG_compiled_transitions) {
-    LOperand* object = UseRegister(instr->object());
+  } else {
     LTransitionElementsKind* result =
-        new(zone()) LTransitionElementsKind(object, NULL, NULL);
+        new(zone()) LTransitionElementsKind(object, TempRegister());
     return AssignPointerMap(result);
-  } else {
-    LOperand* object = UseFixed(instr->object(), x0);
-    LTransitionElementsKind* result =
-        new(zone()) LTransitionElementsKind(object, NULL, NULL);
-    return MarkAsCall(result, instr);
   }
 }
 
 
 LInstruction* LChunkBuilder::DoTrapAllocationMemento(
     HTrapAllocationMemento* instr) {
   LOperand* object = UseRegister(instr->object());
   LOperand* temp1 = TempRegister();
   LOperand* temp2 = TempRegister();
   LTrapAllocationMemento* result =
@@ skipping 186 matching lines @@
 LInstruction* LChunkBuilder::DoWrapReceiver(HWrapReceiver* instr) {
   LOperand* receiver = UseRegister(instr->receiver());
   LOperand* function = UseRegisterAtStart(instr->function());
   LOperand* temp = TempRegister();
   LWrapReceiver* result = new(zone()) LWrapReceiver(receiver, function, temp);
   return AssignEnvironment(DefineAsRegister(result));
 }
 
 
 } }  // namespace v8::internal