Implements context allocation stub for MIPS.

runtime/vm/stub_code_mips.cc

 // Copyright (c) 2013, 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 "vm/globals.h"
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 252 matching lines @@
 // NOTE: A1 cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in V0.
 void StubCode::GenerateAllocateArrayStub(Assembler* assembler) {
   __ TraceSimMsg("AllocateArrayStub");
   Label slow_case;
   if (FLAG_inline_alloc) {
     // Compute the size to be allocated, it is based on the array length
     // and is computed as:
     // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
     // Assert that length is a Smi.
+    __ andi(CMPRES, A1, Immediate(kSmiTagMask));
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
-      __ andi(CMPRES, A1, Immediate(kSmiTagMask));
       __ bne(CMPRES, ZR, &slow_case);
     }
     __ lw(T0, FieldAddress(CTX, Context::isolate_offset()));
     __ lw(T0, Address(T0, Isolate::heap_offset()));
     __ lw(T0, Address(T0, Heap::new_space_offset()));
 
     // Calculate and align allocation size.
     // Load new object start and calculate next object start.
     // A0: array element type.
     // A1: Array length as Smi.
@@ skipping 240 matching lines @@
   // Stack:
   // TOS + 0: Argument array.
   // TOS + 1: Arguments descriptor array.
   // TOS + 2: Place for result from the call.
   // TOS + 3: Saved FP of previous frame.
   // TOS + 4: Dart code return address
   // TOS + 5: PC marker (0 for stub).
   // TOS + 6: Last argument of caller.
   // ....
   __ CallRuntime(kInvokeNonClosureRuntimeEntry);
-  // Remove arguments.
-  __ Drop(2);
-  __ Pop(V0);  // Get result into R0.
+  __ lw(V0, Address(SP, 2 * kWordSize));  // Get result into V0.
+  __ addiu(SP, SP, Immediate(3 * kWordSize));  // Remove arguments.
 
   // Remove the stub frame as we are about to return.
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   RA : points to return address.
@@ skipping 105 matching lines @@
   }
   __ lw(A3, Address(SP));
   __ addiu(SP, SP, Immediate((3 + kAbiPreservedCpuRegCount) * kWordSize));
 
   // Restore the frame pointer and return.
   __ LeaveStubFrame();
   __ Ret();
 }
 
 
