A64: Remove Assembler::finalized_ flag and logic

src/a64/assembler-a64.h

 // 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
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 683 matching lines @@
   // If the provided buffer is NULL, the assembler allocates and grows its own
   // buffer, and buffer_size determines the initial buffer size. The buffer is
   // owned by the assembler and deallocated upon destruction of the assembler.
   //
   // If the provided buffer is not NULL, the assembler uses the provided buffer
   // for code generation and assumes its size to be buffer_size. If the buffer
   // is too small, a fatal error occurs. No deallocation of the buffer is done
   // upon destruction of the assembler.
   Assembler(Isolate* arg_isolate, void* buffer, int buffer_size);
 
-  // The default destructor asserts that one of the following is true:
-  //  * The Assembler object has not been used.
-  //  * Nothing has been emitted since the last Reset() call.
-  //  * Nothing has been emitted since the last GetCode() call.
   virtual ~Assembler();
 
   // System functions ---------------------------------------------------------
   // Start generating code from the beginning of the buffer, discarding any code
   // and data that has already been emitted into the buffer.
   //
   // In order to avoid any accidental transfer of state, Reset ASSERTs that the
   // constant pool is not blocked.
   void Reset();
 
@@ skipping 1157 matching lines @@
   // Postpone the generation of the constant pool for the specified number of
   // instructions.
   void BlockConstPoolFor(int instructions);
 
   // Emit the instruction at pc_.
   void Emit(Instr instruction) {
     STATIC_ASSERT(sizeof(*pc_) == 1);
     STATIC_ASSERT(sizeof(instruction) == kInstructionSize);
     ASSERT((pc_ + sizeof(instruction)) <= (buffer_ + buffer_size_));
 
-#ifdef DEBUG
-    finalized_ = false;
-#endif
-
     memcpy(pc_, &instruction, sizeof(instruction));
     pc_ += sizeof(instruction);
     CheckBuffer();
   }
 
   // Emit data inline in the instruction stream.
   void EmitData(void const * data, unsigned size) {
     ASSERT(sizeof(*pc_) == 1);
     ASSERT((pc_ + size) <= (buffer_ + buffer_size_));
 
-#ifdef DEBUG
-    finalized_ = false;
-#endif
-
     // TODO(all): Somehow register we have some data here. Then we can
     // disassemble it correctly.
     memcpy(pc_, data, size);
     pc_ += size;
     CheckBuffer();
   }
 
   void GrowBuffer();
   void CheckBuffer();
 
@@ skipping 74 matching lines @@
   }
 
   // Code generation
   // The relocation writer's position is at least kGap bytes below the end of
   // the generated instructions. This is so that multi-instruction sequences do
   // not have to check for overflow. The same is true for writes of large
   // relocation info entries, and debug strings encoded in the instruction
   // stream.
   static const int kGap = 128;
 
-#ifdef DEBUG
-  bool finalized_;
-#endif
-
  private:
   // TODO(jbramley): VIXL uses next_literal_pool_check_ and
   // literal_pool_monitor_ to determine when to consider emitting a literal
   // pool. V8 doesn't use them, so they should either not be here at all, or
   // should replace or be merged with next_buffer_check_ and
   // const_pool_blocked_nesting_.
   Instruction* next_literal_pool_check_;
   unsigned literal_pool_monitor_;
 
   PositionsRecorder positions_recorder_;
@@ skipping 29 matching lines @@
     // Const pool should still be blocked.
     ASSERT(is_const_pool_blocked());
     EndBlockConstPool();
     // Verify we have generated the number of instruction we expected.
     ASSERT((pc_offset() + kGap) == buffer_size_);
     // Verify no relocation information has been emitted.
     ASSERT(num_pending_reloc_info() == 0);
     // Flush the Instruction cache.
     size_t length = buffer_size_ - kGap;
     CPU::FlushICache(buffer_, length);
-
-#ifdef DEBUG
-    // The Patching Assembler doesn't need to be finalized, but the Assembler
-    // class's destructor will check the finalized_ flag.
-    finalized_ = true;
-#endif
   }
 };
 
 
 class EnsureSpace BASE_EMBEDDED {
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBuffer();
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_A64_ASSEMBLER_A64_H_