Intrinsics in the RUNTIME_FUNCTION_LIST are now available with '_', too.

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 9517 matching lines @@
     &HOptimizedGraphBuilder::Generate##Name,
 
 const HOptimizedGraphBuilder::InlineFunctionGenerator
     HOptimizedGraphBuilder::kInlineFunctionGenerators[] = {
         INLINE_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_ADDRESS)
         INLINE_OPTIMIZED_FUNCTION_LIST(INLINE_FUNCTION_GENERATOR_ADDRESS)
 };
 #undef INLINE_FUNCTION_GENERATOR_ADDRESS
 
 
+HOptimizedGraphBuilder::InlineFunctionGenerator
+HOptimizedGraphBuilder::FindInlineFunctionGenerator(CallRuntime* expr) {
+  const Runtime::Function* function = expr->function();
+  if (function == nullptr || function->intrinsic_type != Runtime::INLINE) {
+    return nullptr;
+  }
+  Runtime::FunctionId id = function->function_id;
+  if (id < Runtime::kFirstInlineFunction) return nullptr;
+  int lookup_index =
+      static_cast<int>(id) - static_cast<int>(Runtime::kFirstInlineFunction);
+  DCHECK(static_cast<size_t>(lookup_index) <
+         arraysize(kInlineFunctionGenerators));
+  return kInlineFunctionGenerators[lookup_index];
+}
+
+
 template <class ViewClass>
 void HGraphBuilder::BuildArrayBufferViewInitialization(
     HValue* obj,
     HValue* buffer,
     HValue* byte_offset,
     HValue* byte_length) {
 
   for (int offset = ViewClass::kSize;
        offset < ViewClass::kSizeWithInternalFields;
        offset += kPointerSize) {
@@ skipping 359 matching lines @@
   DCHECK(!HasStackOverflow());
   DCHECK(current_block() != NULL);
   DCHECK(current_block()->HasPredecessor());
   if (expr->is_jsruntime()) {
     return Bailout(kCallToAJavaScriptRuntimeFunction);
   }
 
   const Runtime::Function* function = expr->function();
   DCHECK(function != NULL);
 
-  if (function->intrinsic_type == Runtime::INLINE) {
+  InlineFunctionGenerator generator = FindInlineFunctionGenerator(expr);
+  if (generator != nullptr) {
     DCHECK(expr->name()->length() > 0);
     DCHECK(expr->name()->Get(0) == '_');
-    // Call to an inline function.
-    int lookup_index = static_cast<int>(function->function_id) -
-        static_cast<int>(Runtime::kFirstInlineFunction);
-    DCHECK(lookup_index >= 0);
-    DCHECK(static_cast<size_t>(lookup_index) <
-           arraysize(kInlineFunctionGenerators));
-    InlineFunctionGenerator generator = kInlineFunctionGenerators[lookup_index];
-
     // Call the inline code generator using the pointer-to-member.
     (this->*generator)(expr);
   } else {
-    DCHECK(function->intrinsic_type == Runtime::RUNTIME);
     Handle<String> name = expr->name();
     int argument_count = expr->arguments()->length();
     CHECK_ALIVE(VisitExpressions(expr->arguments()));
     PushArgumentsFromEnvironment(argument_count);
     HCallRuntime* call = New<HCallRuntime>(name, function,
                                            argument_count);
     return ast_context()->ReturnInstruction(call, expr->id());
   }
 }
 
@@ skipping 3472 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal