Consider reloc info mode when merging constant pool entries

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 801 matching lines @@
 #endif
 
 
 #ifdef ENABLE_DISASSEMBLER
 const char* RelocInfo::RelocModeName(RelocInfo::Mode rmode) {
   switch (rmode) {
     case NONE32:
       return "no reloc 32";
     case NONE64:
       return "no reloc 64";
+    case NONEINTPTR:
+      return "no reloc intptr";
     case EMBEDDED_OBJECT:
       return "embedded object";
     case DEBUGGER_STATEMENT:
       return "debugger statement";
     case CODE_TARGET:
       return "code target";
     case CODE_TARGET_WITH_ID:
       return "code target with id";
     case CELL:
       return "property cell";
@@ skipping 127 matching lines @@
     case VENEER_POOL:
     case DEBUG_BREAK_SLOT_AT_POSITION:
     case DEBUG_BREAK_SLOT_AT_RETURN:
     case DEBUG_BREAK_SLOT_AT_CALL:
     case DEBUG_BREAK_SLOT_AT_TAIL_CALL:
     case GENERATOR_CONTINUATION:
     case WASM_MEMORY_REFERENCE:
     case WASM_MEMORY_SIZE_REFERENCE:
     case NONE32:
     case NONE64:
+    case NONEINTPTR:
       break;
     case NUMBER_OF_MODES:
     case PC_JUMP:
       UNREACHABLE();
       break;
     case CODE_AGE_SEQUENCE:
       DCHECK(Code::IsYoungSequence(isolate, pc_) || code_age_stub()->IsCode());
       break;
   }
 }
@@ skipping 932 matching lines @@
   } else {
     DCHECK(type == ConstantPoolEntry::INTPTR);
     if (!is_uintn(ptr_offset, info.regular_reach_bits)) {
       return ConstantPoolEntry::OVERFLOWED;
     }
   }
 
   return ConstantPoolEntry::REGULAR;
 }
 
-
 ConstantPoolEntry::Access ConstantPoolBuilder::AddEntry(
-    ConstantPoolEntry& entry, ConstantPoolEntry::Type type) {
+    ConstantPoolEntry& entry) {
   DCHECK(!emitted_label_.is_bound());
-  PerTypeEntryInfo& info = info_[type];
-  const int entry_size = ConstantPoolEntry::size(type);
+  PerTypeEntryInfo& info = info_[entry.type()];
   bool merged = false;
 
   if (entry.sharing_ok()) {
     // Try to merge entries
     std::vector<ConstantPoolEntry>::iterator it = info.shared_entries.begin();
     int end = static_cast<int>(info.shared_entries.size());
     for (int i = 0; i < end; i++, it++) {
-      if ((entry_size == kPointerSize) ? entry.value() == it->value()
-                                       : entry.value64() == it->value64()) {
+      if (entry.MayBeMergedWith(*it)) {
         // Merge with found entry.
         entry.set_merged_index(i);
         merged = true;
         break;
       }
     }
   }
 
   // By definition, merged entries have regular access.
   DCHECK(!merged || entry.merged_index() < info.regular_count);
   ConstantPoolEntry::Access access =
-      (merged ? ConstantPoolEntry::REGULAR : NextAccess(type));
+      (merged ? ConstantPoolEntry::REGULAR : NextAccess(entry.type()));
 
   // Enforce an upper bound on search time by limiting the search to
   // unique sharable entries which fit in the regular section.
   if (entry.sharing_ok() && !merged && access == ConstantPoolEntry::REGULAR) {
     info.shared_entries.push_back(entry);
   } else {
     info.entries.push_back(entry);
   }
 
   // We're done if we found a match or have already triggered the
   // overflow state.
   if (merged || info.overflow()) return access;
 
   if (access == ConstantPoolEntry::REGULAR) {
     info.regular_count++;
   } else {
     info.overflow_start = static_cast<int>(info.entries.size()) - 1;
   }
 
   return access;
 }
 
 
 void ConstantPoolBuilder::EmitSharedEntries(Assembler* assm,
                                             ConstantPoolEntry::Type type) {
   PerTypeEntryInfo& info = info_[type];
   std::vector<ConstantPoolEntry>& shared_entries = info.shared_entries;
-  const int entry_size = ConstantPoolEntry::size(type);
+  const int entry_size = ConstantPoolEntry::SizeOfType(type);
   int base = emitted_label_.pos();
   DCHECK(base > 0);
   int shared_end = static_cast<int>(shared_entries.size());
   std::vector<ConstantPoolEntry>::iterator shared_it = shared_entries.begin();
   for (int i = 0; i < shared_end; i++, shared_it++) {
     int offset = assm->pc_offset() - base;
     shared_it->set_offset(offset);  // Save offset for merged entries.
     if (entry_size == kPointerSize) {
       assm->dp(shared_it->value());
     } else {
       assm->dq(shared_it->value64());
     }
     DCHECK(is_uintn(offset, info.regular_reach_bits));
 
     // Patch load sequence with correct offset.
     assm->PatchConstantPoolAccessInstruction(shared_it->position(), offset,
                                              ConstantPoolEntry::REGULAR, type);
   }
 }
 
 
 void ConstantPoolBuilder::EmitGroup(Assembler* assm,
                                     ConstantPoolEntry::Access access,
                                     ConstantPoolEntry::Type type) {
   PerTypeEntryInfo& info = info_[type];
   const bool overflow = info.overflow();
   std::vector<ConstantPoolEntry>& entries = info.entries;
   std::vector<ConstantPoolEntry>& shared_entries = info.shared_entries;
-  const int entry_size = ConstantPoolEntry::size(type);
+  const int entry_size = ConstantPoolEntry::SizeOfType(type);
   int base = emitted_label_.pos();
   DCHECK(base > 0);
   int begin;
   int end;
 
   if (access == ConstantPoolEntry::REGULAR) {
     // Emit any shared entries first
     EmitSharedEntries(assm, type);
   }
 
@@ skipping 102 matching lines @@
 
 
 void Assembler::DataAlign(int m) {
   DCHECK(m >= 2 && base::bits::IsPowerOfTwo32(m));
   while ((pc_offset() & (m - 1)) != 0) {
     db(0);
   }
 }
 }  // namespace internal
 }  // namespace v8