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
     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),
+        type_(INTPTR),
         value_(value) {}
   ConstantPoolEntry(int position, double value)
-      : position_(position), merged_index_(SHARING_ALLOWED), value64_(value) {}
+      : position_(position),
+        merged_index_(SHARING_ALLOWED),
+        rmode_(RelocInfo::NONE64),
+        type_(DOUBLE),
+        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 MayBeMergedWith(ConstantPoolEntry& other) const {
+    return type_ == other.type_ && rmode_ == other.rmode_ &&
+           (type_ == INTPTR ? value() == other.value()
+                            : value64() == other.value64());
+  }
 
   enum Type { INTPTR, DOUBLE, NUMBER_OF_TYPES };
 
-  static int size(Type type) {
+  Type type() const { return type_; }
+
+  static int SizeOfType(Type type) {
     return (type == INTPTR) ? kPointerSize : kDoubleSize;
   }
 
+  int size() const { return SizeOfType(type_); }
+
   enum Access { REGULAR, OVERFLOWED };
 
  private:
   int position_;
   int merged_index_;
+  RelocInfo::Mode rmode_;
+  Type type_;
   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);
-    return AddEntry(entry, ConstantPoolEntry::INTPTR);
+  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);
   }
 
   // Add double constant to the embedded constant pool
   ConstantPoolEntry::Access AddEntry(int position, double value) {
     ConstantPoolEntry entry(position, value);
-    return AddEntry(entry, ConstantPoolEntry::DOUBLE);
+    return AddEntry(entry);
   }
 
   // Previews the access type required for the next new entry to be added.
   ConstantPoolEntry::Access NextAccess(ConstantPoolEntry::Type type) const;
 
   bool IsEmpty() {
     return info_[ConstantPoolEntry::INTPTR].entries.empty() &&
            info_[ConstantPoolEntry::INTPTR].shared_entries.empty() &&
            info_[ConstantPoolEntry::DOUBLE].entries.empty() &&
            info_[ConstantPoolEntry::DOUBLE].shared_entries.empty();
   }
 
   // Emit the constant pool.  Invoke only after all entries have been
   // added and all instructions have been emitted.
   // Returns position of the emitted pool (zero implies no constant pool).
   int Emit(Assembler* assm);
 
   // Returns the label associated with the start of the constant pool.
   // Linking to this label in the function prologue may provide an
   // efficient means of constant pool pointer register initialization
   // on some architectures.
   inline Label* EmittedPosition() { return &emitted_label_; }
 
  private:
-  ConstantPoolEntry::Access AddEntry(ConstantPoolEntry& entry,
-                                     ConstantPoolEntry::Type type);
+  ConstantPoolEntry::Access AddEntry(ConstantPoolEntry& entry);
   void EmitSharedEntries(Assembler* assm, ConstantPoolEntry::Type type);
   void EmitGroup(Assembler* assm, ConstantPoolEntry::Access access,
                  ConstantPoolEntry::Type type);
 
   struct PerTypeEntryInfo {
     PerTypeEntryInfo() : regular_count(0), overflow_start(-1) {}
     bool overflow() const {
       return (overflow_start >= 0 &&
               overflow_start < static_cast<int>(entries.size()));
     }
     int regular_reach_bits;
     int regular_count;
     int overflow_start;
     std::vector<ConstantPoolEntry> entries;
     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_