[VM DBC compiler and simulator] Support reified generic functions.

runtime/vm/simulator_dbc.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
@@ skipping 156 matching lines @@
   DART_FORCE_INLINE static T* Untag(T* tagged) {
     return tagged->ptr();
   }
 
   DART_FORCE_INLINE static bool CheckIndex(RawSmi* index, RawSmi* length) {
     return !index->IsHeapObject() && (reinterpret_cast<intptr_t>(index) >= 0) &&
            (reinterpret_cast<intptr_t>(index) <
             reinterpret_cast<intptr_t>(length));
   }
 
+  DART_FORCE_INLINE static intptr_t ArgDescTypeArgsLen(RawArray* argdesc) {
+    return Smi::Value(*reinterpret_cast<RawSmi**>(
+        reinterpret_cast<uword>(argdesc->ptr()) +
+        Array::element_offset(ArgumentsDescriptor::kTypeArgsLenIndex)));
+  }
+
+  DART_FORCE_INLINE static intptr_t ArgDescArgCount(RawArray* argdesc) {
+    return Smi::Value(*reinterpret_cast<RawSmi**>(
+        reinterpret_cast<uword>(argdesc->ptr()) +
+        Array::element_offset(ArgumentsDescriptor::kCountIndex)));
+  }
+
+  DART_FORCE_INLINE static intptr_t ArgDescPosCount(RawArray* argdesc) {
+    return Smi::Value(*reinterpret_cast<RawSmi**>(
+        reinterpret_cast<uword>(argdesc->ptr()) +
+        Array::element_offset(ArgumentsDescriptor::kPositionalCountIndex)));
+  }
+
   static bool ObjectArraySetIndexed(Thread* thread,
                                     RawObject** FP,
                                     RawObject** result) {
     if (thread->isolate()->type_checks()) {
       return false;
     }
 
     RawObject** args = FrameArguments(FP, 3);
     RawSmi* index = static_cast<RawSmi*>(args[1]);
     RawArray* array = static_cast<RawArray*>(args[0]);
@@ skipping 641 matching lines @@
                                                 uint32_t** pc,
                                                 RawObject*** FP,
                                                 RawObject*** SP,
                                                 bool optimized) {
   ASSERT(icdata->GetClassId() == kICDataCid);
 
   const intptr_t kCheckedArgs = 1;
   RawObject** args = call_base;
   RawArray* cache = icdata->ptr()->ic_data_->ptr();
 
-  RawSmi* receiver_cid = SimulatorHelpers::GetClassIdAsSmi(args[0]);
+  const intptr_t type_args_len =
+      SimulatorHelpers::ArgDescTypeArgsLen(icdata->ptr()->args_descriptor_);
+  const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0;
+  RawSmi* receiver_cid = SimulatorHelpers::GetClassIdAsSmi(args[receiver_idx]);
 
   bool found = false;
   const intptr_t length = Smi::Value(cache->length_);
   intptr_t i;
   for (i = 0; i < (length - (kCheckedArgs + 2)); i += (kCheckedArgs + 2)) {
     if (cache->data()[i + 0] == receiver_cid) {
       top[0] = cache->data()[i + kCheckedArgs];
       found = true;
       break;
     }
   }
 
   if (found) {
     if (!optimized) {
       SimulatorHelpers::IncrementICUsageCount(cache->data(), i, kCheckedArgs);
     }
   } else {
-    InlineCacheMiss(kCheckedArgs, thread, icdata, call_base, top, *pc, *FP,
-                    *SP);
+    InlineCacheMiss(kCheckedArgs, thread, icdata, call_base + receiver_idx, top,
+                    *pc, *FP, *SP);
   }
 
   *argdesc = icdata->ptr()->args_descriptor_;
   Invoke(thread, call_base, top, pp, pc, FP, SP);
 }
 
 DART_FORCE_INLINE void Simulator::InstanceCall2(Thread* thread,
                                                 RawICData* icdata,
                                                 RawObject** call_base,
                                                 RawObject** top,
                                                 RawArray** argdesc,
                                                 RawObjectPool** pp,
                                                 uint32_t** pc,
                                                 RawObject*** FP,
                                                 RawObject*** SP,
                                                 bool optimized) {
   ASSERT(icdata->GetClassId() == kICDataCid);
 
   const intptr_t kCheckedArgs = 2;
   RawObject** args = call_base;
   RawArray* cache = icdata->ptr()->ic_data_->ptr();
 
-  RawSmi* receiver_cid = SimulatorHelpers::GetClassIdAsSmi(args[0]);
-  RawSmi* arg0_cid = SimulatorHelpers::GetClassIdAsSmi(args[1]);
+  const intptr_t type_args_len =
+      SimulatorHelpers::ArgDescTypeArgsLen(icdata->ptr()->args_descriptor_);
+  const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0;
+  RawSmi* receiver_cid = SimulatorHelpers::GetClassIdAsSmi(args[receiver_idx]);
+  RawSmi* arg0_cid = SimulatorHelpers::GetClassIdAsSmi(args[receiver_idx + 1]);
 
   bool found = false;
   const intptr_t length = Smi::Value(cache->length_);
   intptr_t i;
   for (i = 0; i < (length - (kCheckedArgs + 2)); i += (kCheckedArgs + 2)) {
     if ((cache->data()[i + 0] == receiver_cid) &&
         (cache->data()[i + 1] == arg0_cid)) {
       top[0] = cache->data()[i + kCheckedArgs];
       found = true;
       break;
     }
   }
 
   if (found) {
     if (!optimized) {
       SimulatorHelpers::IncrementICUsageCount(cache->data(), i, kCheckedArgs);
     }
   } else {
-    InlineCacheMiss(kCheckedArgs, thread, icdata, call_base, top, *pc, *FP,
-                    *SP);
+    InlineCacheMiss(kCheckedArgs, thread, icdata, call_base + receiver_idx, top,
+                    *pc, *FP, *SP);
   }
 
   *argdesc = icdata->ptr()->args_descriptor_;
   Invoke(thread, call_base, top, pp, pc, FP, SP);
 }
 
 // Note: functions below are marked DART_NOINLINE to recover performance on
 // ARM where inlining these functions into the interpreter loop seemed to cause
 // some code quality issues.
 static DART_NOINLINE bool InvokeRuntime(Thread* thread,
@@ skipping 342 matching lines @@
     fp_[1 + i] = arguments.At(i);
   }
 
   FP[kFunctionSlotFromFp] = code.function();
   FP[kPcMarkerSlotFromFp] = code.raw();
   FP[kSavedCallerPcSlotFromFp] = reinterpret_cast<RawObject*>((argc << 2) | 2);
   FP[kSavedCallerFpSlotFromFp] = reinterpret_cast<RawObject*>(fp_);
 
   // Load argument descriptor.
   argdesc = arguments_descriptor.raw();