+// Called for inline allocation of contexts.
+// Input:
+//   T1: number of context variables.
+// Output:
+//   V0: new allocated RawContext object.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
-  __ Unimplemented("AllocateContext stub");
+  if (FLAG_inline_alloc) {
+    const Class& context_class = Class::ZoneHandle(Object::context_class());
+    Label slow_case;
+    Heap* heap = Isolate::Current()->heap();
+    // First compute the rounded instance size.
+    // T1: number of context variables.
+    intptr_t fixed_size = sizeof(RawContext) + kObjectAlignment - 1;
+    __ LoadImmediate(T2, fixed_size);
+    __ sll(T0, T1, 2);
+    __ addu(T2, T2, T0);
+    ASSERT(kSmiTagShift == 1);
+    __ LoadImmediate(T0, ~((kObjectAlignment) - 1));
+    __ and_(T2, T2, T0);
+
+    // Now allocate the object.
+    // T1: number of context variables.
+    // T2: object size.
+    __ LoadImmediate(T5, heap->TopAddress());
+    __ lw(V0, Address(T5, 0));
+    __ addu(T3, T2, V0);
+
+    // Check if the allocation fits into the remaining space.
+    // V0: potential new object.
+    // T1: number of context variables.
+    // T2: object size.
+    // T3: potential next object start.
+    __ LoadImmediate(TMP1, heap->EndAddress());
+    __ lw(TMP1, Address(TMP1, 0));
+    if (FLAG_use_slow_path) {
+      __ b(&slow_case);
+    } else {
+      __ BranchGreaterEqual(T3, TMP1, &slow_case);
+    }
+
+    // Successfully allocated the object, now update top to point to
+    // next object start and initialize the object.
+    // V0: new object.
+    // T1: number of context variables.
+    // T2: object size.
+    // T3: next object start.
+    __ sw(T3, Address(T5, 0));
+    __ addiu(V0, V0, Immediate(kHeapObjectTag));
+
+    // Calculate the size tag.
+    // V0: new object.
+    // T1: number of context variables.
+    // T2: object size.
+    const intptr_t shift = RawObject::kSizeTagBit - kObjectAlignmentLog2;
+    __ LoadImmediate(TMP1, RawObject::SizeTag::kMaxSizeTag);
+    __ sltu(CMPRES, TMP1, T2);  // CMPRES = T2 > TMP1 ? 1 : 0.
+    __ movn(T2, ZR, CMPRES);  // T2 = CMPRES != 0 ? 0 : T2.
+    __ sll(TMP1, T2, shift);  // TMP2 = T2 << shift.
+    __ movz(T2, TMP1, CMPRES);  // T2 = CMPRES == 0 ? TMP1 : T2.
+
+    // Get the class index and insert it into the tags.
+    // T2: size and bit tags.
+    __ LoadImmediate(TMP1, RawObject::ClassIdTag::encode(context_class.id()));
+    __ or_(T2, T2, TMP1);
+    __ sw(T2, FieldAddress(V0, Context::tags_offset()));
+
+    // Setup up number of context variables field.
+    // V0: new object.
+    // T1: number of context variables as integer value (not object).
+    __ sw(T1, FieldAddress(V0, Context::num_variables_offset()));
+
+    // Setup isolate field.
+    // Load Isolate pointer from Context structure into R2.
+    // V0: new object.
+    // T1: number of context variables.
+    __ lw(T2, FieldAddress(CTX, Context::isolate_offset()));
+    // T2: isolate, not an object.
+    __ sw(T2, FieldAddress(V0, Context::isolate_offset()));
+
+    // Setup the parent field.
+    // V0: new object.
+    // T1: number of context variables.
+    __ LoadImmediate(T2, reinterpret_cast<intptr_t>(Object::null()));
+    __ sw(T2, FieldAddress(V0, Context::parent_offset()));
+
+    // Initialize the context variables.
+    // V0: new object.
+    // T1: number of context variables.
+    // T2: raw null.
+    Label loop, loop_test;
+    __ AddImmediate(T3, V0, Context::variable_offset(0) - kHeapObjectTag);
+    __ b(&loop_test);
+    __ delay_slot()->sll(T1, T1, 2);
+    __ Bind(&loop);
+    __ addu(TMP1, T3, T1);
+    __ sw(T2, Address(TMP1));
+    __ Bind(&loop_test);
+    __ addiu(T1, T1, Immediate(-kWordSize));
+    __ bne(T1, ZR, &loop);  // Loop if R1 not zero.
+
+    // Done allocating and initializing the context.
+    // V0: new object.
+    __ Ret();
+
+    __ Bind(&slow_case);
+  }
+  // Create a stub frame as we are pushing some objects on the stack before
+  // calling into the runtime.
+  __ EnterStubFrame();
+  // Setup space on stack for return value.
+  __ LoadImmediate(T2, reinterpret_cast<intptr_t>(Object::null()));
+  __ SmiTag(T1);
+  __ addiu(SP, SP, Immediate(-2 * kWordSize));
+  __ sw(T2, Address(SP, 1 * kWordSize));
+  __ sw(T1, Address(SP, 0 * kWordSize));
+  __ CallRuntime(kAllocateContextRuntimeEntry);  // Allocate context.
+  __ lw(V0, Address(SP, 1 * kWordSize));  // Get the new context.
+  __ addiu(SP, SP, Immediate(2 * kWordSize));  // Pop argument and return.
+
+  // V0: new object
+  // Restore the frame pointer.
+  __ LeaveStubFrame();
+  __ Ret();
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, StoreBufferBlockProcess, Isolate* isolate);
 
 
 // Helper stub to implement Assembler::StoreIntoObject.
 // Input parameters:
 //   T0: Address (i.e. object) being stored into.
 void StubCode::GenerateUpdateStoreBufferStub(Assembler* assembler) {
@@ skipping 83 matching lines @@
                      &no_instantiator);
       __ delay_slot()->mov(T4, T3);
       __ AddImmediate(T3, type_args_size);
       __ Bind(&no_instantiator);
       // T4: potential new object end and, if T4 != T3, potential new
       // InstantiatedTypeArguments object start.
     }
     // Check if the allocation fits into the remaining space.
     // T2: potential new object start.
     // T3: potential next object start.
+    __ LoadImmediate(TMP1, heap->EndAddress());
+    __ lw(TMP1, Address(TMP1));
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
-      __ LoadImmediate(TMP1, heap->EndAddress());
-      __ lw(TMP1, Address(TMP1));
       __ BranchGreaterEqual(T3, TMP1, &slow_case);
     }
 
     // Successfully allocated the object(s), now update top to point to
     // next object start and initialize the object.
     __ sw(T3, Address(T5));
 
     if (is_cls_parameterized) {
       // Initialize the type arguments field in the object.
       // T2: new object start.
@@ skipping 82 matching lines @@
     __ Bind(&slow_case);
   }
   if (is_cls_parameterized) {
     __ lw(T1, Address(SP, 1 * kWordSize));
     __ lw(T0, Address(SP, 0 * kWordSize));
   }
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame(true);  // Uses pool pointer to pass cls to runtime.
   __ LoadImmediate(T2, reinterpret_cast<intptr_t>(Object::null()));
