Subzero. Rematerializes shufflevector instructions.

src/IceInst.h

 //===- subzero/src/IceInst.h - High-level instructions ----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares the Inst class and its target-independent subclasses.
 ///
 /// These represent the high-level Vanilla ICE instructions and map roughly 1:1
 /// to LLVM instructions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEINST_H
 #define SUBZERO_SRC_ICEINST_H
 
 #include "IceCfg.h"
 #include "IceDefs.h"
 #include "IceInst.def"
 #include "IceIntrinsics.h"
+#include "IceOperand.h"
 #include "IceSwitchLowering.h"
 #include "IceTypes.h"
 
 // TODO: The Cfg structure, and instructions in particular, need to be
 // validated for things like valid operand types, valid branch targets, proper
 // ordering of Phi and non-Phi instructions, etc. Most of the validity checking
 // will be done in the bitcode reader. We need a list of everything that should
 // be validated, and tests for each.
 
 namespace Ice {
@@ skipping 19 matching lines @@
     Fcmp,
     Icmp,
     IntrinsicCall,
     InsertElement,
     Load,
     Phi,
     Ret,
     Select,
     Store,
     Switch,
-    Assign,       // not part of LLVM/PNaCl bitcode
-    Breakpoint,   // not part of LLVM/PNaCl bitcode
-    BundleLock,   // not part of LLVM/PNaCl bitcode
-    BundleUnlock, // not part of LLVM/PNaCl bitcode
-    FakeDef,      // not part of LLVM/PNaCl bitcode
-    FakeUse,      // not part of LLVM/PNaCl bitcode
-    FakeKill,     // not part of LLVM/PNaCl bitcode
-    JumpTable,    // not part of LLVM/PNaCl bitcode
+    Assign,        // not part of LLVM/PNaCl bitcode
+    Breakpoint,    // not part of LLVM/PNaCl bitcode
+    BundleLock,    // not part of LLVM/PNaCl bitcode
+    BundleUnlock,  // not part of LLVM/PNaCl bitcode
+    FakeDef,       // not part of LLVM/PNaCl bitcode
+    FakeUse,       // not part of LLVM/PNaCl bitcode
+    FakeKill,      // not part of LLVM/PNaCl bitcode
+    JumpTable,     // not part of LLVM/PNaCl bitcode
+    ShuffleVector, // not part of LLVM/PNaCl bitcode
     // Anything >= Target is an InstTarget subclass. Note that the value-spaces
     // are shared across targets. To avoid confusion over the definition of
     // shared values, an object specific to one target should never be passed
     // to a different target.
     Target,
     Target_Max = std::numeric_limits<uint8_t>::max(),
   };
   static_assert(Target <= Target_Max, "Must not be above max.");
   InstKind getKind() const { return Kind; }
   virtual const char *getInstName() const;
@@ skipping 828 matching lines @@
     return Instr->getKind() == FakeKill;
   }
 
 private:
   InstFakeKill(Cfg *Func, const Inst *Linked);
 
   /// This instruction is ignored if Linked->isDeleted() is true.
   const Inst *Linked;
 };
 
+/// ShuffleVector instruction. This represents a shuffle operation on vector
+/// types. This instruction is not part of the PNaCl bitcode: it is generated
+/// by Subzero when it matches the pattern used by pnacl-clang when compiling
+/// to bitcode.
+class InstShuffleVector : public InstHighLevel {
+  InstShuffleVector() = delete;
+  InstShuffleVector(const InstShuffleVector &) = delete;
+  InstShuffleVector &operator=(const InstShuffleVector &) = delete;
+
+public:
+  static InstShuffleVector *create(Cfg *Func, Variable *Dest, Variable *Src0,
+                                   Variable *Src1) {
+    return new (Func->allocate<InstShuffleVector>())
+        InstShuffleVector(Func, Dest, Src0, Src1);
+  }
+
+  SizeT getNumIndexes() const { return NumIndexes; }
+
+  void addIndex(ConstantInteger32 *Index) {
+    assert(CurrentIndex < NumIndexes);
+    Indexes[CurrentIndex++] = Index;
+  }
+
+  ConstantInteger32 *getIndex(SizeT Pos) const {
+    assert(Pos < NumIndexes);
+    return Indexes[Pos];
+  }
+
+  void dump(const Cfg *Func) const override;
+  static bool classof(const Inst *Instr) {
+    return Instr->getKind() == ShuffleVector;
+  }
+
+private:
+  InstShuffleVector(Cfg *Func, Variable *Dest, Variable *Src0, Variable *Src1);
+
+  void destroy(Cfg *Func) override {
+    Func->deallocateArrayOf<ConstantInteger32 *>(Indexes);
+    Inst::destroy(Func);
+  }
+
+  ConstantInteger32 **Indexes;
+  SizeT CurrentIndex = 0;
+  const SizeT NumIndexes;
+};
+
 /// JumpTable instruction. This represents a jump table that will be stored in
 /// the .rodata section. This is used to track and repoint the target CfgNodes
 /// which may change, for example due to splitting for phi lowering.
 class InstJumpTable : public InstHighLevel {
   InstJumpTable() = delete;
   InstJumpTable(const InstJumpTable &) = delete;
   InstJumpTable &operator=(const InstJumpTable &) = delete;
 
 public:
   static InstJumpTable *create(Cfg *Func, SizeT NumTargets, CfgNode *Default) {
@@ skipping 109 matching lines @@
   static void noteHead(Ice::Inst *, Ice::Inst *) {}
   void deleteNode(Ice::Inst *) {}
 
 private:
   mutable ilist_half_node<Ice::Inst> Sentinel;
 };
 
 } // end of namespace llvm
 
 #endif // SUBZERO_SRC_ICEINST_H