Subzero: Add Non-SFI support for x86-32.

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
@@ skipping 836 matching lines @@
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return Inst->getKind() == FakeDef; }
 
 private:
   InstFakeDef(Cfg *Func, Variable *Dest, Variable *Src);
 };
 
 /// FakeUse instruction. This creates a fake use of a variable, to keep the
 /// instruction that produces that variable from being dead-code eliminated.
 /// This is useful in a variety of lowering situations. The FakeUse instruction
-/// has no dest, so it can itself never be dead-code eliminated.
+/// has no dest, so it can itself never be dead-code eliminated.  A weight can
+/// be provided to provide extra bias to the register allocator - for simplicity
+/// of implementation, weight=N is handled by holding N copies of the variable
+/// as source operands.
 class InstFakeUse : public InstHighLevel {
   InstFakeUse() = delete;
   InstFakeUse(const InstFakeUse &) = delete;
   InstFakeUse &operator=(const InstFakeUse &) = delete;
 
 public:
-  static InstFakeUse *create(Cfg *Func, Variable *Src) {
-    return new (Func->allocate<InstFakeUse>()) InstFakeUse(Func, Src);
+  static InstFakeUse *create(Cfg *Func, Variable *Src, uint32_t Weight = 1) {
+    return new (Func->allocate<InstFakeUse>()) InstFakeUse(Func, Src, Weight);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg * /* Func */) const override {}
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return Inst->getKind() == FakeUse; }
 
 private:
-  InstFakeUse(Cfg *Func, Variable *Src);
+  InstFakeUse(Cfg *Func, Variable *Src, uint32_t Weight);
 };
 
 /// FakeKill instruction. This "kills" a set of variables by modeling a trivial
 /// live range at this instruction for each (implicit) variable. The primary use
 /// is to indicate that scratch registers are killed after a call, so that the
 /// register allocator won't assign a scratch register to a variable whose live
 /// range spans a call.
 ///
 /// The FakeKill instruction also holds a pointer to the instruction that kills
 /// the set of variables, so that if that linked instruction gets dead-code
@@ skipping 102 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