Consider reloc info mode when merging constant pool entries

src/assembler.h

 // 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 408 matching lines @@
     DEOPT_ID,      // Deoptimization inlining id.
 
     // This is not an actual reloc mode, but used to encode a long pc jump that
     // cannot be encoded as part of another record.
     PC_JUMP,
 
     // Pseudo-types
     NUMBER_OF_MODES,
     NONE32,             // never recorded 32-bit value
     NONE64,             // never recorded 64-bit value
+    NONEINTPTR,         // never recorded intptr value

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

Maybe highlight in the commit message that you're distinguishing this as an
rmode ? 

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

Done.

     CODE_AGE_SEQUENCE,  // Not stored in RelocInfo array, used explictly by
                         // code aging.
 
     FIRST_REAL_RELOC_MODE = CODE_TARGET,
     LAST_REAL_RELOC_MODE = VENEER_POOL,
     LAST_CODE_ENUM = DEBUGGER_STATEMENT,
     LAST_GCED_ENUM = WASM_MEMORY_SIZE_REFERENCE,
     FIRST_SHAREABLE_RELOC_MODE = CELL,
   };
 
@@ skipping 69 matching lines @@
   static inline bool IsDebugBreakSlotAtCall(Mode mode) {
     return mode == DEBUG_BREAK_SLOT_AT_CALL;
   }
   static inline bool IsDebugBreakSlotAtTailCall(Mode mode) {
     return mode == DEBUG_BREAK_SLOT_AT_TAIL_CALL;
   }
   static inline bool IsDebuggerStatement(Mode mode) {
     return mode == DEBUGGER_STATEMENT;
   }
   static inline bool IsNone(Mode mode) {
-    return mode == NONE32 || mode == NONE64;
+    return mode == NONE32 || mode == NONE64 || mode == NONEINTPTR;
   }
   static inline bool IsCodeAgeSequence(Mode mode) {
     return mode == CODE_AGE_SEQUENCE;
   }
   static inline bool IsGeneratorContinuation(Mode mode) {
     return mode == GENERATOR_CONTINUATION;
   }
   static inline bool IsWasmMemoryReference(Mode mode) {
     return mode == WASM_MEMORY_REFERENCE;
   }
@@ skipping 693 matching lines @@
   virtual bool NeedsDebugStepCheck() const { return true; }
 };
 
 
 // -----------------------------------------------------------------------------
 // Constant pool support
 
 class ConstantPoolEntry {
  public:
   ConstantPoolEntry() {}
-  ConstantPoolEntry(int position, intptr_t value, bool sharing_ok)
+  ConstantPoolEntry(int position, intptr_t value, bool sharing_ok,
+                    RelocInfo::Mode rmode)
       : position_(position),
         merged_index_(sharing_ok ? SHARING_ALLOWED : SHARING_PROHIBITED),
+        rmode_(rmode),
         value_(value) {}
   ConstantPoolEntry(int position, double value)
-      : position_(position), merged_index_(SHARING_ALLOWED), value64_(value) {}
+      : position_(position),
+        merged_index_(SHARING_ALLOWED),
+        rmode_(RelocInfo::NONE64),
+        value64_(value) {}
 
   int position() const { return position_; }
   bool sharing_ok() const { return merged_index_ != SHARING_PROHIBITED; }
   bool is_merged() const { return merged_index_ >= 0; }
   int merged_index(void) const {
     DCHECK(is_merged());
     return merged_index_;
   }
   void set_merged_index(int index) {
     merged_index_ = index;
     DCHECK(is_merged());
   }
   int offset(void) const {
     DCHECK(merged_index_ >= 0);
     return merged_index_;
   }
   void set_offset(int offset) {
     DCHECK(offset >= 0);
     merged_index_ = offset;
   }
   intptr_t value() const { return value_; }
   uint64_t value64() const { return bit_cast<uint64_t>(value64_); }
+  bool IntValueMayBeMergedWith(ConstantPoolEntry& other) const {
+    return rmode_ == other.rmode_ && value() == other.value();

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

Why not have this handle checking both the 32/64 case so the callsite doesn't
have to do it, which seems odd anyhow?

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

See my previous comment about the scope of this change. 

+  }
 
   enum Type { INTPTR, DOUBLE, NUMBER_OF_TYPES };
 
   static int size(Type type) {
     return (type == INTPTR) ? kPointerSize : kDoubleSize;
   }
 
   enum Access { REGULAR, OVERFLOWED };
 
  private:
   int position_;
   int merged_index_;
+  RelocInfo::Mode rmode_;
   union {
     intptr_t value_;
     double value64_;
   };
   enum { SHARING_PROHIBITED = -2, SHARING_ALLOWED = -1 };
 };
 
 
 // -----------------------------------------------------------------------------
 // Embedded constant pool support
 
 class ConstantPoolBuilder BASE_EMBEDDED {
  public:
   ConstantPoolBuilder(int ptr_reach_bits, int double_reach_bits);
 
   // Add pointer-sized constant to the embedded constant pool
-  ConstantPoolEntry::Access AddEntry(int position, intptr_t value,
-                                     bool sharing_ok) {
-    ConstantPoolEntry entry(position, value, sharing_ok);
+  ConstantPoolEntry::Access AddEntry(
+      int position, intptr_t value, bool sharing_ok,
+      RelocInfo::Mode rmode = RelocInfo::NONEINTPTR) {
+    ConstantPoolEntry entry(position, value, sharing_ok, rmode);
     return AddEntry(entry, ConstantPoolEntry::INTPTR);
   }
 
   // Add double constant to the embedded constant pool
   ConstantPoolEntry::Access AddEntry(int position, double value) {
     ConstantPoolEntry entry(position, value);
     return AddEntry(entry, ConstantPoolEntry::DOUBLE);
   }
 
   // Previews the access type required for the next new entry to be added.
@@ skipping 37 matching lines @@
     std::vector<ConstantPoolEntry> shared_entries;
   };
 
   Label emitted_label_;  // Records pc_offset of emitted pool
   PerTypeEntryInfo info_[ConstantPoolEntry::NUMBER_OF_TYPES];
 };
 
 }  // namespace internal
 }  // namespace v8
 #endif  // V8_ASSEMBLER_H_