Change RelocInfo to write 64-bit data field on x64 architecture.

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 73 matching lines @@
 //                     00 [6 bits pc delta]
 //
 // pc-jump:            00 1111 11,
 //                     00 [6 bits pc delta]
 //
 // pc-jump:            01 1111 11,
 // (variable length)   7 - 26 bit pc delta, written in chunks of 7
 //                     bits, the lowest 7 bits written first.
 //
 // data-jump + pos:    00 1110 11,
-//                     signed int, lowest byte written first
+//                     signed intptr_t, lowest byte written first
 //
 // data-jump + st.pos: 01 1110 11,
-//                     signed int, lowest byte written first
+//                     signed intptr_t, lowest byte written first
 //
 // data-jump + comm.:  10 1110 11,
-//                     signed int, lowest byte written first
+//                     signed intptr_t, lowest byte written first
 //
 const int kMaxRelocModes = 14;
 
 const int kTagBits = 2;
 const int kTagMask = (1 << kTagBits) - 1;
 const int kExtraTagBits = 4;
 const int kPositionTypeTagBits = 1;
 const int kSmallDataBits = kBitsPerByte - kPositionTypeTagBits;
 
 const int kEmbeddedObjectTag = 0;
@@ skipping 41 matching lines @@
 }
 
 
 void RelocInfoWriter::WriteTaggedPC(uint32_t pc_delta, int tag) {
   // Write a byte of tagged pc-delta, possibly preceded by var. length pc-jump.
   pc_delta = WriteVariableLengthPCJump(pc_delta);
   *--pos_ = pc_delta << kTagBits | tag;
 }
 
 
