Use the location summary to represent safepoint information.

runtime/vm/flow_graph_compiler_ia32.cc

 // Copyright (c) 2012, 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 "lib/error.h"
@@ skipping 29 matching lines @@
     const intptr_t offset = assem->CodeSize();
     __ Bind(&L);
     __ popl(EAX);
     __ subl(EAX,
         Immediate(offset - AssemblerMacros::kOffsetOfSavedPCfromEntrypoint));
     __ movl(Address(EBP, -kWordSize), EAX);
     __ popl(EAX);
   }
   __ call(&StubCode::DeoptimizeLabel());
   const intptr_t deopt_info_index = stub_ix;
-  compiler->pc_descriptors_list()-> AddDeoptInfo(
+  compiler->pc_descriptors_list()->AddDeoptInfo(
       compiler->assembler()->CodeSize(),
       deopt_id_,
       reason_,
       deopt_info_index);
 #undef __
 }
 
 
 #define __ assembler()->
 
@@ skipping 382 matching lines @@
 // - EDX: instantiator type arguments or raw_null.
 // - ECX: instantiator or raw_null.
 // Clobbers ECX and EDX.
 // Returns:
 // - true or false in EAX.
 void FlowGraphCompiler::GenerateInstanceOf(intptr_t deopt_id,
                                            intptr_t token_pos,
                                            intptr_t try_index,
                                            const AbstractType& type,
                                            bool negate_result,
-                                           BitmapBuilder* stack_bitmap) {
+                                           LocationSummary* locs) {
   ASSERT(type.IsFinalized() && !type.IsMalformed());
 
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label is_instance, is_not_instance;
   __ pushl(ECX);  // Store instantiator on stack.
   __ pushl(EDX);  // Store instantiator type arguments.
   // If type is instantiated and non-parameterized, we can inline code
   // checking whether the tested instance is a Smi.
   if (type.IsInstantiated()) {
@@ skipping 20 matching lines @@
     __ movl(EDX, Address(ESP, 0));  // Get instantiator type arguments.
     __ movl(ECX, Address(ESP, kWordSize));  // Get instantiator.
     __ PushObject(Object::ZoneHandle());  // Make room for the result.
     __ pushl(EAX);  // Push the instance.
     __ PushObject(type);  // Push the type.
     __ pushl(ECX);  // Instantiator.
     __ pushl(EDX);  // Instantiator type arguments.
     __ LoadObject(EAX, test_cache);
     __ pushl(EAX);
     GenerateCallRuntime(deopt_id, token_pos, try_index,
-                        kInstanceofRuntimeEntry, stack_bitmap);
+                        kInstanceofRuntimeEntry, locs);
     // Pop the parameters supplied to the runtime entry. The result of the
     // instanceof runtime call will be left as the result of the operation.
     __ Drop(5);
     if (negate_result) {
       __ popl(EDX);
       __ LoadObject(EAX, bool_true());
       __ cmpl(EDX, EAX);
       __ j(NOT_EQUAL, &done, Assembler::kNearJump);
       __ LoadObject(EAX, bool_false());
     } else {
@@ skipping 23 matching lines @@
 // - ECX: instantiator or raw_null.
 // Returns:
 // - object in EAX for successful assignable check (or throws TypeError).
 // Performance notes: positive checks must be quick, negative checks can be slow
 // as they throw an exception.
 void FlowGraphCompiler::GenerateAssertAssignable(intptr_t deopt_id,
                                                  intptr_t token_pos,
                                                  intptr_t try_index,
                                                  const AbstractType& dst_type,
                                                  const String& dst_name,
-                                                 BitmapBuilder* stack_bitmap) {
+                                                 LocationSummary* locs) {
   ASSERT(token_pos >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
   // Assignable check is skipped in FlowGraphBuilder, not here.
   ASSERT(dst_type.IsMalformed() ||
          (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
   __ pushl(ECX);  // Store instantiator.
   __ pushl(EDX);  // Store instantiator type arguments.
   // A null object is always assignable and is returned as result.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label is_assignable, runtime_call;
   __ cmpl(EAX, raw_null);
   __ j(EQUAL, &is_assignable);
 
   // Generate throw new TypeError() if the type is malformed.
   if (dst_type.IsMalformed()) {
     const Error& error = Error::Handle(dst_type.malformed_error());
     const String& error_message = String::ZoneHandle(
         Symbols::New(error.ToErrorCString()));
     __ PushObject(Object::ZoneHandle());  // Make room for the result.
     __ pushl(EAX);  // Push the source object.
     __ PushObject(dst_name);  // Push the name of the destination.
     __ PushObject(error_message);
     GenerateCallRuntime(deopt_id,
                         token_pos,
                         try_index,
                         kMalformedTypeErrorRuntimeEntry,
-                        stack_bitmap);
+                        locs);
     // We should never return here.
     __ int3();
 
     __ Bind(&is_assignable);  // For a null object.
     __ popl(EDX);  // Remove pushed instantiator type arguments.
     __ popl(ECX);  // Remove pushed instantiator.
     return;
   }
 
   // Generate inline type check, linking to runtime call if not assignable.
   SubtypeTestCache& test_cache = SubtypeTestCache::ZoneHandle();
   test_cache = GenerateInlineInstanceof(token_pos, dst_type,
                                         &is_assignable, &runtime_call);
 
   __ Bind(&runtime_call);
   __ movl(EDX, Address(ESP, 0));  // Get instantiator type arguments.
   __ movl(ECX, Address(ESP, kWordSize));  // Get instantiator.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushl(EAX);  // Push the source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   __ pushl(ECX);  // Instantiator.
   __ pushl(EDX);  // Instantiator type arguments.
   __ PushObject(dst_name);  // Push the name of the destination.
   __ LoadObject(EAX, test_cache);
   __ pushl(EAX);
   GenerateCallRuntime(deopt_id,
                       token_pos,
                       try_index,
                       kTypeCheckRuntimeEntry,
-                      stack_bitmap);
+                      locs);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ Drop(6);
   __ popl(EAX);
 
   __ Bind(&is_assignable);
   __ popl(EDX);  // Remove pushed instantiator type arguments.
   __ popl(ECX);  // Remove pushed instantiator.
 }
 
@@ skipping 153 matching lines @@
   if (StackSize() != 0) {
     // We need to unwind the space we reserved for locals and copied parameters.
     // The NoSuchMethodFunction stub does not expect to see that area on the
     // stack.
     __ addl(ESP, Immediate(StackSize() * kWordSize));
   }
   // The calls below have empty stackmaps because we have just dropped the
   // spill slots.
   BitmapBuilder* empty_stack_bitmap = new BitmapBuilder();
   if (function.IsClosureFunction()) {
-    GenerateCallRuntime(Isolate::kNoDeoptId,
-                        0,
-                        CatchClauseNode::kInvalidTryIndex,
-                        kClosureArgumentMismatchRuntimeEntry,
-                        empty_stack_bitmap);
+    // We do not use GenerateCallRuntime because of the non-standard (empty)
+    // stackmap used here.
+    __ CallRuntime(kClosureArgumentMismatchRuntimeEntry);
+    AddCurrentDescriptor(PcDescriptors::kOther,
+                         Isolate::kNoDeoptId,
+                         0,  // No token position.
+                         CatchClauseNode::kInvalidTryIndex);
   } else {
     ASSERT(!IsLeaf());
     // Invoke noSuchMethod function.
     const int kNumArgsChecked = 1;
     ICData& ic_data = ICData::ZoneHandle();
     ic_data = ICData::New(function,
                           String::Handle(function.name()),
                           Isolate::kNoDeoptId,
                           kNumArgsChecked);
     __ LoadObject(ECX, ic_data);
     // EBP - 4 : PC marker, allows easy identification of RawInstruction obj.
     // EBP : points to previous frame pointer.
     // EBP + 4 : points to return address.
     // EBP + 8 : address of last argument (arg n-1).
     // ESP + 8 + 4*(n-1) : address of first argument (arg 0).
     // ECX : ic-data.
     // EDX : arguments descriptor array.
     __ call(&StubCode::CallNoSuchMethodFunctionLabel());
+  }
+  if (is_optimizing()) {
+    stackmap_table_builder_->AddEntry(assembler()->CodeSize(),
+                                      empty_stack_bitmap);
+  }
+
+
+  if (FLAG_trace_functions) {
+    __ pushl(EAX);  // Preserve result.
+    __ PushObject(Function::ZoneHandle(function.raw()));
+    // We do not use GenerateCallRuntime because of the non-standard (empty)
+    // stackmap used here.
+    __ CallRuntime(kTraceFunctionExitRuntimeEntry);
+    AddCurrentDescriptor(PcDescriptors::kOther,
+                         Isolate::kNoDeoptId,
+                         0,  // No token position.
+                         CatchClauseNode::kInvalidTryIndex);
     if (is_optimizing()) {
       stackmap_table_builder_->AddEntry(assembler()->CodeSize(),
                                         empty_stack_bitmap);
     }
-  }
-
-  if (FLAG_trace_functions) {
-    __ pushl(EAX);  // Preserve result.
-    __ PushObject(Function::ZoneHandle(function.raw()));
-    GenerateCallRuntime(Isolate::kNoDeoptId,
-                        0,
-                        CatchClauseNode::kInvalidTryIndex,
-                        kTraceFunctionExitRuntimeEntry,
-                        empty_stack_bitmap);
     __ popl(EAX);  // Remove argument.
     __ popl(EAX);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
 
   __ Bind(&all_arguments_processed);
   // Nullify originally passed arguments only after they have been copied and
   // checked, otherwise noSuchMethod would not see their original values.
   // This step can be skipped in case we decide that formal parameters are
@@ skipping 83 matching lines @@
   const int local_count = parsed_function().stack_local_count();
   __ Comment("Enter frame");
   if (IsLeaf()) {
     AssemblerMacros::EnterDartLeafFrame(assembler(), (StackSize() * kWordSize));
   } else {
     AssemblerMacros::EnterDartFrame(assembler(), (StackSize() * kWordSize));
   }
 
   // For optimized code, keep a bitmap of the frame in order to build
   // stackmaps for GC safepoints in the prologue.
-  BitmapBuilder* stack_bitmap = NULL;
+  LocationSummary* prologue_locs = NULL;
   if (is_optimizing()) {
     // Spill slots are allocated but not initialized.
-    stack_bitmap = new BitmapBuilder();
-    stack_bitmap->SetLength(StackSize());
+    prologue_locs = new LocationSummary(0, 0, LocationSummary::kCall);
+    prologue_locs->stack_bitmap()->SetLength(StackSize());
   }
 
   // We check the number of passed arguments when we have to copy them due to
   // the presence of optional named parameters.
   // No such checking code is generated if only fixed parameters are declared,
   // unless we are debug mode or unless we are compiling a closure.
   if (copied_parameter_count == 0) {
 #ifdef DEBUG
     const bool check_arguments = true;
 #else
     const bool check_arguments = function.IsClosureFunction();
 #endif
     if (check_arguments) {
       __ Comment("Check argument count");
       // Check that num_fixed <= argc <= num_params.
       Label argc_in_range;
       // Total number of args is the first Smi in args descriptor array (EDX).
       __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
       __ cmpl(EAX, Immediate(Smi::RawValue(parameter_count)));
       __ j(EQUAL, &argc_in_range, Assembler::kNearJump);
       if (function.IsClosureFunction()) {
         GenerateCallRuntime(Isolate::kNoDeoptId,
                             function.token_pos(),
                             CatchClauseNode::kInvalidTryIndex,
                             kClosureArgumentMismatchRuntimeEntry,
-                            stack_bitmap);
+                            prologue_locs);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&argc_in_range);
     }
   } else {
     CopyParameters();
   }
 
   // In unoptimized code, initialize (non-argument) stack allocated slots to
@@ skipping 19 matching lines @@
     }
     AstPrinter::PrintFunctionScope(parsed_function());
   }
 
   VisitBlocks();
 
   __ int3();
   GenerateDeferredCode();
   // Emit function patching code. This will be swapped with the first 5 bytes
   // at entry point.
-  pc_descriptors_list()->AddDescriptor(PcDescriptors::kPatchCode,
-                                       assembler()->CodeSize(),
-                                       Isolate::kNoDeoptId,
-                                       0,
-                                       -1);
+  AddCurrentDescriptor(PcDescriptors::kPatchCode,
+                       Isolate::kNoDeoptId,
+                       0,  // No token position.
+                       CatchClauseNode::kInvalidTryIndex);
   __ jmp(&StubCode::FixCallersTargetLabel());
 }
 
 
 void FlowGraphCompiler::GenerateCall(intptr_t token_pos,
                                      intptr_t try_index,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind,
-                                     BitmapBuilder* stack_bitmap) {
+                                     LocationSummary* locs) {
   ASSERT(!IsLeaf());
   __ call(label);
-  if (is_optimizing() && (stack_bitmap != NULL)) {
-    stackmap_table_builder_->AddEntry(assembler()->CodeSize(), stack_bitmap);
-  }
   AddCurrentDescriptor(kind, Isolate::kNoDeoptId, token_pos, try_index);
+  RecordSafepoint(locs);
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t deopt_id,
                                             intptr_t token_pos,
                                             intptr_t try_index,
                                             const RuntimeEntry& entry,
-                                            BitmapBuilder* stack_bitmap) {
+                                            LocationSummary* locs) {
   ASSERT(!IsLeaf());
-  ASSERT(!is_optimizing() || (stack_bitmap != NULL));
   __ CallRuntime(entry);
-  if (is_optimizing()) {
-    stackmap_table_builder_->AddEntry(assembler()->CodeSize(), stack_bitmap);
-  }
   AddCurrentDescriptor(PcDescriptors::kOther, deopt_id, token_pos, try_index);
+  RecordSafepoint(locs);
 }
 
 
