Thumb2 Backend: Update Code objects with mode, separate Assembler methods for Thumb2

src/arm/assembler-arm-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 137 matching lines @@
 
 
 void RelocInfo::set_target_object(Object* target, WriteBarrierMode mode) {
   ASSERT(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT);
   ASSERT(!target->IsConsString());
   Assembler::set_target_pointer_at(pc_, reinterpret_cast<Address>(target));
   if (mode == UPDATE_WRITE_BARRIER &&
       host() != NULL &&
       target->IsHeapObject()) {
     host()->GetHeap()->incremental_marking()->RecordWrite(
-        host(), &Memory::Object_at(pc_), HeapObject::cast(target));
+        host(),
+        &Memory::Object_at(Assembler::UntagAddress(pc_)),
+        HeapObject::cast(target));
   }
 }
 
 
 Address* RelocInfo::target_reference_address() {
   ASSERT(rmode_ == EXTERNAL_REFERENCE);
   reconstructed_adr_ptr_ = Assembler::target_address_at(pc_);
   return &reconstructed_adr_ptr_;
 }
 
@@ skipping 204 matching lines @@
   if (buffer_space() <= kGap) {
     GrowBuffer();
   }
   if (pc_offset() >= next_buffer_check_) {
     CheckConstPool(false, true);
   }
 }
 
 
 void Assembler::emit(Instr x) {
+  if (is_thumb_mode()) {
+    emit32(x);
+    return;
+  }
   CheckBuffer();
   *reinterpret_cast<Instr*>(pc_) = x;
   pc_ += kInstrSize;
 }
 
 
 void Assembler::emit16(Instr16 x, bool check_buffer) {
   if (check_buffer) {
     CheckBuffer();
   }
   *reinterpret_cast<Instr16*>(pc_) = x;
   pc_ += 2;
 }
 
 
 void Assembler::emit32(Instr x) {
   // emit top, then bottom 2 bytes
   emit16((x>>16) & 0xffff);
   emit16(x & 0xffff, false);
 }
 
 
 Address Assembler::target_pointer_address_at(Address pc) {
+  if (IsThumbAddress(pc)) {
+    return thumb_target_pointer_address_at(UntagAddress(pc));
+  }
+
   Address target_pc = pc;
   Instr instr = Memory::int32_at(target_pc);
   // If we have a bx instruction, the instruction before the bx is
   // what we need to patch.
   static const int32_t kBxInstMask = 0x0ffffff0;
   static const int32_t kBxInstPattern = 0x012fff10;
   if ((instr & kBxInstMask) == kBxInstPattern) {
     target_pc -= kInstrSize;
     instr = Memory::int32_at(target_pc);
   }
 
   // With a blx instruction, the instruction before is what needs to be patched.
   if ((instr & kBlxRegMask) == kBlxRegPattern) {
     target_pc -= kInstrSize;
     instr = Memory::int32_at(target_pc);
   }
 
   ASSERT(IsLdrPcImmediateOffset(instr));
   int offset = instr & 0xfff;  // offset_12 is unsigned
   if ((instr & (1 << 23)) == 0) offset = -offset;  // U bit defines offset sign
   // Verify that the constant pool comes after the instruction referencing it.
   ASSERT(offset >= -4);
   return target_pc + offset + 8;
 }
 
 
 Address Assembler::target_pointer_at(Address pc) {
+  if (IsThumbAddress(pc)) {
+    return thumb_target_pointer_at(UntagAddress(pc));
+  }
   if (IsMovW(Memory::int32_at(pc))) {
     ASSERT(IsMovT(Memory::int32_at(pc + kInstrSize)));
     Instruction* instr = Instruction::At(pc);
     Instruction* next_instr = Instruction::At(pc + kInstrSize);
     return reinterpret_cast<Address>(
         (next_instr->ImmedMovwMovtValue() << 16) |
         instr->ImmedMovwMovtValue());
   }
   return Memory::Address_at(target_pointer_address_at(pc));
 }
 
 
 Address Assembler::target_address_from_return_address(Address pc) {
   // Returns the address of the call target from the return address that will
   // be returned to after a call.
   // Call sequence on V7 or later is :
   //  movw  ip, #... @ call address low 16
   //  movt  ip, #... @ call address high 16
   //  blx   ip
   //                      @ return address
   // Or pre-V7 or cases that need frequent patching:
   //  ldr   ip, [pc, #...] @ call address
   //  blx   ip
   //                      @ return address
   Address candidate = pc - 2 * Assembler::kInstrSize;
   Instr candidate_instr(Memory::int32_at(candidate));
   if (IsLdrPcImmediateOffset(candidate_instr)) {
     return candidate;
+  } else {
+    candidate = pc - Assembler::kInstrSize - Assembler::kInstr16Size - 1;
+    if (IsThumbLdrPcImmediateOffset(thumb32_instr_at(candidate))) {
+        return candidate + 1;
+    } else {
+      candidate = pc - 2 * Assembler::kInstrSize - Assembler::kInstr16Size - 1;
+      if (IsMovWThumb(thumb32_instr_at(candidate))) {
+        ASSERT(IsMovTThumb(thumb32_instr_at(candidate + kInstrSize)));
+        return candidate + 1;
+      }
+    }
   }
   candidate = pc - 3 * Assembler::kInstrSize;
   ASSERT(IsMovW(Memory::int32_at(candidate)) &&
          IsMovT(Memory::int32_at(candidate + kInstrSize)));
   return candidate;
 }
 
 
 Address Assembler::return_address_from_call_start(Address pc) {
+  if (IsThumbAddress(pc)) {
+    pc = UntagAddress(pc);
+    Instr instr = thumb32_instr_at(pc);
+    if (IsThumbLdrPcImmediateOffset(instr)) {
+      return pc + kInstrSize + kInstr16Size;
+    }
+    ASSERT(IsMovWThumb(instr));
+    ASSERT(IsMovTThumb(thumb32_instr_at(pc + kInstrSize)));
+    return pc + kInstrSize * 2 + kInstr16Size;
+  }
   if (IsLdrPcImmediateOffset(Memory::int32_at(pc))) {
     return pc + kInstrSize * 2;
   } else {
     ASSERT(IsMovW(Memory::int32_at(pc)));
     ASSERT(IsMovT(Memory::int32_at(pc + kInstrSize)));
     return pc + kInstrSize * 3;
   }
 }
 
 
 void Assembler::deserialization_set_special_target_at(
     Address constant_pool_entry, Address target) {
   Memory::Address_at(constant_pool_entry) = target;
 }
 
 
 void Assembler::set_external_target_at(Address constant_pool_entry,
                                        Address target) {
   Memory::Address_at(constant_pool_entry) = target;
 }
 
 
 static Instr EncodeMovwImmediate(uint32_t immediate) {
   ASSERT(immediate < 0x10000);
   return ((immediate & 0xf000) << 4) | (immediate & 0xfff);
 }
 
 
 void Assembler::set_target_pointer_at(Address pc, Address target) {
+  if (IsThumbAddress(pc)) {
+    thumb_set_target_pointer_at(UntagAddress(pc), target);
+    return;
+  }
   if (IsMovW(Memory::int32_at(pc))) {
     ASSERT(IsMovT(Memory::int32_at(pc + kInstrSize)));
     uint32_t* instr_ptr = reinterpret_cast<uint32_t*>(pc);
     uint32_t immediate = reinterpret_cast<uint32_t>(target);
     uint32_t intermediate = instr_ptr[0];
     intermediate &= ~EncodeMovwImmediate(0xFFFF);
     intermediate |= EncodeMovwImmediate(immediate & 0xFFFF);
     instr_ptr[0] = intermediate;
     intermediate = instr_ptr[1];
     intermediate &= ~EncodeMovwImmediate(0xFFFF);
@@ skipping 26 matching lines @@
   set_target_pointer_at(pc, target);
 }
 
 
 void Assembler::emit_it(Condition cond) {
   if (cond != al) {
     it_thumb(cond, 1);
   }
 }
 
+
+Address Assembler::AlignAddress(Address addr) {
+  return (Address)((uint32_t)addr &(~3));
+}
+
+
+Address Assembler::UntagAddress(Address addr) {
+  return (Address)((uint32_t)addr & (~1));
+}
+
+
+bool Assembler::IsThumbAddress(Address addr) {
+  return (((uint32_t)addr) & 1) == 1;
+}
+
+
+Address Assembler::thumb_target_pointer_at(Address pc) {
+  Instr instr = thumb32_instr_at(pc);
+  if (IsMovWThumb(instr)) {
+    Instr next_instr = thumb32_instr_at(pc + kInstrSize);
+    ASSERT(IsMovTThumb(next_instr));
+    return reinterpret_cast<Address>(
+        (thumb32_movw_immediate(next_instr) << 16) |
+        thumb32_movw_immediate(instr));
+  }
+  return Memory::Address_at(thumb_target_pointer_address_at(pc));
+}
+
+
+Address Assembler::thumb_target_pointer_address_at(Address pc) {
+  // We must have a load from the constant pool. The address in the constant
+  // pool is what needs to be patched.
+  Instr instr = thumb32_instr_at(pc);
+  ASSERT(IsThumbLdrPcImmediateOffset(instr));
+  pc = AlignAddress(pc);
+
+  int offset = instr & 0xfff;  // offset_12 is unsigned
+  if ((instr & (1 << 23)) == 0) offset = -offset;  // U bit defines offset sign
+  // Verify that the constant pool comes after the instruction referencing it.
+  ASSERT(offset >= -4);
+  return pc + offset + kThumbPcLoadDelta;
+}
+
+
+void Assembler::thumb_set_target_pointer_at(Address pc,
+                                            Address target,
+                                            Code* host) {
+  Instr instr = thumb32_instr_at(pc);
+  uint32_t immediate = reinterpret_cast<uint32_t>(target);
+  if (IsMovWThumb(instr)) {
+    Instr next_instr = thumb32_instr_at(pc + kInstrSize);
+    ASSERT(IsMovTThumb(next_instr));
+    uint16_t* instr_ptr = reinterpret_cast<uint16_t*>(pc);
+    uint32_t immediate_mask = thumb32_set_movw_immediate(0xFFFF);
+    instr &= ~immediate_mask;
+    instr |= thumb32_set_movw_immediate(immediate & 0xFFFF);
+    next_instr &= ~immediate_mask;
+    next_instr |= thumb32_set_movw_immediate(immediate >> 16);
+    instr_ptr[0] = instr >> 16;
+    instr_ptr[1] = instr & 0xFFFF;
+    instr_ptr[2] = next_instr >> 16;
+    instr_ptr[3] = next_instr & 0xFFFF;
+    CPU::FlushICache(pc, 2 * kInstrSize);
+    return;
+  } else if (IsThumbLdrPcImmediateOffset(instr)) {
+    Memory::Address_at(thumb_target_pointer_address_at(pc)) = target;
+    return;
+  }
+}
+
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_ASSEMBLER_ARM_INL_H_