+  ASSERT(ArgumentsDescriptor(arguments_descriptor).TypeArgsLen() == 0);
 
   // Ready to start executing bytecode. Load entry point and corresponding
   // object pool.
   pc = reinterpret_cast<uint32_t*>(code.raw()->ptr()->entry_point_);
   pc_ = reinterpret_cast<uword>(pc);  // For the profiler.
   pp = code.object_pool()->ptr();
 
   // Cache some frequently used values in the frame.
   RawBool* true_value = Bool::True().raw();
   RawBool* false_value = Bool::False().raw();
   RawObject* null_value = Object::null();
   RawObject* empty_context = Object::empty_context().raw();
 
 #if defined(DEBUG)
   Function& function_h = Function::Handle();
 #endif
 
   // Enter the dispatch loop.
   DISPATCH();
 
   // Bytecode handlers (see constants_dbc.h for bytecode descriptions).
   {
     BYTECODE(Entry, A_B_C);
     const uint8_t num_fixed_params = rA;
     const uint16_t num_locals = rB;
     const uint16_t context_reg = rC;
 
     // Decode arguments descriptor.
-    const intptr_t pos_count = Smi::Value(*reinterpret_cast<RawSmi**>(
-        reinterpret_cast<uword>(argdesc->ptr()) +
-        Array::element_offset(ArgumentsDescriptor::kPositionalCountIndex)));
+    const intptr_t pos_count = SimulatorHelpers::ArgDescPosCount(argdesc);
 
     // Check that we got the right number of positional parameters.
     if (pos_count != num_fixed_params) {
       // Mismatch can only occur if current function is a closure.
       goto ClosureNoSuchMethod;
     }
 
     // Initialize locals with null and set current context variable to
     // empty context.
     {
       RawObject** L = FP;
       for (intptr_t i = 0; i < num_locals; i++) {
         L[i] = null_value;
       }
       L[context_reg] = empty_context;
       SP = FP + num_locals - 1;
     }
 
     DISPATCH();
   }
 
   {
     BYTECODE(EntryOptimized, A_D);
     const uint8_t num_fixed_params = rA;
     const uint16_t num_registers = rD;
 
     // Decode arguments descriptor.
-    const intptr_t pos_count = Smi::Value(*reinterpret_cast<RawSmi**>(
-        reinterpret_cast<uword>(argdesc->ptr()) +
-        Array::element_offset(ArgumentsDescriptor::kPositionalCountIndex)));
+    const intptr_t pos_count = SimulatorHelpers::ArgDescPosCount(argdesc);
 
     // Check that we got the right number of positional parameters.
     if (pos_count != num_fixed_params) {
       // Mismatch can only occur if current function is a closure.
       goto ClosureNoSuchMethod;
     }
 
     // Reserve space for registers used by the optimized code.
     SP = FP + num_registers - 1;
 
     DISPATCH();
   }
 
   {
     BYTECODE(EntryOptional, A_B_C);
     const uint16_t num_fixed_params = rA;
     const uint16_t num_opt_pos_params = rB;
     const uint16_t num_opt_named_params = rC;
     const intptr_t min_num_pos_args = num_fixed_params;
     const intptr_t max_num_pos_args = num_fixed_params + num_opt_pos_params;
 
     // Decode arguments descriptor.
-    const intptr_t arg_count = Smi::Value(*reinterpret_cast<RawSmi**>(
-        reinterpret_cast<uword>(argdesc->ptr()) +
-        Array::element_offset(ArgumentsDescriptor::kCountIndex)));
-    const intptr_t pos_count = Smi::Value(*reinterpret_cast<RawSmi**>(
-        reinterpret_cast<uword>(argdesc->ptr()) +
-        Array::element_offset(ArgumentsDescriptor::kPositionalCountIndex)));
+    const intptr_t arg_count = SimulatorHelpers::ArgDescArgCount(argdesc);
+    const intptr_t pos_count = SimulatorHelpers::ArgDescPosCount(argdesc);
     const intptr_t named_count = (arg_count - pos_count);
 
     // Check that got the right number of positional parameters.
     if ((min_num_pos_args > pos_count) || (pos_count > max_num_pos_args)) {
       goto ClosureNoSuchMethod;
     }
 
     // Copy all passed position arguments.
     RawObject** first_arg = FrameArguments(FP, arg_count);
     memmove(FP, first_arg, pos_count * kWordSize);
@@ skipping 62 matching lines @@
       ASSERT(num_opt_pos_params != 0);
       if (named_count != 0) {
         // Function can't have both named and optional positional parameters.
         // This kind of mismatch can only occur if the current function
         // is a closure.
         goto ClosureNoSuchMethod;
       }
 
       // Process the list of default values encoded as a sequence of
       // LoadConstant instructions after EntryOpt bytecode.
-      // Execute only those that correspond to parameters the were not passed.
+      // Execute only those that correspond to parameters that were not passed.
       for (intptr_t i = pos_count - num_fixed_params; i < num_opt_pos_params;
            i++) {
         const uint32_t load_value = pc[i];
         ASSERT(Bytecode::DecodeOpcode(load_value) == Bytecode::kLoadConstant);
 #if defined(DEBUG)
         const uint8_t reg = Bytecode::DecodeA(load_value);
         ASSERT((num_fixed_params + i) == reg);
 #endif
         FP[num_fixed_params + i] = LOAD_CONSTANT(Bytecode::DecodeD(load_value));
       }
@@ skipping 101 matching lines @@
     BYTECODE(CheckStackAlwaysExit, A);
     {
       Exit(thread, FP, SP + 1, pc);
       NativeArguments args(thread, 0, NULL, NULL);
       INVOKE_RUNTIME(DRT_StackOverflow, args);
     }
     DISPATCH();
   }
 
   {
+    BYTECODE(CheckFunctionTypeArgs, A_D);
+    const uint16_t declared_type_args_len = rA;
+    const uint16_t first_stack_local_index = rD;
+
+    // Decode arguments descriptor's type args len.
+    const intptr_t type_args_len =
+        SimulatorHelpers::ArgDescTypeArgsLen(argdesc);
+    if (type_args_len > 0) {
+      // Decode arguments descriptor's argument count (excluding type args).
+      const intptr_t arg_count = SimulatorHelpers::ArgDescArgCount(argdesc);
+      // Copy passed-in type args to first local slot.
+      FP[first_stack_local_index] = *FrameArguments(FP, arg_count + 1);
+    } else {
+      FP[first_stack_local_index] = Object::null();
+    }
+
+    // TODO(regis): Verify that type_args_len is correct.
+    USE(declared_type_args_len);
+
+    DISPATCH();
+  }
+
+  {
     BYTECODE(DebugStep, A);
     if (thread->isolate()->single_step()) {
       Exit(thread, FP, SP + 1, pc);
       NativeArguments args(thread, 0, NULL, NULL);
       INVOKE_RUNTIME(DRT_SingleStepHandler, args);
     }
     DISPATCH();
   }
 
   {
@@ skipping 2340 matching lines @@
     pc_ = pc;
   }
 
   buf->Longjmp();
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC