[compiler] Delay allocation of code-embedded heap numbers.

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 17 matching lines @@
 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // The original source code covered by the above license above has been
 // modified significantly by Google Inc.
 // Copyright 2012 the V8 project authors. All rights reserved.
 
 #ifndef V8_ASSEMBLER_H_
 #define V8_ASSEMBLER_H_
 
+#include <forward_list>
+
 #include "src/allocation.h"
 #include "src/builtins/builtins.h"
 #include "src/deoptimize-reason.h"
 #include "src/globals.h"
 #include "src/isolate.h"
 #include "src/label.h"
 #include "src/log.h"
 #include "src/register-configuration.h"
 #include "src/runtime/runtime.h"
 
@@ skipping 92 matching lines @@
       constant_pool_available_ = available;
     } else {
       // Embedded constant pool not supported on this architecture.
       UNREACHABLE();
     }
   }
 
   // The program counter, which points into the buffer above and moves forward.
   byte* pc_;
 
+  // The following two functions help with avoiding allocations of heap numbers
+  // during the code assembly phase. {RequestHeapNumber} records the need for a
+  // future heap number allocation, together with the current pc offset. After
+  // code assembly, {AllocateRequestedHeapNumbers} will allocate these numbers
+  // and, with the help of {Assembler::set_heap_number}, place them where they
+  // are expected (determined by the recorded pc offset).
+  void RequestHeapNumber(double value) {
+    heap_numbers_.emplace_front(value, pc_offset());
+  }
+  void AllocateRequestedHeapNumbers(Isolate* isolate);
+
  private:
   IsolateData isolate_data_;
   uint64_t enabled_cpu_features_;
   bool emit_debug_code_;
   bool predictable_code_size_;
 
   // Indicates whether the constant pool can be accessed, which is only possible
   // if the pp register points to the current code object's constant pool.
   bool constant_pool_available_;
 
   // Constant pool.
   friend class FrameAndConstantPoolScope;
   friend class ConstantPoolUnavailableScope;
+
+  // Delayed allocation of heap numbers.
+  struct RequestedHeapNumber {
+    RequestedHeapNumber(double value, int offset);
+    double value;  // The number for which we later need to create a HeapObject.
+    int offset;  // The {buffer_} offset where we emitted a dummy that needs to
+                 // get replaced by the actual HeapObject via
+                 // {Assembler::set_heap_number}.
+  };
+  std::forward_list<RequestedHeapNumber> heap_numbers_;
 };
 
 
 // Avoids emitting debug code during the lifetime of this scope object.
 class DontEmitDebugCodeScope BASE_EMBEDDED {
  public:
   explicit DontEmitDebugCodeScope(AssemblerBase* assembler)
       : assembler_(assembler), old_value_(assembler->emit_debug_code()) {
     assembler_->set_emit_debug_code(false);
   }
@@ skipping 1088 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_