Rearrange emit vs emitIAS. Wait till function is done before dumping text.

src/assembler.h

 //===- subzero/src/assembler.h - Integrated assembler -----------*- C++ -*-===//
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
@@ skipping 144 matching lines @@
 
   // When building the C++ tests, assertion code is enabled. To allow
   // asserting that the user of the assembler buffer has ensured the
   // capacity needed for emitting, we add a dummy method in non-debug mode.
   bool HasEnsuredCapacity() const { return true; }
 #endif // NDEBUG
 
   // Returns the position in the instruction stream.
   intptr_t GetPosition() const { return cursor_ - contents_; }
 
-  // For bringup only.
-  AssemblerFixup *GetLatestFixup(intptr_t position) const;
+  // List of pool-allocated fixups.
+  typedef std::vector<AssemblerFixup *> FixupList;
+  FixupList::const_iterator fixups_begin() const { return fixups_.begin(); }
+  FixupList::const_iterator fixups_end() const { return fixups_.end(); }
 
 private:
   // The limit is set to kMinimumGap bytes before the end of the data area.
   // This leaves enough space for the longest possible instruction and allows
   // for a single, fast space check per instruction.
   static const intptr_t kMinimumGap = 32;
 
   uintptr_t contents_;
   uintptr_t cursor_;
   uintptr_t limit_;
   Assembler &assembler_;
-  std::vector<AssemblerFixup *> fixups_;
+  FixupList fixups_;
 #ifndef NDEBUG
   bool fixups_processed_;
 #endif // !NDEBUG
 
   uintptr_t cursor() const { return cursor_; }
   uintptr_t limit() const { return limit_; }
   intptr_t Capacity() const {
     assert(limit_ >= contents_);
     return (limit_ - contents_) + kMinimumGap;
   }
@@ skipping 10 matching lines @@
   void ExtendCapacity();
 
   friend class AssemblerFixup;
 };
 
 class Assembler {
   Assembler(const Assembler &) = delete;
   Assembler &operator=(const Assembler &) = delete;
 
 public:
-  Assembler() {}
+  Assembler() : buffer_(*this) {}
   virtual ~Assembler() {}
 
   // Allocate a chunk of bytes using the per-Assembler allocator.
   uintptr_t AllocateBytes(size_t bytes) {
     // For now, alignment is not related to NaCl bundle alignment, since
     // the buffer's GetPosition is relative to the base. So NaCl bundle
     // alignment checks can be relative to that base. Later, the buffer
     // will be copied out to a ".text" section (or an in memory-buffer
     // that can be mprotect'ed with executable permission), and that
     // second buffer should be aligned for NaCl.
     const size_t Alignment = 16;
     return reinterpret_cast<uintptr_t>(Allocator.Allocate(bytes, Alignment));
   }
 
   // Allocate data of type T using the per-Assembler allocator.
   template <typename T> T *Allocate() { return Allocator.Allocate<T>(); }
 
   virtual void BindCfgNodeLabel(SizeT NodeNumber) = 0;
 
+  void emitIASBytes(GlobalContext *Ctx) const;
+
 private:
   llvm::BumpPtrAllocator Allocator;
+
+protected:
+  AssemblerBuffer buffer_;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ASSEMBLER_H_