Rebase of partial ia32 implementation of optimized try/catch (started by Kevin Millikin, continued …

src/runtime.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 2275 matching lines @@
   array->set_elements(elements);
   array->set_length(Smi::FromInt(elements_count));
   // Write in-object properties after the length of the array.
   array->InObjectPropertyAtPut(JSRegExpResult::kIndexIndex, args[1]);
   array->InObjectPropertyAtPut(JSRegExpResult::kInputIndex, args[2]);
   return array;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_RegExpInitializeObject) {
+  //FIXME(mmassi): ask yangguo if this should be moved, too...
   SealHandleScope shs(isolate);
-  DisallowHeapAllocation no_allocation;
   ASSERT(args.length() == 5);
   CONVERT_ARG_CHECKED(JSRegExp, regexp, 0);
   CONVERT_ARG_CHECKED(String, source, 1);
+  // The no_allocation scope must begin after the above checks because they can
+  // throw and the throw can allocate to build the message.
+  DisallowHeapAllocation no_allocation;
   // If source is the empty string we set it to "(?:)" instead as
   // suggested by ECMA-262, 5th, section 15.10.4.1.
   if (source->length() == 0) source = isolate->heap()->query_colon_string();
 
   Object* global = args[2];
   if (!global->IsTrue()) global = isolate->heap()->false_value();
 
   Object* ignoreCase = args[3];
   if (!ignoreCase->IsTrue()) ignoreCase = isolate->heap()->false_value();
 
@@ skipping 6764 matching lines @@
     // Setting read only property in strict mode.
     Handle<Object> error =
       isolate->factory()->NewTypeError(
           "strict_cannot_assign", HandleVector(&name, 1));
     return isolate->Throw(*error);
   }
   return *value;
 }
 
 
+// Returns the offset in "code" where the code has been patched, as a SMI.
+RUNTIME_FUNCTION(MaybeObject*, Runtime_CatchInOptimizedCode) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+  Code* code = reinterpret_cast<Code*>(args[0]);
+
+  // From the safepoint of the call (i.e., the frame's pc) we can get the
+  // offset of the lazy deoptimization point.
+  DeoptimizationInputData* deopt_data =
+      DeoptimizationInputData::cast(code->deoptimization_data());
+  int deopt_index = isolate->optimized_handler_deopt_index();
+  ASSERT(deopt_index < deopt_data->DeoptCount());
+
+  // Save the code at the lazy deoptimization point off to the side and
+  // patch the lazy deoptimization point with a call to the lazy deopt stub.
+  int patch_size = Deoptimizer::patch_size();
+  Address patch_address =
+      code->instruction_start() + deopt_data->Pc(deopt_index)->value();
+  isolate->set_optimized_handler_patch_buffer(patch_address, patch_size);
+  CodePatcher patcher(patch_address, patch_size);
+  Address deopt_entry = Deoptimizer::GetDeoptimizationEntry(
+      isolate, deopt_index, Deoptimizer::LAZY);
+  //TODO(mmassi): Add a proper "NONE" to RelocInfo.
+  patcher.masm()->call(deopt_entry, RelocInfo::NONE32);
+
+  // Lazy deoptimization expects to find the code in a linked list.
+  isolate->deoptimizer_data()->append_deoptimizing_code(code);
+
+  int frame_pc_offset = isolate->optimized_handler_frame_pc_offset();
+  isolate->clear_optimized_handler_frame_pc_offset();
+  return Smi::FromInt(frame_pc_offset);
+}
+
+
 RUNTIME_FUNCTION(MaybeObject*, Runtime_Throw) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
 
   return isolate->Throw(args[0]);
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_ReThrow) {
   HandleScope scope(isolate);
@@ skipping 4752 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal