Refactor FrameAndConstantPoolScope and ConstantPoolUnavailableScope to be architecture independent

src/arm64/assembler-arm64.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ARM64_ASSEMBLER_ARM64_H_
 #define V8_ARM64_ASSEMBLER_ARM64_H_
 
 #include <list>
 #include <map>
 #include <vector>
@@ skipping 1877 matching lines @@
 
   // Check if is time to emit a constant pool.
   void CheckConstPool(bool force_emit, bool require_jump);
 
   // Allocate a constant pool of the correct size for the generated code.
   Handle<ConstantPoolArray> NewConstantPool(Isolate* isolate);
 
   // Generate the constant pool for the generated code.
   void PopulateConstantPool(ConstantPoolArray* constant_pool);
 
+  bool is_constant_pool_available() const {
+    // Constant pool is not supported on arm64.
+    UNREACHABLE();
+    return false;
+  }
+

[rmcilroy, 2014/10/02 15:01:37]

I think we should put both  is_constant_pool_available() and
set_constant_pool_available(bool available) in BaseAssembler instead rather than
copying to all architectures. Could you rename to is_ool_constant_pool_available
/ set_ool_constant_pool_available to be clear then make the code:

 bool is_ool_constant_pool_available() const {
   if (FLAG_enable_ool_constant_pool) {
     return ool_constant_pool_available_;
   } else {
     // Out-of-line constant pool not supported on this architecture.
     UNREACHABLE();
     return false;
   }
 }

and similar for set_constant_pool_available.

[baixo, 2014/10/09 09:08:14]

Done.

   // Returns true if we should emit a veneer as soon as possible for a branch
   // which can at most reach to specified pc.
   bool ShouldEmitVeneer(int max_reachable_pc,
                         int margin = kVeneerDistanceMargin);
   bool ShouldEmitVeneers(int margin = kVeneerDistanceMargin) {
     return ShouldEmitVeneer(unresolved_branches_first_limit(), margin);
   }
 
   // The maximum code size generated for a veneer. Currently one branch
   // instruction. This is for code size checking purposes, and can be extended
@@ skipping 97 matching lines @@
     const CPURegister& rt, const CPURegister& rt2);
   static inline LoadLiteralOp LoadLiteralOpFor(const CPURegister& rt);
 
   // Remove the specified branch from the unbound label link chain.
   // If available, a veneer for this label can be used for other branches in the
   // chain if the link chain cannot be fixed up without this branch.
   void RemoveBranchFromLabelLinkChain(Instruction* branch,
                                       Label* label,
                                       Instruction* label_veneer = NULL);
 
+  void set_constant_pool_available(bool available) {
+    // Constant pool is not supported on arm64.
+    UNREACHABLE();
+  }
+
+

[rmcilroy, 2014/10/02 15:01:37]

nit - remove extra newline.

[baixo, 2014/10/09 09:08:14]

Done.

  private:
   // Instruction helpers.
   void MoveWide(const Register& rd,
                 uint64_t imm,
                 int shift,
                 MoveWideImmediateOp mov_op);
   void DataProcShiftedRegister(const Register& rd,
                                const Register& rn,
                                const Operand& operand,
                                FlagsUpdate S,
@@ skipping 216 matching lines @@
   // the label chain, and for each PC-relative instruction in the chain checking
   // if pending unresolved information exists. Its complexity is proportional to
   // the length of the label chain.
   void DeleteUnresolvedBranchInfoForLabelTraverse(Label* label);
 
  private:
   PositionsRecorder positions_recorder_;
   friend class PositionsRecorder;
   friend class EnsureSpace;
   friend class ConstPool;
+
+  // constant pool

[rmcilroy, 2014/10/02 15:01:37]

These should move to BaseAssembler if you
is_constant_pool_available/set_constant_pool_available there as in my comment
above.

[baixo, 2014/10/09 09:08:14]

Done.

+  friend class FrameAndConstantPoolScope;
+  friend class ConstantPoolUnavailableScope;
 };
 
 class PatchingAssembler : public Assembler {
  public:
   // Create an Assembler with a buffer starting at 'start'.
   // The buffer size is
   //   size of instructions to patch + kGap
   // Where kGap is the distance from which the Assembler tries to grow the
   // buffer.
   // If more or fewer instructions than expected are generated or if some
@@ skipping 35 matching lines @@
 class EnsureSpace BASE_EMBEDDED {
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBufferSpace();
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_ASSEMBLER_ARM64_H_