Subzero: Support multiple fixups in one instruction.

src/IceInstX8632.cpp

 //===- subzero/src/IceInstX8632.cpp - X86-32 instruction implementation ---===//
 //
 //                        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 InstX8632 and OperandX8632 classes,
@@ skipping 331 matching lines @@
 
 // ======================== Dump routines ======================== //
 
 namespace {
 
 void emitIASBytes(const Cfg *Func, const x86::AssemblerX86 *Asm,
                   intptr_t StartPosition) {
   GlobalContext *Ctx = Func->getContext();
   Ostream &Str = Ctx->getStrEmit();
   intptr_t EndPosition = Asm->GetPosition();
-  intptr_t LastFixupLoc = -1;
-  AssemblerFixup *LastFixup = NULL;
-  if (Asm->GetLatestFixup()) {
-    LastFixup = Asm->GetLatestFixup();
-    LastFixupLoc = LastFixup->position();
-  }
-  if (LastFixupLoc < StartPosition) {
+  AssemblerFixup *LastFixup = Asm->GetLatestFixup(StartPosition);
+  if (LastFixup == NULL) {
     // The fixup doesn't apply to this current block.
     for (intptr_t i = StartPosition; i < EndPosition; ++i) {
       Str << "\t.byte 0x";
       Str.write_hex(Asm->LoadBuffer<uint8_t>(i));
       Str << "\n";
     }
     return;
   }
+  intptr_t LastFixupLoc = LastFixup->position();
   const intptr_t FixupSize = 4;
-  assert(LastFixupLoc + FixupSize <= EndPosition);
   // The fixup does apply to this current block.
   for (intptr_t i = StartPosition; i < LastFixupLoc; ++i) {
     Str << "\t.byte 0x";
     Str.write_hex(Asm->LoadBuffer<uint8_t>(i));
     Str << "\n";
   }
-  Str << "\t.long ";
-  const ConstantRelocatable *Reloc = LastFixup->value();
-  if (Reloc->getSuppressMangling())
-    Str << Reloc->getName();
-  else
-    Str << Ctx->mangleName(Reloc->getName());
-  if (LastFixup->value()->getOffset()) {
-    Str << " + " << LastFixup->value()->getOffset();
+  while (LastFixup) {
+    Str << "\t.long ";
+    const ConstantRelocatable *Reloc = LastFixup->value();
+    if (Reloc->getSuppressMangling())
+      Str << Reloc->getName();
+    else
+      Str << Ctx->mangleName(Reloc->getName());
+    if (LastFixup->value()->getOffset()) {
+      Str << " + " << LastFixup->value()->getOffset();
+    }
+    Str << "\n";
+    LastFixupLoc += FixupSize;
+    assert(LastFixupLoc <= EndPosition);
+    LastFixup = Asm->GetLatestFixup(LastFixupLoc);
+    // Assume multi-fixups are adjacent in the instruction encoding.
+    assert(LastFixup == NULL || LastFixup->position() == LastFixupLoc);
   }
-  Str << "\n";
-  for (intptr_t i = LastFixupLoc + FixupSize; i < EndPosition; ++i) {
+  for (intptr_t i = LastFixupLoc; i < EndPosition; ++i) {
     Str << "\t.byte 0x";
     Str.write_hex(Asm->LoadBuffer<uint8_t>(i));
     Str << "\n";
   }
 }
 
 void emitIASBytesBranch(const Cfg *Func, const x86::AssemblerX86 *Asm,
                         intptr_t StartPosition, const x86::Label *Label,
                         const IceString &LabelName, bool Near) {
   // If this is a backward branch (label is bound), we're good and know
@@ skipping 2512 matching lines @@
   }
   Str << "(";
   if (Func)
     Var->dump(Func);
   else
     Var->dump(Str);
   Str << ")";
 }
 
 } // end of namespace Ice