Setup R10/EDX to be valid Oops before stub calls

runtime/vm/flow_graph_compiler_ia32.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"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 1164 matching lines @@
     const ICData& ic_data) {
   uword label_address = 0;
   if (ic_data.NumArgsTested() == 0) {
     label_address = StubCode::ZeroArgsUnoptimizedStaticCallEntryPoint();
   } else if (ic_data.NumArgsTested() == 2) {
     label_address = StubCode::TwoArgsUnoptimizedStaticCallEntryPoint();
   } else {
     UNIMPLEMENTED();
   }
   ExternalLabel target_label(label_address);
+  __ movl(EDX, Immediate(0));

[Florian Schneider, 2014/06/20 12:48:54]

This is bad for unoptimized code size.

[Ivan Posva, 2014/06/20 14:03:31]

We were fully aware of the code size issue when we implemented this fix. The
real fix will be to have different stubs, based on the call patterns and the
corresponding live registers.

   __ LoadObject(ECX, ic_data);
   GenerateDartCall(deopt_id,
                    token_pos,
                    &target_label,
                    PcDescriptors::kUnoptStaticCall,
                    locs);
   __ Drop(argument_count);
+#if defined(DEBUG)
+  __ movl(EDX, Immediate(kInvalidObjectPointer));
+#endif
 }
 
 
 void FlowGraphCompiler::EmitEdgeCounter() {
   // We do not check for overflow when incrementing the edge counter.  The
   // function should normally be optimized long before the counter can
   // overflow; and though we do not reset the counters when we optimize or
   // deoptimize, there is a bound on the number of
   // optimization/deoptimization cycles we will attempt.
   const Array& counter = Array::ZoneHandle(Array::New(1, Heap::kOld));
@@ skipping 30 matching lines @@
 }
 
 
 void FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
                                          const ICData& ic_data,
                                          intptr_t argument_count,
                                          intptr_t deopt_id,
                                          intptr_t token_pos,
                                          LocationSummary* locs) {
   ASSERT(Array::Handle(ic_data.arguments_descriptor()).Length() > 0);
+  __ movl(EDX, Immediate(0));
   __ LoadObject(ECX, ic_data);
   GenerateDartCall(deopt_id,
                    token_pos,
                    target_label,
                    PcDescriptors::kIcCall,
                    locs);
   __ Drop(argument_count);
+#if defined(DEBUG)
+  __ movl(EDX, Immediate(kInvalidObjectPointer));
+#endif
 }
 
 
 void FlowGraphCompiler::EmitMegamorphicInstanceCall(
     const ICData& ic_data,
     intptr_t argument_count,
     intptr_t deopt_id,
     intptr_t token_pos,
     LocationSummary* locs) {
   MegamorphicCacheTable* table = Isolate::Current()->megamorphic_cache_table();
@@ skipping 109 matching lines @@
 void FlowGraphCompiler::EmitEqualityRegRegCompare(Register left,
                                                   Register right,
                                                   bool needs_number_check,
                                                   intptr_t token_pos) {
   if (needs_number_check) {
     __ pushl(left);
     __ pushl(right);
     if (is_optimizing()) {
       __ call(&StubCode::OptimizedIdenticalWithNumberCheckLabel());
     } else {
+      __ movl(EDX, Immediate(0));
+      __ movl(ECX, Immediate(0));
       __ call(&StubCode::UnoptimizedIdenticalWithNumberCheckLabel());
     }
     if (token_pos != Scanner::kNoSourcePos) {
       AddCurrentDescriptor(PcDescriptors::kRuntimeCall,
                            Isolate::kNoDeoptId,
                            token_pos);
     }
+#if defined(DEBUG)
+    if (!is_optimizing()) {
+      // Do this *after* adding the pc descriptor!
+      __ movl(EDX, Immediate(kInvalidObjectPointer));
+      __ movl(ECX, Immediate(kInvalidObjectPointer));
+    }
+#endif
     // Stub returns result in flags (result of a cmpl, we need ZF computed).
     __ popl(right);
     __ popl(left);
   } else {
     __ cmpl(left, right);
   }
 }
 
 
 // This function must be in sync with FlowGraphCompiler::RecordSafepoint and
@@ skipping 344 matching lines @@
   __ movups(reg, Address(ESP, 0));
   __ addl(ESP, Immediate(kFpuRegisterSize));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32