Reimplement stack manipulations for LiveEdit

src/heap.cc

 // Copyright 2009 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 2405 matching lines @@
   Address new_addr = reinterpret_cast<HeapObject*>(result)->address();
   CopyBlock(new_addr, old_addr, obj_size);
   // Relocate the copy.
   Code* new_code = Code::cast(result);
   ASSERT(!CodeRange::exists() || CodeRange::contains(code->address()));
   new_code->Relocate(new_addr - old_addr);
   return new_code;
 }
 
 
-Object* Heap::CopyCode(Code* code, Vector<byte> reloc_info) {
-  // Allocate ByteArray before the Code object, so that we do not risk
-  // leaving uninitialized Code object (and breaking the heap).
-  Object* reloc_info_array = AllocateByteArray(reloc_info.length(), TENURED);
-  if (reloc_info_array->IsFailure()) return reloc_info_array;
-
-  int new_body_size = RoundUp(code->instruction_size(), kObjectAlignment);
+Object* Heap::AddPatchToCode(Code* code, Code* patch) {
+  int space_size = patch->instruction_size();
+  int new_body_size = RoundUp(code->instruction_size() + space_size,
+      kObjectAlignment);
 
   int sinfo_size = code->sinfo_size();
 
   int new_obj_size = Code::SizeFor(new_body_size, sinfo_size);
 
   Address old_addr = code->address();
 
-  size_t relocation_offset =
-      static_cast<size_t>(code->instruction_end() - old_addr);
-
   Object* result;
   if (new_obj_size > MaxObjectSizeInPagedSpace()) {
     result = lo_space_->AllocateRawCode(new_obj_size);
   } else {
     result = code_space_->AllocateRaw(new_obj_size);
   }
 
   if (result->IsFailure()) return result;
 
   // Copy code object.
   Address new_addr = reinterpret_cast<HeapObject*>(result)->address();
 
+  int first_part_size =
+      code->instruction_start() + code->instruction_size() - old_addr;
+
   // Copy header and instructions.
-  memcpy(new_addr, old_addr, relocation_offset);
+  memcpy(new_addr, old_addr, first_part_size);
 
   Code* new_code = Code::cast(result);
-  new_code->set_relocation_info(ByteArray::cast(reloc_info_array));
+  new_code->set_instruction_size(code->instruction_size() + space_size);
 
-  // Copy patched rinfo.
-  memcpy(new_code->relocation_start(), reloc_info.start(), reloc_info.length());
+  // Copy patch instructions ignoring its rinfo/sinfo.
+  memcpy(new_addr + first_part_size, patch->instruction_start(), space_size);
+
   // Copy sinfo.
   memcpy(new_code->sinfo_start(), code->sinfo_start(), code->sinfo_size());
 
   // Relocate the copy.
   ASSERT(!CodeRange::exists() || CodeRange::contains(code->address()));
   new_code->Relocate(new_addr - old_addr);
 
 #ifdef DEBUG
-  code->Verify();
+  new_code->Verify();
 #endif
   return new_code;
 }
 
 
 Object* Heap::Allocate(Map* map, AllocationSpace space) {
   ASSERT(gc_state_ == NOT_IN_GC);
   ASSERT(map->instance_type() != MAP_TYPE);
   // If allocation failures are disallowed, we may allocate in a different
   // space when new space is full and the object is not a large object.
@@ skipping 2349 matching lines @@
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 List<Object*> ExternalStringTable::new_space_strings_;
 List<Object*> ExternalStringTable::old_space_strings_;
 
 } }  // namespace v8::internal