Subzero: Fix the g++ build (e.g. Windows).

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Inst class and its target-independent
@@ skipping 110 matching lines @@
   // algorithm has converged, and then a separate pass permanently
   // deletes dead instructions.
   bool liveness(InstNumberT InstNumber, LivenessBV &Live, Liveness *Liveness,
                 LiveBeginEndMap *LiveBegin, LiveBeginEndMap *LiveEnd);
 
   // Get the number of native instructions that this instruction
   // ultimately emits.  By default, high-level instructions don't
   // result in any native instructions, and a target-specific
   // instruction results in a single native instruction.
   virtual uint32_t getEmitInstCount() const { return 0; }
-  virtual void emit(const Cfg *Func) const = 0;
-  virtual void emitIAS(const Cfg *Func) const = 0;
+  // TODO(stichnot): Change Inst back to abstract once the g++ build
+  // issue is fixed.  llvm::ilist<Ice::Inst> doesn't work under g++
+  // because the resize(size_t, Ice::Inst) method is incorrectly
+  // declared and thus doesn't allow the abstract class Ice::Inst.
+  // The method should be declared resize(size_t, const Ice::Inst &).
+  // virtual void emit(const Cfg *Func) const = 0;
+  // virtual void emitIAS(const Cfg *Func) const = 0;
+  virtual void emit(const Cfg *) const {
+    llvm_unreachable("emit on abstract class");
+  }
+  virtual void emitIAS(const Cfg *Func) const { emit(Func); }
   virtual void dump(const Cfg *Func) const;
   virtual void dumpExtras(const Cfg *Func) const;
   void dumpDecorated(const Cfg *Func) const;
   void emitSources(const Cfg *Func) const;
   void dumpSources(const Cfg *Func) const;
   void dumpDest(const Cfg *Func) const;
   virtual bool isRedundantAssign() const { return false; }
 
   virtual ~Inst() {}
 
@@ skipping 685 matching lines @@
 protected:
   InstTarget(Cfg *Func, InstKind Kind, SizeT MaxSrcs, Variable *Dest)
       : Inst(Func, Kind, MaxSrcs, Dest) {
     assert(Kind >= Target);
   }
   ~InstTarget() override {}
 };
 
 } // end of namespace Ice
 
+namespace llvm {
+
 // Override the default ilist traits so that Inst's private ctor and
 // deleted dtor aren't invoked.
 template <>
-struct llvm::ilist_traits<Ice::Inst>
-    : public llvm::ilist_default_traits<Ice::Inst> {
+struct ilist_traits<Ice::Inst> : public ilist_default_traits<Ice::Inst> {
   Ice::Inst *createSentinel() const {
     return static_cast<Ice::Inst *>(&Sentinel);
   }
   static void destroySentinel(Ice::Inst *) {}
   Ice::Inst *provideInitialHead() const { return createSentinel(); }
   Ice::Inst *ensureHead(Ice::Inst *) const { return createSentinel(); }
   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