More compact snapshots.

src/vm/interpreter_arm.cc

 // Copyright (c) 2015, the Dartino 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.md file.
 
 #if defined(DARTINO_TARGET_ARM)
 
 #include "src/shared/bytecodes.h"
 #include "src/shared/names.h"
 #include "src/shared/selectors.h"
 
@@ skipping 68 matching lines @@
 #undef V
 }
 
 class InterpreterGeneratorARM : public InterpreterGenerator {
  public:
   explicit InterpreterGeneratorARM(Assembler* assembler)
       : InterpreterGenerator(assembler), spill_size_(-1) {}
 
   // Registers
   // ---------
-  //   r4: current process
-  //   r5: bytecode pointer
-  //   r6: stack pointer (top)
-  //   r8: null
-  //   r10: true
-  //   r11: false
+  //   R4: current process
+  //   R5: bytecode pointer
+  //   R6: stack pointer (top)
+  //   R8: null
+  //   R10: program
+  //   R11: dispatch table
 
   virtual void GeneratePrologue();
   virtual void GenerateEpilogue();
 
   virtual void GenerateMethodEntry();
 
   virtual void GenerateBytecodePrologue(const char* name);
   virtual void GenerateDebugAtBytecode();
 
   virtual void DoLoadLocal0();
@@ skipping 127 matching lines @@
  private:
   Label done_;
   Label done_state_saved_;
   Label check_stack_overflow_;
   Label check_stack_overflow_0_;
   Label gc_;
   Label intrinsic_failure_;
   Label interpreter_entry_;
   int spill_size_;
 
+  static const int kFalseOffset = 8;
+  static const int kTrueOffset = 16;
+
   void LoadLocal(Register reg, int index);
   void StoreLocal(Register reg, int index);
 
   void Push(Register reg);
   void Pop(Register reg);
   void Drop(int n);
   void Drop(Register reg);
   void DropNAndSetTop(int dropping_slots, Register reg);
 
   void LoadFramePointer(Register reg);
@@ skipping 31 matching lines @@
   void InvokeBitXor(const char* fallback);
   void InvokeBitShr(const char* fallback);
   void InvokeBitShl(const char* fallback);
 
   void InvokeMethodUnfold(bool test);
   void InvokeMethod(bool test);
 
   void InvokeNative(bool yield, bool safepoint);
   void InvokeStatic();
 
-  void ConditionalStore(Register reg_if_eq, Register reg_if_ne,
-                        const Address& address);
+  void AddIf(Condition cond, Register reg, int immediate);
+  void ToBoolean(Condition cond, Register reg);
+  void LoadFalse(Register reg);
+  void LoadTrue(Register reg);
 
   void CheckStackOverflow(int size);
 
   void Dispatch(int size);
 
   void SaveState(Label* resume);
   void RestoreState();
 
   static int ComputeStackPadding(int reserved, int extra) {
     const int kAlignment = 8;
@@ skipping 91 matching lines @@
   __ b(NE, &overflow);
   __ mov(R0, Immediate(Interpreter::kBreakpoint));
   __ b(&done_);
 
   __ Bind(&stay_fast);
   Dispatch(0);
 
   __ Bind(&overflow);
   Label throw_resume;
   SaveState(&throw_resume);
-  __ ldr(R7, Address(R4, Process::kProgramOffset));
-  __ ldr(R7, Address(R7, Program::kStackOverflowErrorOffset));
+  __ ldr(R7, Address(R10, Program::kStackOverflowErrorOffset));
   DoThrowAfterSaveState(&throw_resume);
 
   // Intrinsic failure: Just invoke the method.
   __ Bind(&intrinsic_failure_);
   __ b("InterpreterMethodEntry");
 }
 
 void InterpreterGeneratorARM::GenerateMethodEntry() {
   __ SwitchToText();
   __ AlignToPowerOfTwo(3);
@@ skipping 215 matching lines @@
 
   Dispatch(kStoreFieldWideLength);
 }
 
 void InterpreterGeneratorARM::DoLoadLiteralNull() {
   Push(R8);
   Dispatch(kLoadLiteralNullLength);
 }
 
 void InterpreterGeneratorARM::DoLoadLiteralTrue() {
-  Push(R10);
+  LoadTrue(R2);
+  Push(R2);
   Dispatch(kLoadLiteralTrueLength);
 }
 
 void InterpreterGeneratorARM::DoLoadLiteralFalse() {
-  Push(R11);
+  LoadFalse(R2);
+  Push(R2);
   Dispatch(kLoadLiteralFalseLength);
 }
 
 void InterpreterGeneratorARM::DoLoadLiteral0() {
   __ mov(R0, Immediate(reinterpret_cast<int32_t>(Smi::FromWord(0))));
   Push(R0);
   Dispatch(kLoadLiteral0Length);
 }
 
 void InterpreterGeneratorARM::DoLoadLiteral1() {
@@ skipping 19 matching lines @@
 }
 
 void InterpreterGeneratorARM::DoInvokeMethodUnfold() {
   InvokeMethodUnfold(false);
 }
 
 void InterpreterGeneratorARM::DoInvokeMethod() { InvokeMethod(false); }
 
 void InterpreterGeneratorARM::DoInvokeNoSuchMethod() {
   // Use the noSuchMethod entry from entry zero of the virtual table.
-  __ ldr(R1, Address(R4, Process::kProgramOffset));
-  __ ldr(R1, Address(R1, Program::kDispatchTableOffset));
+  __ ldr(R1, Address(R10, Program::kDispatchTableOffset));
   __ ldr(R1, Address(R1, Array::kSize - HeapObject::kTag));
 
   // Load the function.
   __ ldr(R0,
          Address(R1, DispatchTableEntry::kTargetOffset - HeapObject::kTag));
 
   SaveByteCodePointer(R2);
   __ bl("InterpreterMethodEntry");
   RestoreByteCodePointer(R2);
 
   __ ldr(R7, Address(R5, 1));
   // Compute the arity from the selector.
   ASSERT(Selector::ArityField::shift() == 0);
   __ and_(R2, R7, Immediate(Selector::ArityField::mask()));
 
   Drop(R2);
 
   StoreLocal(R0, 0);
   Dispatch(kInvokeNoSuchMethodLength);
 }
 
 void InterpreterGeneratorARM::DoInvokeTestNoSuchMethod() {
-  StoreLocal(R11, 0);
+  LoadFalse(R2);
+  StoreLocal(R2, 0);
   Dispatch(kInvokeTestNoSuchMethodLength);
 }
 
 void InterpreterGeneratorARM::DoInvokeTestUnfold() { InvokeMethodUnfold(true); }
 
 void InterpreterGeneratorARM::DoInvokeTest() { InvokeMethod(true); }
 
 void InterpreterGeneratorARM::DoInvokeStatic() { InvokeStatic(); }
 
 void InterpreterGeneratorARM::DoInvokeFactory() { InvokeStatic(); }
@@ skipping 239 matching lines @@
 
 void InterpreterGeneratorARM::DoBranchWide() {
   __ ldr(R0, Address(R5, 1));
   __ adds(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoBranchIfTrueWide() {
   Label branch;
   Pop(R7);
-  __ cmp(R7, R10);
+  LoadTrue(R2);
+  __ cmp(R7, R2);
   __ b(EQ, &branch);
   Dispatch(kBranchIfTrueWideLength);
 
   __ Bind(&branch);
   __ ldr(R0, Address(R5, 1));
   __ adds(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoBranchIfFalseWide() {
   Label branch;
   Pop(R7);
-  __ cmp(R7, R10);
+  LoadTrue(R2);
+  __ cmp(R7, R2);
   __ b(NE, &branch);
   Dispatch(kBranchIfFalseWideLength);
 
   __ Bind(&branch);
   __ ldr(R0, Address(R5, 1));
   __ adds(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoBranchBack() {
   CheckStackOverflow(0);
   __ ldrb(R0, Address(R5, 1));
   __ subs(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoBranchBackIfTrue() {
   CheckStackOverflow(0);
 
   Label branch;
   Pop(R1);
-  __ cmp(R1, R10);
+  LoadTrue(R2);
+  __ cmp(R1, R2);
   __ b(EQ, &branch);
   Dispatch(kBranchBackIfTrueLength);
 
   __ Bind(&branch);
   __ ldrb(R0, Address(R5, 1));
   __ subs(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoBranchBackIfFalse() {
   CheckStackOverflow(0);
 
   Label branch;
   Pop(R1);
-  __ cmp(R1, R10);
+  LoadTrue(R2);
+  __ cmp(R1, R2);
   __ b(NE, &branch);
   Dispatch(kBranchBackIfFalseLength);
 
   __ Bind(&branch);
   __ ldrb(R0, Address(R5, 1));
   __ subs(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoBranchBackWide() {
   CheckStackOverflow(0);
   __ ldr(R0, Address(R5, 1));
   __ subs(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoBranchBackIfTrueWide() {
   CheckStackOverflow(0);
 
   Label branch;
   Pop(R1);
-  __ cmp(R10, R1);
+  LoadTrue(R2);
+  __ cmp(R2, R1);
   __ b(EQ, &branch);
   Dispatch(kBranchBackIfTrueWideLength);
 
   __ Bind(&branch);
   __ ldr(R0, Address(R5, 1));
   __ subs(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoBranchBackIfFalseWide() {
   CheckStackOverflow(0);
 
   Label branch;
   Pop(R1);
-  __ cmp(R10, R1);
+  LoadTrue(R2);
+  __ cmp(R2, R1);
   __ b(NE, &branch);
   Dispatch(kBranchBackIfTrueWideLength);
 
   __ Bind(&branch);
   __ ldr(R0, Address(R5, 1));
   __ subs(R5, R5, R0);
   Dispatch(0);
 }
 
 void InterpreterGeneratorARM::DoPopAndBranchWide() {
@@ skipping 26 matching lines @@
   __ bl("HandleAllocateBoxed");
   __ and_(R1, R0, Immediate(Failure::kTagMask | Failure::kTypeMask));
   __ cmp(R1, Immediate(Failure::kTag));
   __ b(EQ, &gc_);
   StoreLocal(R0, 0);
   Dispatch(kAllocateBoxedLength);
 }
 
 void InterpreterGeneratorARM::DoNegate() {
   LoadLocal(R1, 0);
-  __ cmp(R1, R10);
-  ConditionalStore(R11, R10, Address(R6, 0));
+  LoadTrue(R2);
+  __ cmp(R1, R2);
+  AddIf(EQ, R2, kFalseOffset - kTrueOffset);
+  StoreLocal(R2, 0);
   Dispatch(kNegateLength);
 }
 
 void InterpreterGeneratorARM::DoStackOverflowCheck() {
   __ ldr(R0, Address(R5, 1));
   __ ldr(R1, Address(R4, Process::kStackLimitOffset));
   __ sub(R3, R6, Operand(R0, TIMES_WORD_SIZE));
   __ cmp(R3, R1);
   __ b(LS, &check_stack_overflow_);
   Dispatch(kStackOverflowCheckLength);
@@ skipping 128 matching lines @@
   int type_field_shift = InstanceFormat::TypeField::shift();
 
   __ and_(R2, R2, Immediate(InstanceFormat::TypeField::mask()));
   __ cmp(R2, Immediate(double_type << type_field_shift));
   __ b(EQ, &bail_out);
   __ cmp(R2, Immediate(large_integer_type << type_field_shift));
   __ b(EQ, &bail_out);
 
   __ Bind(&fast_case);
   __ cmp(R1, R0);
-  ConditionalStore(R10, R11, Address(R6, kWordSize));
+  ToBoolean(EQ, R2);
+  StoreLocal(R2, 1);
   Drop(1);
   Dispatch(kIdenticalLength);
 
   __ Bind(&bail_out);
   __ mov(R2, R0);
   __ mov(R0, R4);
   __ bl("HandleIdentical");
   DropNAndSetTop(1, R0);
   Dispatch(kIdenticalLength);
 }
 
 void InterpreterGeneratorARM::DoIdenticalNonNumeric() {
   LoadLocal(R0, 0);
   LoadLocal(R1, 1);
   __ cmp(R0, R1);
-  ConditionalStore(R10, R11, Address(R6, kWordSize));
+  ToBoolean(EQ, R2);
+  StoreLocal(R2, 1);
   Drop(1);
   Dispatch(kIdenticalNonNumericLength);
 }
 
 void InterpreterGeneratorARM::DoEnterNoSuchMethod() {
   SaveState(&interpreter_entry_);
   __ mov(R0, R4);
   __ bl("HandleEnterNoSuchMethod");
   RestoreState();
 }
@@ skipping 21 matching lines @@
   Pop(LR);
   __ mov(PC, LR);
 }
 
 void InterpreterGeneratorARM::DoMethodEnd() { __ bkpt(); }
 
 void InterpreterGeneratorARM::DoIntrinsicObjectEquals() {
   LoadLocal(R0, 0);
   LoadLocal(R1, 1);
   __ cmp(R0, R1);
-  ConditionalStore(R10, R11, Address(R6, -kWordSize));
+  ToBoolean(EQ, R2);
+  StoreLocal(R2, -1);
   Drop(1);
   Dispatch(kInvokeMethodLength);
 }
 
 void InterpreterGeneratorARM::DoIntrinsicGetField() {
   __ ldrb(R1, Address(R0, 2 + Function::kSize - HeapObject::kTag));
   LoadLocal(R0, 0);
   __ adds(R0, R0, Immediate(Instance::kSize - HeapObject::kTag));
   __ ldr(R0, Address(R0, Operand(R1, TIMES_WORD_SIZE)));
 
@@ skipping 245 matching lines @@
     __ b(NE, &hit);
     __ ldr(R0, "InterpreterMethodEntry");
     __ Bind(&hit);
   }
 
   if (test) {
     // Materialize either true or false depending on whether or not
     // we've found a target method.
     Label found;
     __ tst(R0, R0);
-    ConditionalStore(R11, R10, Address(R6, 0));
+    ToBoolean(EQ, R2);
+    StoreLocal(R2, 0);
     Dispatch(kInvokeTestUnfoldLength);
   } else {
     SaveByteCodePointer(R2);
     __ bl("InterpreterMethodEntry");
     RestoreByteCodePointer(R2);
 
     __ ldr(R7, Address(R5, 1));
     // Compute the arity from the selector.
     ASSERT(Selector::ArityField::shift() == 0);
     __ and_(R2, R7, Immediate(Selector::ArityField::mask()));
 
     Drop(R2);
 
     StoreLocal(R0, 0);
     Dispatch(kInvokeMethodUnfoldLength);
   }
 
   __ Bind(&smi);
-  __ ldr(R3, Address(R4, Process::kProgramOffset));
-  __ ldr(R2, Address(R3, Program::kSmiClassOffset));
+  __ ldr(R2, Address(R10, Program::kSmiClassOffset));
   __ b(&probe);
 
   // We didn't find a valid entry in primary lookup cache.
   __ Bind(&miss);
   // Arguments:
   // - r0: process
   // - r1: primary cache entry
   // - r2: class (already in r2)
   // - r3: selector
   __ mov(R1, R0);
   __ mov(R0, R4);
   __ mov(R3, R7);
   __ bl("HandleLookupEntry");
   __ b(&finish);
 }
 
 void InterpreterGeneratorARM::InvokeMethod(bool test) {
   // Get the selector from the bytecodes.
   __ ldr(R7, Address(R5, 1));
 
   // Fetch the virtual table from the program.
-  __ ldr(R1, Address(R4, Process::kProgramOffset));
-  __ ldr(R1, Address(R1, Program::kDispatchTableOffset));
+  __ ldr(R1, Address(R10, Program::kDispatchTableOffset));
 
   if (!test) {
     // Compute the arity from the selector.
     ASSERT(Selector::ArityField::shift() == 0);
     __ and_(R2, R7, Immediate(Selector::ArityField::mask()));
   }
 
   // Compute the selector offset (smi tagged) from the selector.
   __ LoadInt(R9, Selector::IdField::mask());
   __ and_(R7, R7, R9);
@@ skipping 29 matching lines @@
   // we used to find it.
   Label invalid;
   __ ldr(R3, Address(R1, DispatchTableEntry::kOffsetOffset - HeapObject::kTag));
   __ cmp(R7, R3);
   __ b(NE, &invalid);
 
   // Load the target and the intrinsic from the entry.
   Label validated, intrinsified;
   if (test) {
     // Valid entry: The answer is true.
-    StoreLocal(R10, 0);
+    LoadTrue(R2);
+    StoreLocal(R2, 0);
     Dispatch(kInvokeTestLength);
   } else {
     __ Bind(&validated);
 
     __ ldr(R0,
            Address(R1, DispatchTableEntry::kTargetOffset - HeapObject::kTag));
 
     SaveByteCodePointer(R2);
     __ ldr(R1,
            Address(R1, DispatchTableEntry::kCodeOffset - HeapObject::kTag));
     __ blx(R1);
     RestoreByteCodePointer(R2);
 
     __ ldr(R7, Address(R5, 1));
     // Compute the arity from the selector.
     ASSERT(Selector::ArityField::shift() == 0);
     __ and_(R2, R7, Immediate(Selector::ArityField::mask()));
 
     Drop(R2);
 
     StoreLocal(R0, 0);
     Dispatch(kInvokeMethodLength);
   }
 
   __ Bind(&smi);
-  __ ldr(R2, Address(R4, Process::kProgramOffset));
-  __ ldr(R2, Address(R2, Program::kSmiClassOffset));
+  __ ldr(R2, Address(R10, Program::kSmiClassOffset));
   __ b(&dispatch);
 
   if (test) {
     // Invalid entry: The answer is false.
     __ Bind(&invalid);
-    StoreLocal(R11, 0);
+    LoadFalse(R2);
+    StoreLocal(R2, 0);
     Dispatch(kInvokeTestLength);
   } else {
     __ Bind(&intrinsified);
     __ mov(PC, R2);
 
     // Invalid entry: Use the noSuchMethod entry from entry zero of
     // the virtual table.
     __ Bind(&invalid);
-    __ ldr(R1, Address(R4, Process::kProgramOffset));
-    __ ldr(R1, Address(R1, Program::kDispatchTableOffset));
+    __ ldr(R1, Address(R10, Program::kDispatchTableOffset));
     __ ldr(R1, Address(R1, Array::kSize - HeapObject::kTag));
     __ b(&validated);
   }
 }
 
 void InterpreterGeneratorARM::InvokeNative(bool yield, bool safepoint) {
   __ ldrb(R1, Address(R5, 1));
   // Also skip two empty slots.
   __ adds(R1, R1, Immediate(2));
   __ ldrb(R0, Address(R5, 2));
@@ skipping 232 matching lines @@
                                             Condition cond) {
   LoadLocal(R0, 0);
   __ tst(R0, Immediate(Smi::kTagMask));
   __ b(NE, fallback);
   LoadLocal(R1, 1);
   __ tst(R1, Immediate(Smi::kTagMask));
   __ b(NE, fallback);
 
   Label true_case;
   __ cmp(R1, R0);
-  __ b(cond, &true_case);
-
-  DropNAndSetTop(1, R11);
-  Dispatch(5);
-
-  __ Bind(&true_case);
-  DropNAndSetTop(1, R10);
+  ToBoolean(cond, R2);
+  DropNAndSetTop(1, R2);
   Dispatch(5);
 }
 
-void InterpreterGeneratorARM::ConditionalStore(Register reg_if_eq,
-                                               Register reg_if_ne,
-                                               const Address& address) {
-  Label if_ne, done;
-  __ b(NE, &if_ne);
-  __ str(reg_if_eq, address);
-  __ b(&done);
-  __ Bind(&if_ne);
-  __ str(reg_if_ne, address);
-  __ Bind(&done);
+void InterpreterGeneratorARM::AddIf(Condition cond, Register reg,
+                                    int add_if_eq) {
+  __ it(cond);
+  __ add(cond, reg, reg, Immediate(add_if_eq));
+}
+
+void InterpreterGeneratorARM::LoadTrue(Register reg) {
+  __ add(reg, R8, Immediate(kTrueOffset));
+}
+
+void InterpreterGeneratorARM::LoadFalse(Register reg) {
+  __ add(reg, R8, Immediate(kFalseOffset));
+}
+
+void InterpreterGeneratorARM::ToBoolean(Condition cond, Register reg) {
+  LoadFalse(reg);
+  AddIf(cond, reg, kTrueOffset - kFalseOffset);
 }
 
 void InterpreterGeneratorARM::CheckStackOverflow(int size) {
   __ ldr(R1, Address(R4, Process::kStackLimitOffset));
   __ cmp(R6, R1);
   if (size == 0) {
     __ b(LS, &check_stack_overflow_0_);
   } else {
     Label done;
     __ b(HI, &done);
     __ mov(R0, Immediate(size));
     __ b(&check_stack_overflow_);
     __ Bind(&done);
   }
 }
 
 void InterpreterGeneratorARM::Dispatch(int size) {
 // Load the next bytecode through R5 and dispatch to it.
 #ifdef DARTINO_THUMB_ONLY
   __ ldrb(R7, Address(R5, size));
   if (size > 0) {
     __ adds(R5, R5, Immediate(size));
   }
 #else
   __ ldrb(R7, Address(R5, size), WRITE_BACK);
 #endif
-  __ ldr(R9, "Interpret_DispatchTable");
-  __ ldr(PC, Address(R9, Operand(R7, TIMES_WORD_SIZE)));
+  __ ldr(PC, Address(R11, Operand(R7, TIMES_WORD_SIZE)));
   __ GenerateConstantPool();
 }
 
 void InterpreterGeneratorARM::SaveState(Label* resume) {
   // Save the bytecode pointer at the return-address slot.
   LoadFramePointer(R3);
   __ str(R5, Address(R3, -kWordSize));
 
   // Push resume address.
   __ ldr(R5, resume);
@@ skipping 14 matching lines @@
 void InterpreterGeneratorARM::RestoreState() {
   // Load the current stack pointer into R6.
   __ ldr(R6, Address(R4, Process::kCoroutineOffset));
   __ ldr(R6, Address(R6, Coroutine::kStackOffset - HeapObject::kTag));
   __ ldr(R5, Address(R6, Stack::kTopOffset - HeapObject::kTag));
   __ adds(R6, R6, Immediate(Stack::kSize - HeapObject::kTag));
   __ add(R6, R6, Operand(R5, TIMES_2));
 
   // Load constants into registers.
   __ ldr(R10, Address(R4, Process::kProgramOffset));
-  __ ldr(R11, Address(R10, Program::kFalseObjectOffset));
   __ ldr(R8, Address(R10, Program::kNullObjectOffset));
-  __ ldr(R10, Address(R10, Program::kTrueObjectOffset));
+  __ ldr(R11, "Interpret_DispatchTable");
 
   // Pop and store frame pointer.
   Pop(R5);
   StoreFramePointer(R5);
 
   // Set the bytecode pointer from the stack.
   __ ldr(R5, Address(R5, -kWordSize));
 
   // Pop and branch to resume address.
   Pop(LR);
   __ mov(PC, LR);
 }
 
 }  // namespace dartino
 
 #endif  // defined(DARTINO_TARGET_ARM)