Prevent deopt on double value assignment to typed arrays

src/arm/lithium-arm.cc

 // Copyright 2011 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 1749 matching lines @@
   } else {
     ASSERT(input_rep.IsTagged());
     // Register allocator doesn't (yet) support allocation of double
     // temps. Reserve d1 explicitly.
     LClampTToUint8* result = new LClampTToUint8(reg, FixedTemp(d1));
     return AssignEnvironment(DefineAsRegister(result));
   }
 }
 
 
+LInstruction* LChunkBuilder::DoToInt32(HToInt32* instr) {
+  HValue* value = instr->value();
+  Representation input_rep = value->representation();
+  LOperand* reg = UseRegister(value);
+  if (input_rep.IsDouble()) {
+      LDoubleToI* res = new LDoubleToI(reg,

[Kevin Millikin (Chromium), 2011/05/26 07:53:37]

Two space indent here.

I'd name the two TempRegisters.  There is some dependence on the order uses are
communicated to the register allocator.  The use at this site is OK (right now),
but it would be better to have:

LOperand* temp1 = TempRegister();
LOperand* temp2 = TempRegister();
LDoubleToI* res = new LDoubleToI(reg, temp1, temp2);

if for no other reason than it is deterministic across compilers.

You can probably hoist temp1 and temp2 out of the if.

[danno, 2011/06/01 13:14:41]

Done.

+                                       TempRegister(),
+                                       TempRegister());
+      return AssignEnvironment(DefineAsRegister(res));
+  } else if (input_rep.IsInteger32()) {
+    // Canonicalization should already have removed the hydrogen instruction in
+    // this case, since it is a noop.
+    UNREACHABLE();
+    return NULL;
+  } else {
+    ASSERT(input_rep.IsTagged());
+    LOperand* temp1 = TempRegister();
+    LOperand* temp2 = TempRegister();
+    LOperand* temp3 = FixedTemp(d3);
+    LInstruction* res = DefineSameAsFirst(

[Kevin Millikin (Chromium), 2011/05/26 07:53:37]

I like

LTaggedToI* res = new LTaggedToI(reg, temp1, temp2, temp3);
return AssigneEnvironment(DefineSameAsFirst(res));

better.  It's consistent with the first clause and avoids the line break :)

[danno, 2011/06/01 13:14:41]

Done.

+        new LTaggedToI(reg, temp1, temp2, temp3));
+    return AssignEnvironment(res);
+  }
+}
+
+
 LInstruction* LChunkBuilder::DoReturn(HReturn* instr) {
   return new LReturn(UseFixed(instr->value(), r0));
 }
 
 
 LInstruction* LChunkBuilder::DoConstant(HConstant* instr) {
   Representation r = instr->representation();
   if (r.IsInteger32()) {
     return DefineAsRegister(new LConstantI);
   } else if (r.IsDouble()) {
@@ skipping 417 matching lines @@
 
 LInstruction* LChunkBuilder::DoIn(HIn* instr) {
   LOperand* key = UseRegisterAtStart(instr->key());
   LOperand* object = UseRegisterAtStart(instr->object());
   LIn* result = new LIn(key, object);
   return MarkAsCall(DefineFixed(result, r0), instr);
 }
 
 
 } }  // namespace v8::internal