Cleanup more isolate usage in ia32 files.

src/ia32/deoptimizer-ia32.cc

 // Copyright 2011 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 38 matching lines @@
 #ifdef DEBUG
   ASSERT(start <= end);
   int size = end - start;
   CodePatcher destroyer(start, size);
   while (size-- > 0) destroyer.masm()->int3();
 #endif
 }
 
 
 void Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(Handle<Code> code) {
-  HandleScope scope;
+  Isolate* isolate = code->GetIsolate();
+  HandleScope scope(isolate);
 
   // Compute the size of relocation information needed for the code
   // patching in Deoptimizer::DeoptimizeFunction.
   int min_reloc_size = 0;
   Address prev_reloc_address = code->instruction_start();
   Address code_start_address = code->instruction_start();
   SafepointTable table(*code);
   for (unsigned i = 0; i < table.length(); ++i) {
     Address curr_reloc_address = code_start_address + table.GetPcOffset(i);
     ASSERT_GE(curr_reloc_address, prev_reloc_address);
@@ skipping 26 matching lines @@
     // Padding needed.
     int min_padding = min_reloc_size - reloc_length;
     // Number of comments needed to take up at least that much space.
     int additional_comments =
         (min_padding + comment_reloc_size - 1) / comment_reloc_size;
     // Actual padding size.
     int padding = additional_comments * comment_reloc_size;
     // Allocate new relocation info and copy old relocation to the end
     // of the new relocation info array because relocation info is
     // written and read backwards.
-    Factory* factory = code->GetIsolate()->factory();
+    Factory* factory = isolate->factory();
     Handle<ByteArray> new_reloc =
         factory->NewByteArray(reloc_length + padding, TENURED);
     memcpy(new_reloc->GetDataStartAddress() + padding,
            code->relocation_info()->GetDataStartAddress(),
            reloc_length);
     // Create a relocation writer to write the comments in the padding
     // space. Use position 0 for everything to ensure short encoding.
     RelocInfoWriter reloc_info_writer(
         new_reloc->GetDataStartAddress() + padding, 0);
     intptr_t comment_string
         = reinterpret_cast<intptr_t>(RelocInfo::kFillerCommentString);
     RelocInfo rinfo(0, RelocInfo::COMMENT, comment_string);
     for (int i = 0; i < additional_comments; ++i) {
 #ifdef DEBUG
       byte* pos_before = reloc_info_writer.pos();
 #endif
       reloc_info_writer.Write(&rinfo);
       ASSERT(RelocInfo::kMinRelocCommentSize ==
              pos_before - reloc_info_writer.pos());
     }
     // Replace relocation information on the code object.
     code->set_relocation_info(*new_reloc);
   }
 }
 
 
 void Deoptimizer::DeoptimizeFunction(JSFunction* function) {
-  HandleScope scope;
+  if (!function->IsOptimized()) return;
+
+  Isolate* isolate = function->GetIsolate();
+  HandleScope scope(isolate);
   AssertNoAllocation no_allocation;
 
-  if (!function->IsOptimized()) return;
-
   // Get the optimized code.
   Code* code = function->code();
   Address code_start_address = code->instruction_start();
 
   // We will overwrite the code's relocation info in-place. Relocation info
   // is written backward. The relocation info is the payload of a byte
   // array.  Later on we will slide this to the start of the byte array and
   // create a filler object in the remaining space.
   ByteArray* reloc_info = code->relocation_info();
   Address reloc_end_address = reloc_info->address() + reloc_info->Size();
@@ skipping 38 matching lines @@
   int new_reloc_size = reloc_end_address - reloc_info_writer.pos();
   memmove(code->relocation_start(), reloc_info_writer.pos(), new_reloc_size);
 
   // The relocation info is in place, update the size.
   reloc_info->set_length(new_reloc_size);
 
   // Handle the junk part after the new relocation info. We will create
   // a non-live object in the extra space at the end of the former reloc info.
   Address junk_address = reloc_info->address() + reloc_info->Size();
   ASSERT(junk_address <= reloc_end_address);
-  HEAP->CreateFillerObjectAt(junk_address, reloc_end_address - junk_address);
+  isolate->heap()->CreateFillerObjectAt(junk_address,
+                                        reloc_end_address - junk_address);
 
   // Add the deoptimizing code to the list.
   DeoptimizingCodeListNode* node = new DeoptimizingCodeListNode(code);
-  DeoptimizerData* data = code->GetIsolate()->deoptimizer_data();
+  DeoptimizerData* data = isolate->deoptimizer_data();
   node->set_next(data->deoptimizing_code_list_);
   data->deoptimizing_code_list_ = node;
 
   // Set the code for the function to non-optimized version.
   function->ReplaceCode(function->shared()->code());
 
   if (FLAG_trace_deopt) {
     PrintF("[forced deoptimization: ");
     function->PrintName();
     PrintF(" / %x]\n", reinterpret_cast<uint32_t>(function));
@@ skipping 530 matching lines @@
   }
   __ bind(&done);
 }
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32