ARM64: fix constant pool size used by disassembler

src/arm64/assembler-arm64.cc

 // Copyright 2013 the V8 project authors. 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.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
@@ skipping 629 matching lines @@
     return instr->ImmLLiteral();
   } else {
     return -1;
   }
 }
 
 
 void Assembler::ConstantPoolMarker(uint32_t size) {
   ASSERT(is_const_pool_blocked());
   // + 1 is for the crash guard.
-  Emit(LDR_x_lit | ImmLLiteral(2 * size + 1) | Rt(xzr));
+  Emit(LDR_x_lit | ImmLLiteral(size + 1) | Rt(xzr));
 }
 
 
 void Assembler::EmitPoolGuard() {
   // We must generate only one instruction as this is used in scopes that
   // control the size of the code generated.
   Emit(BLR | Rn(xzr));
 }
 
 
@@ skipping 1922 matching lines @@
   // Check that the code buffer is large enough before emitting the constant
   // pool (include the jump over the pool, the constant pool marker, the
   // constant pool guard, and the gap to the relocation information).
   while (buffer_space() <= needed_space) {
     GrowBuffer();
   }
 
   {
     // Block recursive calls to CheckConstPool and protect from veneer pools.
     BlockPoolsScope block_pools(this);
-    RecordComment("[ Constant Pool");
     RecordConstPool(pool_size);
 
     // Emit jump over constant pool if necessary.
     Label after_pool;
     if (require_jump) {
       b(&after_pool);
     }
 
     // Emit a constant pool header. The header has two goals:
     //  1) Encode the size of the constant pool, for use by the disassembler.
     //  2) Terminate the program, to try to prevent execution from accidentally
     //     flowing into the constant pool.
     // The header is therefore made of two arm64 instructions:
     //   ldr xzr, #<size of the constant pool in 32-bit words>
     //   blr xzr
     // If executed the code will likely segfault and lr will point to the
     // beginning of the constant pool.
     // TODO(all): currently each relocated constant is 64 bits, consider adding
     // support for 32-bit entries.
+    RecordComment("[ Constant Pool");
     ConstantPoolMarker(2 * num_pending_reloc_info_);
     ConstantPoolGuard();
 
     // Emit constant pool entries.
     for (int i = 0; i < num_pending_reloc_info_; i++) {
       RelocInfo& rinfo = pending_reloc_info_[i];
       ASSERT(rinfo.rmode() != RelocInfo::COMMENT &&
              rinfo.rmode() != RelocInfo::POSITION &&
              rinfo.rmode() != RelocInfo::STATEMENT_POSITION &&
              rinfo.rmode() != RelocInfo::CONST_POOL &&
@@ skipping 190 matching lines @@
 
 void Assembler::PopulateConstantPool(ConstantPoolArray* constant_pool) {
   // No out-of-line constant pool support.
   UNREACHABLE();
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM64