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

src/assembler.cpp

 //===- subzero/src/assembler.cpp - Assembler base class -------------------===//
 // 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
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Assembler class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "assembler.h"
+#include "IceGlobalContext.h"
 #include "IceMemoryRegion.h"
+#include "IceOperand.h"
 
 namespace Ice {
 
 static uintptr_t NewContents(Assembler &assembler, intptr_t capacity) {
   uintptr_t result = assembler.AllocateBytes(capacity);
   return result;
 }
 
 #ifndef NDEBUG
 AssemblerBuffer::EnsureCapacity::EnsureCapacity(AssemblerBuffer *buffer) {
@@ skipping 34 matching lines @@
   fixups_processed_ = false;
 #endif // !NDEBUG
 
   // Verify internal state.
   assert(Capacity() == kInitialBufferCapacity);
   assert(Size() == 0);
 }
 
 AssemblerBuffer::~AssemblerBuffer() {}
 
-// Returns the latest fixup at or after the given position, or nullptr if
-// there is none.  Assumes fixups were added in increasing order.
-AssemblerFixup *AssemblerBuffer::GetLatestFixup(intptr_t position) const {
-  AssemblerFixup *latest_fixup = nullptr;
-  for (auto I = fixups_.rbegin(), E = fixups_.rend(); I != E; ++I) {
-    if ((*I)->position() < position)
-      return latest_fixup;
-    latest_fixup = *I;
-  }
-  return latest_fixup;
-}
-
 void AssemblerBuffer::ProcessFixups(const MemoryRegion &region) {
   for (SizeT I = 0; I < fixups_.size(); ++I) {
     AssemblerFixup *fixup = fixups_[I];
     fixup->Process(region, fixup->position());
   }
 }
 
 void AssemblerBuffer::FinalizeInstructions(const MemoryRegion &instructions) {
   // Copy the instructions from the buffer.
   MemoryRegion from(reinterpret_cast<void *>(contents()), Size());
@@ skipping 27 matching lines @@
 
   // Update the cursor and recompute the limit.
   cursor_ += delta;
   limit_ = ComputeLimit(new_contents, new_capacity);
 
   // Verify internal state.
   assert(Capacity() == new_capacity);
   assert(Size() == old_size);
 }
 
+void Assembler::emitIASBytes(GlobalContext *Ctx) const {
+  Ostream &Str = Ctx->getStrEmit();
+  intptr_t EndPosition = buffer_.Size();
+  intptr_t CurPosition = 0;
+  const intptr_t FixupSize = 4;
+  for (AssemblerBuffer::FixupList::const_iterator
+           FixupI = buffer_.fixups_begin(),
+           FixupE = buffer_.fixups_end(); FixupI != FixupE; ++FixupI) {
+    AssemblerFixup *NextFixup = *FixupI;
+    intptr_t NextFixupLoc = NextFixup->position();
+    for (intptr_t i = CurPosition; i < NextFixupLoc; ++i) {
+      Str << "\t.byte 0x";
+      Str.write_hex(buffer_.Load<uint8_t>(i));
+      Str << "\n";
+    }
+    Str << "\t.long ";
+    const ConstantRelocatable *Reloc = NextFixup->value();
+    if (Reloc->getSuppressMangling())
+      Str << Reloc->getName();
+    else
+      Str << Ctx->mangleName(Reloc->getName());
+    if (Reloc->getOffset()) {
+      Str << " + " << Reloc->getOffset();
+    }
+    bool IsPCRel = NextFixup->kind() == FK_PcRel_4;
+    if (IsPCRel)
+      Str << " - (. + " << FixupSize << ")";
+    Str << "\n";
+    CurPosition = NextFixupLoc + FixupSize;
+    assert(CurPosition <= EndPosition);
+  }
+  // Handle any bytes that are not prefixed by a fixup.
+  for (intptr_t i = CurPosition; i < EndPosition; ++i) {
+    Str << "\t.byte 0x";
+    Str.write_hex(buffer_.Load<uint8_t>(i));
+    Str << "\n";
+  }
+}
+
 } // end of namespace Ice