Generate TypedArrayInitialize builtin in hydrogen.

src/hydrogen-instructions.cc

 // Copyright 2012 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 1251 matching lines @@
   }
   // Optimize double negation, a common pattern used for ToInt32(x).
   HValue* arg;
   if (MatchDoubleNegation(this, &arg) && !arg->CheckFlag(kUint32)) {
     return arg;
   }
   return this;
 }
 
 
+Representation HAdd::RepresentationFromInputs() {
+  Representation left_rep = left()->representation();
+  if (left_rep.IsExternal()) {
+    return Representation::External();
+  }
+  return HArithmeticBinaryOperation::RepresentationFromInputs();
+}
+
+
+Representation HAdd::RequiredInputRepresentation(int index) {
+  if (index == 2) {
+    Representation left_rep = left()->representation();
+    if (left_rep.IsExternal()) {
+      return Representation::Integer32();
+    }
+  }
+  return HArithmeticBinaryOperation::RequiredInputRepresentation(index);
+}
+
+
 static bool IsIdentityOperation(HValue* arg1, HValue* arg2, int32_t identity) {
   return arg1->representation().IsSpecialization() &&
     arg2->EqualsInteger32Constant(identity);
 }
 
 
 HValue* HAdd::Canonicalize() {
   // Adding 0 is an identity operation except in case of -0: -0 + 0 = +0
   if (IsIdentityOperation(left(), right(), 0) &&
       !left()->representation().IsDouble()) {  // Left could be -0.
@@ skipping 2467 matching lines @@
       if (TypeInfo::IsInt32Double(double_res)) {                               \
         return H_CONSTANT_INT(double_res);                                     \
       }                                                                        \
       return H_CONSTANT_DOUBLE(double_res);                                    \
     }                                                                          \
   }                                                                            \
   return new(zone) HInstr(context, left, right);                               \
 }
 
 
-DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HAdd, +)
 DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HMul, *)
 DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HSub, -)
 
 #undef DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR
 
 
+HInstruction* HAdd::New(
+    Zone* zone, HValue* context, HValue* left, HValue* right,
+    Representation forced_representation) {
+  if (!forced_representation.IsNone()) {

[Dmitry Lomov (no reviews), 2013/11/19 09:42:04]

I am not entirely convinced this is a good change. In my original patch, I
explicitly created an (external + offset) => external instruction, which is the
only case we handle downstream. Here it appears that we can handle a (r + smth)
=> r for all r, which is not true. wdyt?

[danno, 2013/11/20 09:45:25]

I see your point, but I also really don't like the idea of two instructions. It
seems the Add should "automagically" do the right thing when one of it's inputs
is an external pointer, since that's the special case you need to handle. i.e.
why do you need to set the observed input representation in the first place?
Shouldn't the instruction just do the right thing when this input is External?
If not, there seems to be some missing machinery somewhere else.

Alternatively, since there are only two additional calls that are needed in this
path, can it be done separately from the constructor? i.e. remove the input to
the constructor and have a "MarkAsExternalPointerAdd" method?

In any case, let's discuss in person.

+    HAdd* result = new(zone) HAdd(context, left, right);
+
+    result->set_observed_input_representation(1, forced_representation);
+    result->initialize_output_representation(forced_representation);
+    return result;
+  }
+  if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
+    HConstant* c_left = HConstant::cast(left);
+    HConstant* c_right = HConstant::cast(right);
+    if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {
+      double double_res = c_left->DoubleValue() + c_right->DoubleValue();
+      if (TypeInfo::IsInt32Double(double_res)) {
+        return H_CONSTANT_INT(double_res);
+      }
+      return H_CONSTANT_DOUBLE(double_res);
+    }
+  }
+  return new(zone) HAdd(context, left, right);
+}
+
+
 HInstruction* HStringAdd::New(Zone* zone,
                               HValue* context,
                               HValue* left,
                               HValue* right,
                               StringAddFlags flags) {
   if (FLAG_fold_constants && left->IsConstant() && right->IsConstant()) {
     HConstant* c_right = HConstant::cast(right);
     HConstant* c_left = HConstant::cast(left);
     if (c_left->HasStringValue() && c_right->HasStringValue()) {
       Handle<String> concat = zone->isolate()->factory()->NewFlatConcatString(
@@ skipping 589 matching lines @@
       break;
     case kExternalMemory:
       stream->Add("[external-memory]");
       break;
   }
 
   stream->Add("@%d", offset());
 }
 
 } }  // namespace v8::internal