Reland: [Interpreter] Map runtime id's to intrinsic id's in InvokeIntrinsic bytecode.

src/interpreter/interpreter-intrinsics.cc

 // Copyright 2015 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/interpreter/interpreter-intrinsics.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 using compiler::Node;
 
 #define __ assembler_->
 
 IntrinsicsHelper::IntrinsicsHelper(InterpreterAssembler* assembler)
     : assembler_(assembler) {}
 
+// static
 bool IntrinsicsHelper::IsSupported(Runtime::FunctionId function_id) {
   switch (function_id) {
 #define SUPPORTED(name, lower_case, count) case Runtime::kInline##name:
     INTRINSICS_LIST(SUPPORTED)
     return true;
 #undef SUPPORTED
     default:
       return false;
   }
 }
 
+// static
+IntrinsicsHelper::IntrinsicId IntrinsicsHelper::FromRuntimeId(
+    Runtime::FunctionId function_id) {
+  switch (function_id) {
+#define TO_RUNTIME_ID(name, lower_case, count) \
+  case Runtime::kInline##name:                 \
+    return IntrinsicId::k##name;
+    INTRINSICS_LIST(TO_RUNTIME_ID)
+#undef TO_RUNTIME_ID
+    default:
+      UNREACHABLE();
+      return static_cast<IntrinsicsHelper::IntrinsicId>(-1);
+  }
+}
+
+// static
+Runtime::FunctionId IntrinsicsHelper::ToRuntimeId(
+    IntrinsicsHelper::IntrinsicId intrinsic_id) {
+  switch (intrinsic_id) {
+#define TO_INTRINSIC_ID(name, lower_case, count) \
+  case IntrinsicId::k##name:                     \
+    return Runtime::kInline##name;
+    INTRINSICS_LIST(TO_INTRINSIC_ID)
+#undef TO_INTRINSIC_ID
+    default:
+      UNREACHABLE();
+      return static_cast<Runtime::FunctionId>(-1);
+  }
+}
+
 Node* IntrinsicsHelper::InvokeIntrinsic(Node* function_id, Node* context,
                                         Node* first_arg_reg, Node* arg_count) {
   InterpreterAssembler::Label abort(assembler_), end(assembler_);
   InterpreterAssembler::Variable result(assembler_,
                                         MachineRepresentation::kTagged);
 
 #define MAKE_LABEL(name, lower_case, count) \
   InterpreterAssembler::Label lower_case(assembler_);
   INTRINSICS_LIST(MAKE_LABEL)
 #undef MAKE_LABEL
 
 #define LABEL_POINTER(name, lower_case, count) &lower_case,
   InterpreterAssembler::Label* labels[] = {INTRINSICS_LIST(LABEL_POINTER)};
 #undef LABEL_POINTER
 
 #define CASE(name, lower_case, count) \
-  static_cast<int32_t>(Runtime::kInline##name),
+  static_cast<int32_t>(IntrinsicId::k##name),
   int32_t cases[] = {INTRINSICS_LIST(CASE)};
 #undef CASE
 
   __ Switch(function_id, &abort, cases, labels, arraysize(cases));
 #define HANDLE_CASE(name, lower_case, expected_arg_count)   \
   __ Bind(&lower_case);                                     \
   if (FLAG_debug_code && expected_arg_count >= 0) {         \
     AbortIfArgCountMismatch(expected_arg_count, arg_count); \
   }                                                         \
   result.Bind(name(first_arg_reg, arg_count, context));     \
@@ skipping 171 matching lines @@
   Node* comparison = __ Word32Equal(actual, __ Int32Constant(expected));
   __ GotoIf(comparison, &match);
   __ Abort(kWrongArgumentCountForInvokeIntrinsic);
   __ Goto(&match);
   __ Bind(&match);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8