Subzero. Rematerializes shufflevector instructions.

src/IceInst.cpp

 //===- subzero/src/IceInst.cpp - High-level instruction implementation ----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 94 matching lines @@
     X(Store, "store");
     X(Switch, "switch");
     X(Assign, "assign");
     X(Breakpoint, "break");
     X(BundleLock, "bundlelock");
     X(BundleUnlock, "bundleunlock");
     X(FakeDef, "fakedef");
     X(FakeUse, "fakeuse");
     X(FakeKill, "fakekill");
     X(JumpTable, "jumptable");
+    X(ShuffleVector, "shufflevector");
 #undef X
   default:
     assert(Kind >= Target);
     return "target";
   }
 }
 
 // Assign the instruction a new number.
 void Inst::renumber(Cfg *Func) {
   Number = isDeleted() ? NumberDeleted : Func->newInstNumber();
@@ skipping 442 matching lines @@
 InstFakeUse::InstFakeUse(Cfg *Func, Variable *Src, uint32_t Weight)
     : InstHighLevel(Func, Inst::FakeUse, Weight, nullptr) {
   assert(Src);
   for (uint32_t i = 0; i < Weight; ++i)
     addSource(Src);
 }
 
 InstFakeKill::InstFakeKill(Cfg *Func, const Inst *Linked)
     : InstHighLevel(Func, Inst::FakeKill, 0, nullptr), Linked(Linked) {}
 
+InstShuffleVector::InstShuffleVector(Cfg *Func, Variable *Dest, Variable *Src0,
+                                     Variable *Src1)
+    : InstHighLevel(Func, Inst::ShuffleVector, 2, Dest),
+      NumIndexes(typeNumElements(Dest->getType())) {
+  addSource(Src0);
+  addSource(Src1);
+  Indexes = Func->allocateArrayOf<ConstantInteger32 *>(NumIndexes);
+}
+
 namespace {
 GlobalString makeName(Cfg *Func, const SizeT Id) {
   const auto FuncName = Func->getFunctionName();
   auto *Ctx = Func->getContext();
   if (FuncName.hasStdString())
     return GlobalString::createWithString(
         Ctx, ".L" + FuncName.toString() + "$jumptable$__" + std::to_string(Id));
   return GlobalString::createWithString(
       Ctx, "$J" + std::to_string(FuncName.getID()) + "_" + std::to_string(Id));
 }
@@ skipping 438 matching lines @@
 
 void InstFakeKill::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   if (Linked->isDeleted())
     Str << "// ";
   Str << "kill.pseudo scratch_regs";
 }
 
+void InstShuffleVector::dump(const Cfg *Func) const {
+  if (!BuildDefs::dump())
+    return;
+  Ostream &Str = Func->getContext()->getStrDump();
+  Str << "shufflevector ";
+  dumpDest(Func);
+  Str << " = ";
+  dumpSources(Func);
+  for (SizeT I = 0; I < NumIndexes; ++I) {
+    Str << ", ";
+    Indexes[I]->dump(Func);
+  }
+  Str << "\n";
+}
+
 void InstJumpTable::dump(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "jump table [";
   for (SizeT I = 0; I < NumTargets; ++I)
     Str << "\n    " << Targets[I]->getName();
   Str << "\n  ]";
 }
 
@@ skipping 17 matching lines @@
     // upper 32 bits of rax. We need to recognize and preserve these.
     return true;
   }
   if (!Dest->hasReg() && !SrcVar->hasReg() &&
       Dest->getStackOffset() == SrcVar->getStackOffset())
     return true;
   return false;
 }
 
 } // end of namespace Ice