Use direct jump and call instruction for X64 when the deoptimization entries are in the code range

src/assembler.cc

 // 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 275 matching lines @@
 const int kLastChunkTag = 1;
 
 
 const int kDataJumpExtraTag = kPCJumpExtraTag - 1;
 
 const int kCodeWithIdTag = 0;
 const int kNonstatementPositionTag = 1;
 const int kStatementPositionTag = 2;
 const int kCommentTag = 3;
 
+#if !defined(V8_TARGET_ARCH_X64)

[Sven Panne, 2012/12/14 08:20:11]

Again for this and the rest of the file: No architecture-dependent stuff should
be here.

 const int kConstPoolExtraTag = kPCJumpExtraTag - 2;
 const int kConstPoolTag = 3;
-
+#else
+const int kDeoptEntryExtraTag = kPCJumpExtraTag - 2;
+const int kDeoptEntryTag = 3;
+#endif
 
 uint32_t RelocInfoWriter::WriteVariableLengthPCJump(uint32_t pc_delta) {
   // Return if the pc_delta can fit in kSmallPCDeltaBits bits.
   // Otherwise write a variable length PC jump for the bits that do
   // not fit in the kSmallPCDeltaBits bits.
   if (is_uintn(pc_delta, kSmallPCDeltaBits)) return pc_delta;
   WriteExtraTag(kPCJumpExtraTag, kVariableLengthPCJumpTopTag);
   uint32_t pc_jump = pc_delta >> kSmallPCDeltaBits;
   ASSERT(pc_jump > 0);
   // Write kChunkBits size chunks of the pc_jump.
@@ skipping 37 matching lines @@
 
 void RelocInfoWriter::WriteExtraTaggedIntData(int data_delta, int top_tag) {
   WriteExtraTag(kDataJumpExtraTag, top_tag);
   for (int i = 0; i < kIntSize; i++) {
     *--pos_ = static_cast<byte>(data_delta);
     // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
     data_delta = data_delta >> kBitsPerByte;
   }
 }
 
+
+#if !defined(V8_TARGET_ARCH_X64)
 void RelocInfoWriter::WriteExtraTaggedConstPoolData(int data) {
   WriteExtraTag(kConstPoolExtraTag, kConstPoolTag);
   for (int i = 0; i < kIntSize; i++) {
     *--pos_ = static_cast<byte>(data);
     // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
     data = data >> kBitsPerByte;
   }
 }
+#else
+void RelocInfoWriter::WriteExtraTaggedDeoptEntryData(int data) {
+  WriteExtraTag(kDeoptEntryExtraTag, kDeoptEntryTag);
+  for (int i = 0; i < kIntSize; i++) {
+    *--pos_ = static_cast<byte>(data);
+    // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
+    data = data >> kBitsPerByte;
+  }
+}
+#endif
+
 
 void RelocInfoWriter::WriteExtraTaggedData(intptr_t data_delta, int top_tag) {
   WriteExtraTag(kDataJumpExtraTag, top_tag);
   for (int i = 0; i < kIntptrSize; i++) {
     *--pos_ = static_cast<byte>(data_delta);
     // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
     data_delta = data_delta >> kBitsPerByte;
   }
 }
 
@@ skipping 44 matching lines @@
       // Otherwise, use costly encoding.
       WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
       WriteExtraTaggedIntData(pos_delta, pos_type_tag);
     }
     last_position_ = static_cast<int>(rinfo->data());
   } else if (RelocInfo::IsComment(rmode)) {
     // Comments are normally not generated, so we use the costly encoding.
     WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
     WriteExtraTaggedData(rinfo->data(), kCommentTag);
     ASSERT(begin_pos - pos_ >= RelocInfo::kMinRelocCommentSize);
+#if !defined(V8_TARGET_ARCH_X64)
   } else if (RelocInfo::IsConstPool(rmode)) {
       WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
       WriteExtraTaggedConstPoolData(static_cast<int>(rinfo->data()));
+#else
+  } else if (RelocInfo::IsDeoptEntry(rmode)) {
+      WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
+      WriteExtraTaggedDeoptEntryData(static_cast<int>(rinfo->data()));
+#endif
   } else {
     ASSERT(rmode > RelocInfo::LAST_COMPACT_ENUM);
     int saved_mode = rmode - RelocInfo::LAST_COMPACT_ENUM;
     // For all other modes we simply use the mode as the extra tag.
     // None of these modes need a data component.
     ASSERT(saved_mode < kPCJumpExtraTag && saved_mode < kDataJumpExtraTag);
     WriteExtraTaggedPC(pc_delta, saved_mode);
   }
   last_pc_ = rinfo->pc();
 #ifdef DEBUG
@@ skipping 172 matching lines @@
             Advance(kIntSize);
           }
         } else {
           ASSERT(locatable_tag == kCommentTag);
           if (SetMode(RelocInfo::COMMENT)) {
             AdvanceReadData();
             return;
           }
           Advance(kIntptrSize);
         }
+#if !defined(V8_TARGET_ARCH_X64)
       } else if ((extra_tag == kConstPoolExtraTag) &&
                  (GetTopTag() == kConstPoolTag)) {
         if (SetMode(RelocInfo::CONST_POOL)) {
           AdvanceReadConstPoolData();
           return;
         }
         Advance(kIntSize);
+#else
+      } else if ((extra_tag == kDeoptEntryExtraTag) &&
+                 (GetTopTag() == kDeoptEntryTag)) {
+        if (SetMode(RelocInfo::DEOPT_ENTRY)) {
+          AdvanceReadConstPoolData();
+          return;
+        }
+        Advance(kIntSize);
+#endif
       } else {
         AdvanceReadPC();
         int rmode = extra_tag + RelocInfo::LAST_COMPACT_ENUM;
         if (SetMode(static_cast<RelocInfo::Mode>(rmode))) return;
       }
     }
   }
   if (code_age_sequence_ != NULL) {
     byte* old_code_age_sequence = code_age_sequence_;
     code_age_sequence_ = NULL;
@@ skipping 78 matching lines @@
     case RelocInfo::COMMENT:
       return "comment";
     case RelocInfo::POSITION:
       return "position";
     case RelocInfo::STATEMENT_POSITION:
       return "statement position";
     case RelocInfo::EXTERNAL_REFERENCE:
       return "external reference";
     case RelocInfo::INTERNAL_REFERENCE:
       return "internal reference";
+#if !defined(V8_TARGET_ARCH_X64)
     case RelocInfo::CONST_POOL:
       return "constant pool";
+#else
+    case RelocInfo::DEOPT_ENTRY:
+      return "deopt entry";
+#endif
     case RelocInfo::DEBUG_BREAK_SLOT:
 #ifndef ENABLE_DEBUGGER_SUPPORT
       UNREACHABLE();
 #endif
       return "debug break slot";
     case RelocInfo::CODE_AGE_SEQUENCE:
       return "code_age_sequence";
     case RelocInfo::NUMBER_OF_MODES:
       UNREACHABLE();
       return "number_of_modes";
@@ skipping 67 matching lines @@
       CHECK(code->address() == HeapObject::cast(found)->address());
       break;
     }
     case RUNTIME_ENTRY:
     case JS_RETURN:
     case COMMENT:
     case POSITION:
     case STATEMENT_POSITION:
     case EXTERNAL_REFERENCE:
     case INTERNAL_REFERENCE:
+#if !defined(V8_TARGET_ARCH_X64)
     case CONST_POOL:
+#else
+    case DEOPT_ENTRY:
+#endif
     case DEBUG_BREAK_SLOT:
     case NONE:
       break;
     case NUMBER_OF_MODES:
       UNREACHABLE();
       break;
     case CODE_AGE_SEQUENCE:
       ASSERT(Code::IsYoungSequence(pc_) || code_age_stub()->IsCode());
       break;
   }
@@ skipping 721 matching lines @@
     assembler_->RecordRelocInfo(RelocInfo::POSITION, state_.current_position);
     state_.written_position = state_.current_position;
     written = true;
   }
 
   // Return whether something was written.
   return written;
 }
 
 } }  // namespace v8::internal