-intptr_t FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
-                                             const ICData& ic_data,
-                                             const Array& arguments_descriptor,
-                                             intptr_t argument_count) {
+void FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label,
+                                         const ICData& ic_data,
+                                         const Array& arguments_descriptor,
+                                         intptr_t argument_count,
+                                         intptr_t deopt_id,
+                                         intptr_t token_pos,
+                                         intptr_t try_index,
+                                         LocationSummary* locs) {
   ASSERT(!IsLeaf());
   __ LoadObject(ECX, ic_data);
   __ LoadObject(EDX, arguments_descriptor);
 
   __ call(target_label);
-  const intptr_t descr_offset = assembler()->CodeSize();
+  AddCurrentDescriptor(PcDescriptors::kIcCall, deopt_id, token_pos, try_index);
+  RecordSafepoint(locs);
+
   __ Drop(argument_count);
-  return descr_offset;
 }
 
 
-intptr_t FlowGraphCompiler::EmitStaticCall(const Function& function,
-                                           const Array& arguments_descriptor,
-                                           intptr_t argument_count) {
+void FlowGraphCompiler::EmitStaticCall(const Function& function,
+                                       const Array& arguments_descriptor,
+                                       intptr_t argument_count,
+                                       intptr_t deopt_id,
+                                       intptr_t token_pos,
+                                       intptr_t try_index,
+                                       LocationSummary* locs) {
   ASSERT(!IsLeaf());
   __ LoadObject(ECX, function);
   __ LoadObject(EDX, arguments_descriptor);
   __ call(&StubCode::CallStaticFunctionLabel());
-  const intptr_t descr_offset = assembler()->CodeSize();
+  AddCurrentDescriptor(PcDescriptors::kFuncCall, deopt_id, token_pos,
+                       try_index);
+  RecordSafepoint(locs);
   __ Drop(argument_count);
-  return descr_offset;
 }
 
 
 // Checks class id of instance against all 'class_ids'. Jump to 'deopt' label
 // if no match or instance is Smi.
 void FlowGraphCompiler::EmitClassChecksNoSmi(const ICData& ic_data,
                                              Register instance_reg,
                                              Register temp_reg,
                                              Label* deopt) {
   Label ok;
@@ skipping 167 matching lines @@
   __ popl(ECX);
   __ popl(EAX);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32