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 945 matching lines @@
   DCHECK(!emitted_label_.is_bound());
   PerTypeEntryInfo& info = info_[type];
   const int entry_size = ConstantPoolEntry::size(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()
+      if ((entry_size == kPointerSize) ? entry.IntValueMayBeMergedWith(*it)

[bradnelson, 2016/06/08 00:58:32]

It seems strange to use carnal knowledge of entry to decide which method to
call? Also, just because entry_size != kPointerSize, doesn't seem that means you
can merge mismatched relocation types. Or am I missing something?

[Mircea Trofin, 2016/06/08 03:32:16]

This is inherited (previous) code, and I agree, overall the logic here isn't
ideal. My goal was to initially just nudge the constant pool logic to support
categories of constants, and then try to clean this up, but it may be a small
enough additional change to do it now. Let me give it a go.

                                        : entry.value64() == it->value64()) {
         // Merge with found entry.
         entry.set_merged_index(i);
         merged = true;
         break;
       }
     }
   }
 
   // By definition, merged entries have regular access.
@@ skipping 172 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