Make sure the constant pool size is as promised.

src/arm/assembler-arm.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 3767 matching lines @@
 
   int needed_space = size + kGap;
   while (buffer_space() <= needed_space) GrowBuffer();
 
   {
     // Block recursive calls to CheckConstPool.
     BlockConstPoolScope block_const_pool(this);
     RecordComment("[ Constant Pool");
     RecordConstPool(size);
 
+    Label size_check;
+    bind(&size_check);
+
     // Emit jump over constant pool if necessary.
     Label after_pool;
     if (require_jump) {
       b(&after_pool);
     }
 
     // Put down constant pool marker "Undefined instruction".
     // The data size helps disassembly know what to print.
     emit(kConstantPoolMarker |
          EncodeConstantPoolLength(size_after_marker / kPointerSize));
 
     if (require_64_bit_align) {
       emit(kConstantPoolMarker);
     }
 
     // Emit 64-bit constant pool entries first: their range is smaller than
     // 32-bit entries.
     for (int i = 0; i < num_pending_64_bit_constants_; i++) {
       ConstantPoolEntry& entry = pending_64_bit_constants_[i];
 
       DCHECK(!((uintptr_t)pc_ & 0x7));  // Check 64-bit alignment.
 
       Instr instr = instr_at(entry.position());
       // Instruction to patch must be 'vldr rd, [pc, #offset]' with offset == 0.
       DCHECK((IsVldrDPcImmediateOffset(instr) &&
               GetVldrDRegisterImmediateOffset(instr) == 0));
 
       int delta = pc_offset() - entry.position() - kPcLoadDelta;
       DCHECK(is_uint10(delta));
-
-      bool found = false;
-      uint64_t value = entry.value64();
-      for (int j = 0; j < i; j++) {
-        ConstantPoolEntry& entry2 = pending_64_bit_constants_[j];
-        if (value == entry2.value64()) {
-          found = true;
-          Instr instr2 = instr_at(entry2.position());
-          DCHECK(IsVldrDPcImmediateOffset(instr2));
-          delta = GetVldrDRegisterImmediateOffset(instr2);
-          delta += entry2.position() - entry.position();
-          break;
-        }
-      }
-
       instr_at_put(entry.position(),
                    SetVldrDRegisterImmediateOffset(instr, delta));
-
-      if (!found) {
-        dq(entry.value64());
-      }
+      dq(entry.value64());
     }
 
     // Emit 32-bit constant pool entries.
     for (int i = 0; i < num_pending_32_bit_constants_; i++) {
       ConstantPoolEntry& entry = pending_32_bit_constants_[i];
       Instr instr = instr_at(entry.position());
 
       // 64-bit loads shouldn't get here.
       DCHECK(!IsVldrDPcImmediateOffset(instr));
 
       if (IsLdrPcImmediateOffset(instr) &&
           GetLdrRegisterImmediateOffset(instr) == 0) {
         int delta = pc_offset() - entry.position() - kPcLoadDelta;
         DCHECK(is_uint12(delta));
         // 0 is the smallest delta:
         //   ldr rd, [pc, #0]
         //   constant pool marker
         //   data
-
-        bool found = false;
-        if (entry.sharing_ok()) {
-          for (int j = 0; j < i; j++) {

[rmcilroy, 2015/07/02 13:59:48]

By removing this sharing you are going to increase the size of the generated Arm
code which is not ideal (especially considering we are trying all we can to
reduce heap usage on Android). Is there another way we could deal with the
duplicates (e.g., having some way for the debugger to estimate the size of the
constant pool ahead of time?).

Happy to VC about this if it helps.

-            ConstantPoolEntry& entry2 = pending_32_bit_constants_[j];
-
-            if (entry2.value() == entry.value()) {
-              Instr instr2 = instr_at(entry2.position());
-              if (IsLdrPcImmediateOffset(instr2)) {
-                delta = GetLdrRegisterImmediateOffset(instr2);
-                delta += entry2.position() - entry.position();
-                found = true;
-                break;
-              }
-            }
-          }
-        }
-
         instr_at_put(entry.position(),
                      SetLdrRegisterImmediateOffset(instr, delta));
-
-        if (!found) {
-          emit(entry.value());
-        }
+        emit(entry.value());
       } else {
         DCHECK(IsMovW(instr));
       }
     }
 
     num_pending_32_bit_constants_ = 0;
     num_pending_64_bit_constants_ = 0;
     first_const_pool_32_use_ = -1;
     first_const_pool_64_use_ = -1;
 
     RecordComment("]");
 
+    DCHECK_EQ(size, SizeOfCodeGeneratedSince(&size_check));
+
     if (after_pool.is_linked()) {
       bind(&after_pool);
     }
   }
 
   // Since a constant pool was just emitted, move the check offset forward by
   // the standard interval.
   next_buffer_check_ = pc_offset() + kCheckPoolInterval;
 }
 
@@ skipping 49 matching lines @@
     DCHECK(is_uint12(offset));
     instr_at_put(pc, SetLdrRegisterImmediateOffset(instr, offset));
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM