ARM: Do not stack allocate big buffers in Assembler.

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 456 matching lines @@
   num_pending_32_bit_reloc_info_ = 0;
   num_pending_64_bit_reloc_info_ = 0;
   next_buffer_check_ = 0;
   const_pool_blocked_nesting_ = 0;
   no_const_pool_before_ = 0;
   first_const_pool_32_use_ = -1;
   first_const_pool_64_use_ = -1;
   last_bound_pos_ = 0;
   constant_pool_available_ = !FLAG_enable_ool_constant_pool;
   ClearRecordedAstId();
+  max_num_32_bit_reloc_info_ =

[Rodolph Perfetta, 2014/09/18 14:03:24]

This may not work. kMaxNumPending[32|64]RelocInfo were define as
LiteralPoolRange / InstructionSize so that you never need to check if you are
going to overflow the array of RelocInfo since the pool will be emitted before
that happens. There is no such guarantee now. And if buffer_size_ is bigger than
4k then we are wasting space.

+      Min(kMaxNumPending32RelocInfo, buffer_size_ / kInstrSize);
+  max_num_64_bit_reloc_info_ =
+      Min(kMaxNumPending64RelocInfo, buffer_size_ / kInstrSize);
+  pending_32_bit_reloc_info_ = NewArray<RelocInfo>(max_num_32_bit_reloc_info_);
+  pending_64_bit_reloc_info_ = NewArray<RelocInfo>(max_num_64_bit_reloc_info_);
 }
 
 
 Assembler::~Assembler() {
   DCHECK(const_pool_blocked_nesting_ == 0);
+  DeleteArray(pending_32_bit_reloc_info_);
+  DeleteArray(pending_64_bit_reloc_info_);
 }
 
 
 void Assembler::GetCode(CodeDesc* desc) {
   if (!FLAG_enable_ool_constant_pool) {
     // Emit constant pool if necessary.
     CheckConstPool(true, false);
     DCHECK(num_pending_32_bit_reloc_info_ == 0);
     DCHECK(num_pending_64_bit_reloc_info_ == 0);
   }
@@ skipping 2864 matching lines @@
   }
 }
 
 
 ConstantPoolArray::LayoutSection Assembler::ConstantPoolAddEntry(
     const RelocInfo& rinfo) {
   if (FLAG_enable_ool_constant_pool) {
     return constant_pool_builder_.AddEntry(this, rinfo);
   } else {
     if (rinfo.rmode() == RelocInfo::NONE64) {
-      DCHECK(num_pending_64_bit_reloc_info_ < kMaxNumPending64RelocInfo);
+      DCHECK(num_pending_64_bit_reloc_info_ < max_num_64_bit_reloc_info_);
       if (num_pending_64_bit_reloc_info_ == 0) {
         first_const_pool_64_use_ = pc_offset();
       }
       pending_64_bit_reloc_info_[num_pending_64_bit_reloc_info_++] = rinfo;
     } else {
-      DCHECK(num_pending_32_bit_reloc_info_ < kMaxNumPending32RelocInfo);
+      DCHECK(num_pending_32_bit_reloc_info_ < max_num_32_bit_reloc_info_);
       if (num_pending_32_bit_reloc_info_ == 0) {
         first_const_pool_32_use_ = pc_offset();
       }
       pending_32_bit_reloc_info_[num_pending_32_bit_reloc_info_++] = rinfo;
     }
     // Make sure the constant pool is not emitted in place of the next
     // instruction for which we just recorded relocation info.
     BlockConstPoolFor(1);
     return ConstantPoolArray::SMALL_SECTION;
   }
@@ skipping 452 matching lines @@
       assm->instr_at_put(
           rinfo.pc(), Assembler::SetLdrRegisterImmediateOffset(instr, offset));
     }
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM