Contribution of PowerPC port (continuation of 422063005) - serialize.cc cleanup

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 249 matching lines @@
 //
 //  Long record format:
 //    4-bit middle_tag:
 //      0000 - 1100 : Short record for RelocInfo::Mode middle_tag + 2
 //         (The middle_tag encodes rmode - RelocInfo::LAST_COMPACT_ENUM,
 //          and is between 0000 and 1100)
 //        The format is:
 //                              00 [4 bit middle_tag] 11 followed by
 //                              00 [6 bit pc delta]
 //
-//      1101: constant or veneer pool. Used only on ARM and ARM64 for now.
+//      1101: arch1 or arch2 (architecture dependent)
 //        The format is:       [2-bit sub-type] 1101 11
-//                             signed int (size of the pool).
+//                             signed int (data).
 //          The 2-bit sub-types are:
-//            00: constant pool
-//            01: veneer pool
+//            00: arch1
+//            01: arch2
 //      1110: long_data_record
 //        The format is:       [2-bit data_type_tag] 1110 11
 //                             signed intptr_t, lowest byte written first
 //                             (except data_type code_target_with_id, which
 //                             is followed by a signed int, not intptr_t.)
 //
 //      1111: long_pc_jump
 //        The format is:
 //          pc-jump:             00 1111 11,
 //                               00 [6 bits pc delta]
@@ skipping 40 matching lines @@
 
 const int kCodeWithIdTag = 0;
 const int kNonstatementPositionTag = 1;
 const int kStatementPositionTag = 2;
 const int kCommentTag = 3;
 
 // Reuse the same value for deopt reason tag in short record format.
 // It is possible because we use kCommentTag only for the long record format.
 const int kDeoptReasonTag = 3;
 
-const int kPoolExtraTag = kPCJumpExtraTag - 2;
-const int kConstPoolTag = 0;
-const int kVeneerPoolTag = 1;
+const int kArchExtraTag = kPCJumpExtraTag - 2;
+const int kArch1Tag = 0;
+const int kArch2Tag = 1;
 
 
 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;
   DCHECK(pc_jump > 0);
@@ skipping 39 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;
   }
 }
 
 
-void RelocInfoWriter::WriteExtraTaggedPoolData(int data, int pool_type) {
-  WriteExtraTag(kPoolExtraTag, pool_type);
+void RelocInfoWriter::WriteExtraTaggedArchData(int data, int type) {
+  WriteExtraTag(kArchExtraTag, type);
   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;
   }
 }
 
 
 void RelocInfoWriter::WriteExtraTaggedData(intptr_t data_delta, int top_tag) {
   WriteExtraTag(kDataJumpExtraTag, top_tag);
@@ skipping 87 matching lines @@
         next_position_candidate_pos_delta_ += pos_delta;
       }
       next_position_candidate_flushed_ = false;
     }
     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);
     DCHECK(begin_pos - pos_ >= RelocInfo::kMinRelocCommentSize);
-  } else if (RelocInfo::IsConstPool(rmode) || RelocInfo::IsVeneerPool(rmode)) {
+  } else if (rmode == RelocInfo::ARCH1 || rmode == RelocInfo::ARCH2) {
       WriteExtraTaggedPC(pc_delta, kPCJumpExtraTag);
-      WriteExtraTaggedPoolData(static_cast<int>(rinfo->data()),
-                               RelocInfo::IsConstPool(rmode) ? kConstPoolTag
-                                                             : kVeneerPoolTag);
+      WriteExtraTaggedArchData(
+          static_cast<int>(rinfo->data()),
+          rmode == RelocInfo::ARCH1 ? kArch1Tag : kArch2Tag);
   } else {
     DCHECK(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.
-    DCHECK(saved_mode < kPoolExtraTag);
+    DCHECK(saved_mode < kArchExtraTag);
     WriteExtraTaggedPC(pc_delta, saved_mode);
   }
   last_pc_ = rinfo->pc();
   last_mode_ = rmode;
 #ifdef DEBUG
   DCHECK(begin_pos - pos_ <= kMaxSize);
 #endif
 }
 
 
@@ skipping 25 matching lines @@
 void RelocIterator::AdvanceReadId() {
   int x = 0;
   for (int i = 0; i < kIntSize; i++) {
     x |= static_cast<int>(*--pos_) << i * kBitsPerByte;
   }
   last_id_ += x;
   rinfo_.data_ = last_id_;
 }
 
 
-void RelocIterator::AdvanceReadPoolData() {
+void RelocIterator::AdvanceReadArchData() {
   int x = 0;
   for (int i = 0; i < kIntSize; i++) {
     x |= static_cast<int>(*--pos_) << i * kBitsPerByte;
   }
   rinfo_.data_ = x;
 }
 
 
 void RelocIterator::AdvanceReadPosition() {
   int x = 0;
@@ skipping 128 matching lines @@
             Advance(kIntSize);
           }
         } else {
           DCHECK(locatable_tag == kCommentTag);
           if (SetMode(RelocInfo::COMMENT)) {
             AdvanceReadData();
             return;
           }
           Advance(kIntptrSize);
         }
-      } else if (extra_tag == kPoolExtraTag) {
-        int pool_type = GetTopTag();
-        DCHECK(pool_type == kConstPoolTag || pool_type == kVeneerPoolTag);
-        RelocInfo::Mode rmode = (pool_type == kConstPoolTag) ?
-          RelocInfo::CONST_POOL : RelocInfo::VENEER_POOL;
+      } else if (extra_tag == kArchExtraTag) {
+        int type = GetTopTag();
+        DCHECK(type == kArch1Tag || type == kArch2Tag);
+        RelocInfo::Mode rmode =
+            (type == kArch1Tag) ? RelocInfo::ARCH1 : RelocInfo::ARCH2;
         if (SetMode(rmode)) {
-          AdvanceReadPoolData();
+          AdvanceReadArchData();
           return;
         }
         Advance(kIntSize);
       } else {
         AdvanceReadPC();
         int rmode = extra_tag + RelocInfo::LAST_COMPACT_ENUM;
         if (SetMode(static_cast<RelocInfo::Mode>(rmode))) return;
       }
     }
   }
@@ skipping 98 matching lines @@
     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";
     case RelocInfo::DEOPT_REASON:
       return "deopt reason";
+#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
     case RelocInfo::CONST_POOL:
       return "constant pool";
     case RelocInfo::VENEER_POOL:
       return "veneer pool";
+#elif V8_TARGET_ARCH_PPC || V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64
+    case RelocInfo::INTERNAL_REFERENCE_ENCODED:
+      return "internal reference (encoded)";
+    case RelocInfo::ARCH2:
+      UNREACHABLE();
+      return "arch2";
+#else
+    case RelocInfo::ARCH1:
+      UNREACHABLE();
+      return "arch1";
+    case RelocInfo::ARCH2:
+      UNREACHABLE();
+      return "arch2";
+#endif
     case RelocInfo::DEBUG_BREAK_SLOT:
       return "debug break slot";
     case RelocInfo::CODE_AGE_SEQUENCE:
       return "code_age_sequence";
     case RelocInfo::NUMBER_OF_MODES:
       UNREACHABLE();
       return "number_of_modes";
   }
   return "unknown relocation type";
 }
@@ skipping 62 matching lines @@
       break;
     }
     case RUNTIME_ENTRY:
     case JS_RETURN:
     case COMMENT:
     case POSITION:
     case STATEMENT_POSITION:
     case EXTERNAL_REFERENCE:
     case INTERNAL_REFERENCE:
     case DEOPT_REASON:
-    case CONST_POOL:
-    case VENEER_POOL:
+    case ARCH1:
+    case ARCH2:
     case DEBUG_BREAK_SLOT:
     case NONE32:
     case NONE64:
       break;
     case NUMBER_OF_MODES:
       UNREACHABLE();
       break;
     case CODE_AGE_SEQUENCE:
       DCHECK(Code::IsYoungSequence(isolate, pc_) || code_age_stub()->IsCode());
       break;
@@ skipping 748 matching lines @@
   RecordRelocInfo(RelocInfo::JS_RETURN);
 }
 
 
 void Assembler::RecordDebugBreakSlot() {
   positions_recorder()->WriteRecordedPositions();
   EnsureSpace ensure_space(this);
   RecordRelocInfo(RelocInfo::DEBUG_BREAK_SLOT);
 }
 } }  // namespace v8::internal