-void RelocInfoWriter::WriteTaggedData(int32_t data_delta, int tag) {
+void RelocInfoWriter::WriteTaggedData(intptr_t data_delta, int tag) {
   *--pos_ = data_delta << kPositionTypeTagBits | tag;
 }
 
 
 void RelocInfoWriter::WriteExtraTag(int extra_tag, int top_tag) {
   *--pos_ = top_tag << (kTagBits + kExtraTagBits) |
             extra_tag << kTagBits |
             kDefaultTag;
 }
 
 
 void RelocInfoWriter::WriteExtraTaggedPC(uint32_t pc_delta, int extra_tag) {
   // Write two-byte tagged pc-delta, possibly preceded by var. length pc-jump.
   pc_delta = WriteVariableLengthPCJump(pc_delta);
   WriteExtraTag(extra_tag, 0);
   *--pos_ = pc_delta;
 }
 
 
-void RelocInfoWriter::WriteExtraTaggedData(int32_t data_delta, int top_tag) {
+void RelocInfoWriter::WriteExtraTaggedData(intptr_t data_delta, int top_tag) {
   WriteExtraTag(kDataJumpTag, top_tag);
-  for (int i = 0; i < kIntSize; i++) {
+  for (int i = 0; i < kIntptrSize; i++) {
     *--pos_ = data_delta;
-    data_delta = ArithmeticShiftRight(data_delta, kBitsPerByte);
+  // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
+    data_delta = data_delta >> kBitsPerByte;
   }
 }
 
 
 void RelocInfoWriter::Write(const RelocInfo* rinfo) {
 #ifdef DEBUG
   byte* begin_pos = pos_;
 #endif
   Counters::reloc_info_count.Increment();
   ASSERT(rinfo->pc() - last_pc_ >= 0);
   ASSERT(RelocInfo::NUMBER_OF_MODES < kMaxRelocModes);
   // Use unsigned delta-encoding for pc.
   uint32_t pc_delta = rinfo->pc() - last_pc_;
   RelocInfo::Mode rmode = rinfo->rmode();
 
   // The two most common modes are given small tags, and usually fit in a byte.
   if (rmode == RelocInfo::EMBEDDED_OBJECT) {
     WriteTaggedPC(pc_delta, kEmbeddedObjectTag);
   } else if (rmode == RelocInfo::CODE_TARGET) {
     WriteTaggedPC(pc_delta, kCodeTargetTag);
   } else if (RelocInfo::IsPosition(rmode)) {
     // Use signed delta-encoding for data.
-    int32_t data_delta = rinfo->data() - last_data_;
+    intptr_t data_delta = rinfo->data() - last_data_;
     int pos_type_tag = rmode == RelocInfo::POSITION ? kNonstatementPositionTag
                                                     : kStatementPositionTag;
     // Check if data is small enough to fit in a tagged byte.
-    if (is_intn(data_delta, kSmallDataBits)) {
+    // We cannot use is_intn because data_delta is not an int32_t.
+    if (data_delta >= -(1 << (kSmallDataBits-1)) &&
+        data_delta < 1 << (kSmallDataBits-1)) {
       WriteTaggedPC(pc_delta, kPositionTag);
       WriteTaggedData(data_delta, pos_type_tag);
       last_data_ = rinfo->data();
     } else {
       // Otherwise, use costly encoding.
       WriteExtraTaggedPC(pc_delta, kPCJumpTag);
       WriteExtraTaggedData(data_delta, pos_type_tag);
       last_data_ = rinfo->data();
     }
   } else if (RelocInfo::IsComment(rmode)) {
@@ skipping 33 matching lines @@
   rinfo_.pc_ += *pos_ >> kTagBits;
 }
 
 
 inline void RelocIterator::AdvanceReadPC() {
   rinfo_.pc_ += *--pos_;
 }
 
 
 void RelocIterator::AdvanceReadData() {
-  int32_t x = 0;
-  for (int i = 0; i < kIntSize; i++) {
-    x |= *--pos_ << i * kBitsPerByte;
+  intptr_t x = 0;
+  for (int i = 0; i < kIntptrSize; i++) {
+    x |= static_cast<intptr_t>(*--pos_) << i * kBitsPerByte;
   }
   rinfo_.data_ += x;
 }
 
 
 void RelocIterator::AdvanceReadVariableLengthPCJump() {
   // Read the 32-kSmallPCDeltaBits most significant bits of the
   // pc jump in kChunkBits bit chunks and shift them into place.
   // Stop when the last chunk is encountered.
   uint32_t pc_jump = 0;
   for (int i = 0; i < kIntSize; i++) {
     byte pc_jump_part = *--pos_;
     pc_jump |= (pc_jump_part >> kLastChunkTagBits) << i * kChunkBits;
     if ((pc_jump_part & kLastChunkTagMask) == 1) break;
   }
   // The least significant kSmallPCDeltaBits bits will be added
   // later.
   rinfo_.pc_ += pc_jump << kSmallPCDeltaBits;
 }
 
 
 inline int RelocIterator::GetPositionTypeTag() {
   return *pos_ & ((1 << kPositionTypeTagBits) - 1);
 }
 
 
 inline void RelocIterator::ReadTaggedData() {
   int8_t signed_b = *pos_;
-  rinfo_.data_ += ArithmeticShiftRight(signed_b, kPositionTypeTagBits);
+  // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
+  rinfo_.data_ += signed_b >> kPositionTypeTagBits;
 }
 
 
 inline RelocInfo::Mode RelocIterator::DebugInfoModeFromTag(int tag) {
   if (tag == kStatementPositionTag) {
     return RelocInfo::STATEMENT_POSITION;
   } else if (tag == kNonstatementPositionTag) {
     return RelocInfo::POSITION;
   } else {
     ASSERT(tag == kCommentTag);
@@ skipping 310 matching lines @@
   return ExternalReference(FUNCTION_ADDR(Debug::Break));
 }
 
 
 ExternalReference ExternalReference::debug_step_in_fp_address() {
   return ExternalReference(Debug::step_in_fp_addr());
 }
 #endif
 
 } }  // namespace v8::internal