Assembler changes for enabling GrowHeap in Wasm

src/ia32/assembler-ia32-inl.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 59 matching lines @@
     *p -= delta;  // Relocate entry.
   } else if (IsInternalReference(rmode_)) {
     // absolute code pointer inside code object moves with the code object.
     int32_t* p = reinterpret_cast<int32_t*>(pc_);
     *p += delta;  // Relocate entry.
   }
 }
 
 
 Address RelocInfo::target_address() {
-  DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_));
+  DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_) ||
+         IsWasmCodeEntry(rmode_));
   return Assembler::target_address_at(pc_, host_);
 }
 
 
 Address RelocInfo::target_address_address() {
   DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_)
                               || rmode_ == EMBEDDED_OBJECT
                               || rmode_ == EXTERNAL_REFERENCE);
   return reinterpret_cast<Address>(pc_);
 }
 
 
 Address RelocInfo::constant_pool_entry_address() {
   UNREACHABLE();
   return NULL;
 }
 
 
 int RelocInfo::target_address_size() {
   return Assembler::kSpecialTargetSize;
 }
 
 
 void RelocInfo::set_target_address(Address target,

[Yang, 2016/03/03 06:21:56]

Can we create a separate method to do the wasm heap address patching? This
method, as the name states, is for call targets. It may contain the same code,
yes, but overloading this method to deal with wasm heap addresses is going to
cause a lot of confusion. Maybe call the new method set_wasm_heap_reference or
something.

[gdeepti1, 2016/03/03 22:59:15]

Done.

                                    WriteBarrierMode write_barrier_mode,
                                    ICacheFlushMode icache_flush_mode) {
   Assembler::set_target_address_at(isolate_, pc_, host_, target,
                                    icache_flush_mode);
-  DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_));
+  DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_) ||
+         IsWasmCodeEntry(rmode_));
   if (write_barrier_mode == UPDATE_WRITE_BARRIER && host() != NULL &&
       IsCodeTarget(rmode_)) {
     Object* target_code = Code::GetCodeFromTargetAddress(target);
     host()->GetHeap()->incremental_marking()->RecordWriteIntoCode(
         host(), this, HeapObject::cast(target_code));
   }
 }
 
 
 Object* RelocInfo::target_object() {
@@ skipping 194 matching lines @@
   }
 }
 
 
 
 Immediate::Immediate(int x)  {
   x_ = x;
   rmode_ = RelocInfo::NONE32;
 }
 
+Immediate::Immediate(int x, RelocInfo::Mode rmode) {
+  x_ = x;
+  rmode_ = rmode;
+}
 
 Immediate::Immediate(const ExternalReference& ext) {
   x_ = reinterpret_cast<int32_t>(ext.address());
   rmode_ = RelocInfo::EXTERNAL_REFERENCE;
 }
 
 
 Immediate::Immediate(Label* internal_offset) {
   x_ = reinterpret_cast<int32_t>(internal_offset);
   rmode_ = RelocInfo::INTERNAL_REFERENCE;
@@ skipping 212 matching lines @@
 
 Operand::Operand(Immediate imm) {
   // [disp/r]
   set_modrm(0, ebp);
   set_dispr(imm.x_, imm.rmode_);
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_IA32_ASSEMBLER_IA32_INL_H_