[v8-dev] ARM: safepoints frame optimization

src/frames.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 634 matching lines @@
   Object** parameters_limit = &Memory::Object_at(
       fp() + JavaScriptFrameConstants::kFunctionOffset - slot_space);
 
   // Visit the parameters that may be on top of the saved registers.
   if (safepoint_entry.argument_count() > 0) {
     v->VisitPointers(parameters_base,
                      parameters_base + safepoint_entry.argument_count());
     parameters_base += safepoint_entry.argument_count();
   }
 
+#if V8_TARGET_ARCH_ARM
+  // The frame must have been generated within LCodegen::GeneratedCode where
+  // registers_mask and double_registers_mask are set.
+  ASSERT(code->registers_mask() != kRegListEmpty);
+  // Skip saved double registers.
+  if (safepoint_entry.has_doubles()) {
+    parameters_base +=
+        CompilerIntrinsics::CountSetBits(code->double_registers_mask()) *
+        kDoubleSize / kPointerSize;
+  }
+
+  // Visit the registers that contain pointers if any.
+  if (safepoint_entry.HasRegisters()) {
+    RegList registers_mask = code->registers_mask();
+    for (int i = 0; i < kNumSafepointRegisters; i++) {
+      if ((registers_mask & (1 << i)) != 0) {
+        if (safepoint_entry.HasRegisterAt(i)) {
+          v->VisitPointer(parameters_base);
+        }
+        parameters_base++;
+      } else {
+        ASSERT(!safepoint_entry.HasRegisterAt(i));
+      }
+    }
+  }
+#else
   // Skip saved double registers.
   if (safepoint_entry.has_doubles()) {
     // Number of doubles not known at snapshot time.
     ASSERT(!Serializer::enabled());
     parameters_base += DoubleRegister::NumAllocatableRegisters() *
         kDoubleSize / kPointerSize;
   }
 
   // Visit the registers that contain pointers if any.
   if (safepoint_entry.HasRegisters()) {
     for (int i = kNumSafepointRegisters - 1; i >=0; i--) {
       if (safepoint_entry.HasRegisterAt(i)) {
         int reg_stack_index = MacroAssembler::SafepointRegisterStackIndex(i);
         v->VisitPointer(parameters_base + reg_stack_index);
       }
     }
     // Skip the words containing the register values.
     parameters_base += kNumSafepointRegisters;
   }
+#endif
 
   // We're done dealing with the register bits.
   uint8_t* safepoint_bits = safepoint_entry.bits();
   safepoint_bits += kNumSafepointRegisters >> kBitsPerByteLog2;
 
   // Visit the rest of the parameters.
   v->VisitPointers(parameters_base, parameters_limit);
 
   // Visit pointer spill slots and locals.
   for (unsigned index = 0; index < stack_slots; index++) {
@@ skipping 952 matching lines @@
   ZoneList<StackFrame*> list(10, zone);
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 } }  // namespace v8::internal