Generate TypedArrayInitialize builtin in hydrogen.

src/hydrogen.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 40 matching lines @@
 #include "hydrogen-minus-zero.h"
 #include "hydrogen-osr.h"
 #include "hydrogen-range-analysis.h"
 #include "hydrogen-redundant-phi.h"
 #include "hydrogen-removable-simulates.h"
 #include "hydrogen-representation-changes.h"
 #include "hydrogen-sce.h"
 #include "hydrogen-uint32-analysis.h"
 #include "lithium-allocator.h"
 #include "parser.h"
+#include "runtime.h"
 #include "scopeinfo.h"
 #include "scopes.h"
 #include "stub-cache.h"
 #include "typing.h"
 
 #if V8_TARGET_ARCH_IA32
 #include "ia32/lithium-codegen-ia32.h"
 #elif V8_TARGET_ARCH_X64
 #include "x64/lithium-codegen-x64.h"
 #elif V8_TARGET_ARCH_ARM
@@ skipping 7974 matching lines @@
     &HOptimizedGraphBuilder::Generate##Name,
 
 const HOptimizedGraphBuilder::InlineFunctionGenerator
     HOptimizedGraphBuilder::kInlineFunctionGenerators[] = {
         INLINE_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_ADDRESS)
         INLINE_RUNTIME_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_ADDRESS)
 };
 #undef INLINE_FUNCTION_GENERATOR_ADDRESS
 
 
+void HOptimizedGraphBuilder::VisitTypedArrayInitialize(
+    CallRuntime* expr) {
+  ZoneList<Expression*>* arguments = expr->arguments();
+
+  NoObservableSideEffectsScope scope(this);
+  ASSERT(arguments->length()== 5);
+  CHECK_ALIVE(VisitForValue(arguments->at(0)));
+  HValue* obj = Pop();
+
+  ASSERT(arguments->at(1)->node_type() == AstNode::kLiteral);

[mvstanton, 2013/11/18 10:44:49]

Could you use constants for these arguments with a meaning-based name?

[Dmitry Lomov (no reviews), 2013/11/18 13:48:14]

Done. Great suggestion, because it uncovered a bug :)

+  Handle<Object> value = static_cast<Literal*>(arguments->at(1))->value();
+  ASSERT(value->IsSmi());

[mvstanton, 2013/11/18 10:44:49]

The assert is unnecessary because the Smi::cast will do the same.

[Dmitry Lomov (no reviews), 2013/11/18 13:48:14]

I am paranoid lately.

+  int array_id = Smi::cast(*value)->value();
+
+  CHECK_ALIVE(VisitForValue(arguments->at(2)));
+  HValue* buffer = Pop();
+
+  HValue* byte_offset;
+  bool is_zero_byte_offset;
+
+  if (arguments->at(3)->node_type() == AstNode::kLiteral
+      && Smi::FromInt(0) == *static_cast<Literal*>(arguments->at(1))->value()) {
+    byte_offset = Add<HConstant>(static_cast<int32_t>(0));
+    is_zero_byte_offset = true;
+  } else {
+    CHECK_ALIVE(VisitForValue(arguments->at(3)));
+    byte_offset = Pop();
+    is_zero_byte_offset = false;
+  }
+
+  CHECK_ALIVE(VisitForValue(arguments->at(4)));
+  HValue* byte_length = Pop();
+
+  IfBuilder byte_offset_smi(this);
+
+  if (!is_zero_byte_offset) {
+    byte_offset_smi.If<HIsSmiAndBranch>(byte_offset);
+    byte_offset_smi.Then();
+  }
+
+  ExternalArrayType array_type = kExternalByteArray;  // Bogus initialization.
+  size_t element_size = 1;  // Bogus initialization.
+  Runtime::ArrayIdToTypeAndSize(array_id, &array_type, &element_size);
+
+  for (int offset = JSTypedArray::kSize;
+        offset < JSTypedArray::kSizeWithInternalFields;
+        offset += kPointerSize) {
+    Add<HStoreNamedField>(obj,
+        HObjectAccess::ForJSObjectOffset(offset),
+        Add<HConstant>(static_cast<int32_t>(0)));

[mvstanton, 2013/11/18 10:44:49]

Not something we have to do now, but it would be neat if we had a memset
instruction that could do this very efficiently. I can think of other places
we'd use it. 

[Dmitry Lomov (no reviews), 2013/11/18 13:48:14]

Agreed.

+  }
+
+  Add<HStoreNamedField>(obj,
+      HObjectAccess::ForJSObjectOffset(JSTypedArray::kBufferOffset), buffer);
+  Add<HStoreNamedField>(obj,
+      HObjectAccess::ForJSObjectOffset(JSTypedArray::kByteOffsetOffset),
+      byte_offset);
+  Add<HStoreNamedField>(obj,
+      HObjectAccess::ForJSObjectOffset(JSTypedArray::kByteLengthOffset),
+      byte_length);
+
+  HInstruction* length = Add<HDiv>(byte_length,
+      Add<HConstant>(static_cast<int32_t>(element_size)));
+
+  Add<HStoreNamedField>(obj,
+      HObjectAccess::ForJSObjectOffset(JSTypedArray::kLengthOffset),
+      length);
+
+  Add<HStoreNamedField>(obj,
+      HObjectAccess::ForJSObjectOffset(JSTypedArray::kWeakNextOffset),
+      Add<HLoadNamedField>(buffer,
+          HObjectAccess::ForJSObjectOffset(
+

[mvstanton, 2013/11/18 10:44:49]

nit: Remove newline.

[Dmitry Lomov (no reviews), 2013/11/18 13:48:14]

Done.

+            JSArrayBuffer::kWeakFirstViewOffset)));
+  Add<HStoreNamedField>(buffer,
+      HObjectAccess::ForJSObjectOffset(JSArrayBuffer::kWeakFirstViewOffset),
+      obj);
+
+  HValue* elements =
+    Add<HAllocate>(
+        Add<HConstant>(ExternalArray::kAlignedSize),
+        HType::JSArray(),
+        isolate()->heap()->GetPretenureMode(),

[mvstanton, 2013/11/18 10:44:49]

It would be good if you continue passing NOT_TENURED here, like the current
runtime call does. The reason is that for the allocation-site-based pretenuring
work, we've identified sites that make use of this global mode and are (rather
painfully) addressing them in turn. I don't want that set to grow larger for the
moment.

[Dmitry Lomov (no reviews), 2013/11/18 13:48:14]

Done.

+        static_cast<InstanceType>(FIRST_EXTERNAL_ARRAY_TYPE + array_type));
+
+  Handle<Map> external_array_map(
+      isolate()->heap()->MapForExternalArrayType(array_type));
+
+  Add<HStoreNamedField>(elements,
+      HObjectAccess::ForMap(),
+      Add<HConstant>(external_array_map));
+  HValue* backing_store =
+      Add<HLoadNamedField>(buffer,
+        HObjectAccess::ForJSObjectOffset(
+          JSArrayBuffer::kBackingStoreOffset, Representation::External()));
+
+  HValue* typed_array_start;
+  if (is_zero_byte_offset) {
+    typed_array_start = backing_store;
+  } else {
+    HAdd* external_pointer =
+        HAdd::NewExternalPointerOffset(
+            zone(), graph()->GetInvalidContext(), backing_store, byte_offset);
+    // Arguments are checked prior to call to TypedArrayInitialize,
+    // including byte_offset.
+    external_pointer->ClearFlag(HValue::kCanOverflow);

[danno, 2013/11/18 14:26:17]

This should be folded into the constructor of the Add based on the
representation, probably.

[Dmitry Lomov (no reviews), 2013/11/18 16:43:54]

No, because it is in this particular case (in TypedArrayinitialize builtin) we
validate that (backing_store +byte_offset) cannot overflow. If we didn't do
that, it wouldn't be correct to assume no overflow here (and cause *interesting*
bugs!)

+    typed_array_start = AddInstruction(external_pointer);
+  }
+
+  Add<HStoreNamedField>(elements,
+      HObjectAccess::ForJSObjectOffset(
+        ExternalArray::kExternalPointerOffset, Representation::External()),
+      typed_array_start);
+  Add<HStoreNamedField>(elements,
+      HObjectAccess::ForJSObjectOffset(ExternalArray::kLengthOffset),
+      length);
+  Add<HStoreNamedField>(
+      obj, HObjectAccess::ForElementsPointer(), elements);
+
+  if (!is_zero_byte_offset) {
+    byte_offset_smi.Else();

[danno, 2013/11/18 14:26:17]

Perhaps use the {} indenting style used in code-stubs-hydrogen to help parse the
IfBuilder control flow?

[Dmitry Lomov (no reviews), 2013/11/18 16:43:54]

Done.

+    Push(Add<HPushArgument>(obj));
+    VisitArgument(arguments->at(1));
+    Push(Add<HPushArgument>(buffer));
+    Push(Add<HPushArgument>(byte_offset));
+    Push(Add<HPushArgument>(byte_length));
+    Add<HCallRuntime>(expr->name(), expr->function(), 5);
+    Drop(5);
+    byte_offset_smi.End();
+  }
+}
+
+
 void HOptimizedGraphBuilder::VisitCallRuntime(CallRuntime* expr) {
   ASSERT(!HasStackOverflow());
   ASSERT(current_block() != NULL);
   ASSERT(current_block()->HasPredecessor());
   if (expr->is_jsruntime()) {
     return Bailout(kCallToAJavaScriptRuntimeFunction);
   }
 
   const Runtime::Function* function = expr->function();
   ASSERT(function != NULL);
+
+  if (function->function_id == Runtime::kTypedArrayInitialize) {
+    return VisitTypedArrayInitialize(expr);
+  }
+
+  if (function->function_id == Runtime::kMaxSmi) {
+    ASSERT(expr->arguments()->length() == 0);
+    HConstant* max_smi = New<HConstant>(static_cast<int32_t>(Smi::kMaxValue));
+    return ast_context()->ReturnInstruction(max_smi, expr->id());
+  }
+
   if (function->intrinsic_type == Runtime::INLINE) {
     ASSERT(expr->name()->length() > 0);
     ASSERT(expr->name()->Get(0) == '_');
     // Call to an inline function.
     int lookup_index = static_cast<int>(function->function_id) -
         static_cast<int>(Runtime::kFirstInlineFunction);
     ASSERT(lookup_index >= 0);
     ASSERT(static_cast<size_t>(lookup_index) <
            ARRAY_SIZE(kInlineFunctionGenerators));
     InlineFunctionGenerator generator = kInlineFunctionGenerators[lookup_index];
@@ skipping 2475 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal