Subzero. Introduces a new LoweringContext::insert() method.

src/IceTargetLowering.h

 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- 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 TargetLowering, LoweringContext, and TargetDataLowering
 /// classes.
 ///
 /// TargetLowering is an abstract class used to drive the translation/lowering
 /// process. LoweringContext maintains a context for lowering each instruction,
 /// offering conveniences such as iterating over non-deleted instructions.
 /// TargetDataLowering is an abstract class used to drive the lowering/emission
 /// of global initializers, external global declarations, and internal constant
 /// pools.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICETARGETLOWERING_H
 #define SUBZERO_SRC_ICETARGETLOWERING_H
 
+#include "IceCfgNode.h"
 #include "IceDefs.h"
 #include "IceInst.h" // for the names of the Inst subtypes
 #include "IceOperand.h"
 #include "IceTypes.h"
 
+#include <utility>
+
 namespace Ice {
 
 // UnimplementedError is defined as a macro so that we can get actual line
 // numbers.
 #define UnimplementedError(Flags)                                              \
   do {                                                                         \
     if (!static_cast<const ClFlags &>(Flags).getSkipUnimplemented()) {         \
       /* Use llvm_unreachable instead of report_fatal_error, which gives       \
          better stack traces. */                                               \
       llvm_unreachable("Not yet implemented");                                 \
@@ skipping 24 matching lines @@
     if (Iter == End)
       return nullptr;
     return Iter;
   }
   CfgNode *getNode() const { return Node; }
   bool atEnd() const { return Cur == End; }
   InstList::iterator getCur() const { return Cur; }
   InstList::iterator getNext() const { return Next; }
   InstList::iterator getEnd() const { return End; }
   void insert(Inst *Inst);
+  template <typename Inst, typename... Args> Inst *insert(Args &&... A) {
+    auto *New = Inst::create(Node->getCfg(), std::forward<Args>(A)...);
+    insert(New);
+    return New;
+  }
   Inst *getLastInserted() const;
   void advanceCur() { Cur = Next; }
   void advanceNext() { advanceForward(Next); }
   void setCur(InstList::iterator C) { Cur = C; }
   void setNext(InstList::iterator N) { Next = N; }
   void rewind();
   void setInsertPoint(const InstList::iterator &Position) { Next = Position; }
   void availabilityReset();
   void availabilityUpdate();
   Variable *availabilityGet(Operand *Src) const;
@@ skipping 278 matching lines @@
   /// Sort the variables in Source based on required alignment. The variables
   /// with the largest alignment need are placed in the front of the Dest list.
   void sortVarsByAlignment(VarList &Dest, const VarList &Source) const;
 
   /// Make a call to an external helper function.
   InstCall *makeHelperCall(const IceString &Name, Variable *Dest,
                            SizeT MaxSrcs);
 
   void
   _bundle_lock(InstBundleLock::Option BundleOption = InstBundleLock::Opt_None) {
-    Context.insert(InstBundleLock::create(Func, BundleOption));
+    Context.insert<InstBundleLock>(BundleOption);
   }
-  void _bundle_unlock() { Context.insert(InstBundleUnlock::create(Func)); }
+  void _bundle_unlock() { Context.insert<InstBundleUnlock>(); }
   void _set_dest_redefined() { Context.getLastInserted()->setDestRedefined(); }
 
   bool shouldOptimizeMemIntrins();
 
   Cfg *Func;
   GlobalContext *Ctx;
   bool HasComputedFrame = false;
   bool CallsReturnsTwice = false;
   SizeT NextLabelNumber = 0;
   SizeT NextJumpTableNumber = 0;
@@ skipping 84 matching lines @@
   virtual void lower() {}
 
 protected:
   explicit TargetHeaderLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H