-  __ Push(T2);  // Setup space on stack for return value.
-  __ PushObject(cls);  // Push class of object to be allocated.
+  __ LoadObject(TMP1, cls);
+
+  __ addiu(SP, SP, Immediate(-4 * kWordSize));
+  __ sw(T2, Address(SP, 3 * kWordSize));  // Space on stack for return value.
+  __ sw(TMP1, Address(SP, 2 * kWordSize));  // Class of object to be allocated.
+
   if (is_cls_parameterized) {
     // Push type arguments of object to be allocated and of instantiator.
-    __ addiu(SP, SP, Immediate(-2 * kWordSize));
     __ sw(T1, Address(SP, 1 * kWordSize));
     __ sw(T0, Address(SP, 0 * kWordSize));
   } else {
     // Push null type arguments and kNoInstantiator.
     __ LoadImmediate(T1, Smi::RawValue(StubCode::kNoInstantiator));
-    __ addiu(SP, SP, Immediate(-2 * kWordSize));
     __ sw(T2, Address(SP, 1 * kWordSize));
     __ sw(T1, Address(SP, 0 * kWordSize));
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry);  // Allocate object.
   __ TraceSimMsg("AllocationStubForClass return");
-  __ Drop(3);  // Pop arguments.
-  __ Pop(V0);  // Pop result (newly allocated object).
+  // Pop result (newly allocated object).
+  __ lw(V0, Address(SP, 3 * kWordSize));
+  __ addiu(SP, SP, Immediate(4 * kWordSize));  // Pop arguments.
   // V0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame(true);
   __ Ret();
 }
 
 
 // Called for inline allocation of closures.
 // Input parameters:
 //   RA: return address.
@@ skipping 23 matching lines @@
     __ lw(T2, Address(T5));
     __ AddImmediate(T3, T2, closure_size);
     if (is_implicit_instance_closure) {
       __ mov(T4, T3);  // T4: new context address.
       __ AddImmediate(T3, context_size);
     }
     // Check if the allocation fits into the remaining space.
     // T2: potential new closure object.
     // T3: address of top of heap.
     // T4: potential new context object (only if is_implicit_closure).
+    __ LoadImmediate(TMP1, heap->EndAddress());
+    __ lw(TMP1, Address(TMP1));
     if (FLAG_use_slow_path) {
       __ b(&slow_case);
     } else {
-      __ LoadImmediate(TMP1, heap->EndAddress());
-      __ lw(TMP1, Address(TMP1));
       __ BranchGreaterEqual(T3, TMP1, &slow_case);
     }
 
     // Successfully allocated the object, now update top to point to
     // next object start and initialize the object.
     __ sw(T3, Address(T5));
 
     // T2: new closure object.
     // T4: new context object (only if is_implicit_closure).
     // Set the tags.
@@ skipping 56 matching lines @@
 
     // Done allocating and initializing the instance.
     // V0: new object.
     __ addiu(V0, T2, Immediate(kHeapObjectTag));
     __ LeaveStubFrame(true);
     __ Ret();
 
     __ Bind(&slow_case);
   }
 
+  // If it's an implicit static closure we need 2 stack slots. Otherwise,
+  // If it's an implicit instance closure we need 4 stack slots, o/w only 3.
+  int num_slots = 2;
+  if (!is_implicit_static_closure) {
+    num_slots = is_implicit_instance_closure ? 4 : 3;
+  }
+  __ addiu(SP, SP, Immediate(-num_slots * kWordSize));
   __ LoadImmediate(V0, reinterpret_cast<intptr_t>(Object::null()));
-  __ Push(V0);  // Setup space on stack for return value.
-  __ PushObject(func);
+  __ LoadObject(TMP1, func);
+  // Setup space on stack for return value.
+  __ sw(V0, Address(SP, (num_slots - 1) * kWordSize));
+  __ sw(TMP1, Address(SP, (num_slots - 2) * kWordSize));
   if (is_implicit_static_closure) {
     __ CallRuntime(kAllocateImplicitStaticClosureRuntimeEntry);
     __ TraceSimMsg("AllocationStubForClosure return");
   } else {
     if (is_implicit_instance_closure) {
       __ lw(T1, Address(FP, kReceiverFPOffset));
-      __ Push(T1);  // Receiver.
+      __ sw(T1, Address(SP, (num_slots - 3) * kWordSize));  // Receiver.
+      __ sw(V0, Address(SP, (num_slots - 4) * kWordSize));  // Push null.
     }
     if (has_type_arguments) {
       __ lw(V0, Address(FP, kTypeArgumentsFPOffset));
+      // Push type arguments of closure.
+      __ sw(V0, Address(SP, (num_slots - 3) * kWordSize));
     }
-    __ Push(V0);  // Push type arguments of closure to be allocated or null.
 
     if (is_implicit_instance_closure) {
       __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry);
       __ TraceSimMsg("AllocationStubForClosure return");
-      __ Drop(2);
     } else {
       ASSERT(func.IsNonImplicitClosureFunction());
       __ CallRuntime(kAllocateClosureRuntimeEntry);
       __ TraceSimMsg("AllocationStubForClosure return");
-      __ Drop(1);  // Pop argument (type arguments of object).
     }
   }
-  __ Drop(1);  // Pop function object.
-  __ Pop(V0);
+  __ lw(V0, Address(SP, (num_slots - 1) * kWordSize));  // Pop function object.
+  __ addiu(SP, SP, Immediate(num_slots * kWordSize));
+
   // V0: new object
   // Restore the frame pointer.
   __ LeaveStubFrame(true);
   __ Ret();
 }
 
 
 void StubCode::GenerateCallNoSuchMethodFunctionStub(Assembler* assembler) {
   __ Unimplemented("CallNoSuchMethodFunction stub");
 }
@@ skipping 129 matching lines @@
   // T1: argument_count - 1 (smi).
   __ sll(T1, T1, 1);  // T1 is Smi.
   __ addu(T1, SP, T1);
   // T1: address of receiver.
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   __ LoadImmediate(T3, reinterpret_cast<intptr_t>(Object::null()));
   // Preserve IC data object and arguments descriptor array and
   // setup space on stack for result (target code object).
-  __ addiu(SP, SP, Immediate(-3 * kWordSize));
-  __ sw(S5, Address(SP, 2 * kWordSize));
-  __ sw(S4, Address(SP, 1 * kWordSize));
-  __ sw(T3, Address(SP, 0 * kWordSize));
+  int num_slots = num_args + 5;
+  __ addiu(SP, SP, Immediate(-num_slots * kWordSize));
+  __ sw(S5, Address(SP, (num_slots - 1) * kWordSize));
+  __ sw(S4, Address(SP, (num_slots - 2) * kWordSize));
+  __ sw(T3, Address(SP, (num_slots - 3) * kWordSize));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
-    __ lw(TMP, Address(T1, -i * kWordSize));
-    __ Push(TMP);
+    __ lw(TMP1, Address(T1, -i * kWordSize));
+    __ sw(TMP1, Address(SP, (num_slots - i - 4) * kWordSize));
   }
   // Pass IC data object and arguments descriptor array.
-  __ addiu(SP, SP, Immediate(-2 * kWordSize));
-  __ sw(S5, Address(SP, 1 * kWordSize));
-  __ sw(S4, Address(SP, 0 * kWordSize));
+  __ sw(S5, Address(SP, (num_slots - num_args - 4) * kWordSize));
+  __ sw(S4, Address(SP, (num_slots - num_args - 5) * kWordSize));
 
   if (num_args == 1) {
     __ CallRuntime(kInlineCacheMissHandlerOneArgRuntimeEntry);
   } else if (num_args == 2) {
     __ CallRuntime(kInlineCacheMissHandlerTwoArgsRuntimeEntry);
   } else if (num_args == 3) {
     __ CallRuntime(kInlineCacheMissHandlerThreeArgsRuntimeEntry);
   } else {
     UNIMPLEMENTED();
   }
   __ TraceSimMsg("NArgsCheckInlineCacheStub return");
+  // Pop returned code object into T3 (null if not found).
+  // Restore arguments descriptor array and IC data array.
+  __ lw(T3, Address(SP, (num_slots - 3) * kWordSize));
+  __ lw(S4, Address(SP, (num_slots - 2) * kWordSize));
+  __ lw(S5, Address(SP, (num_slots - 1) * kWordSize));
   // Remove the call arguments pushed earlier, including the IC data object
   // and the arguments descriptor array.
-  __ Drop(num_args + 2);
-  // Pop returned code object into T3 (null if not found).
-  // Restore arguments descriptor array and IC data array.
-  __ lw(T3, Address(SP, 0 * kWordSize));
-  __ lw(S4, Address(SP, 1 * kWordSize));
-  __ lw(S5, Address(SP, 2 * kWordSize));
-  __ addiu(SP, SP, Immediate(3 * kWordSize));
+  __ addiu(SP, SP, Immediate(num_slots * kWordSize));
   __ LeaveStubFrame();
   Label call_target_function;
   __ BranchNotEqual(T3, reinterpret_cast<intptr_t>(Object::null()),
                     &call_target_function);
   // NoSuchMethod or closure.
   // Mark IC call that it may be a closure call that does not collect
   // type feedback.
   __ LoadImmediate(TMP2, 1);
   __ Branch(&StubCode::InstanceFunctionLookupLabel());
   __ delay_slot()->sb(TMP2, FieldAddress(S5, ICData::is_closure_call_offset()));
@@ skipping 357 matching lines @@
   __ Bind(&done);
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(T1, Address(SP, 1 * kWordSize));
   __ Ret();
   __ delay_slot()->addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS