Initial Subzero WASM prototype.

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 149 matching lines @@
   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() = default;
 
+  void setCfgNode(CfgNode *node) { BasicBlock = node; }
+  CfgNode *getCfgNode() const { return BasicBlock; }
+
 protected:
   Inst(Cfg *Func, InstKind Kind, SizeT MaxSrcs, Variable *Dest);
   void addSource(Operand *Src) {
     assert(Src);
     assert(NumSrcs < MaxSrcs);
     Srcs[NumSrcs++] = Src;
   }
   void setLastUse(SizeT VarIndex) {
     if (VarIndex < CHAR_BIT * sizeof(LiveRangesEnded))
       LiveRangesEnded |= (((LREndedBits)1u) << VarIndex);
   }
   void resetLastUses() { LiveRangesEnded = 0; }
   /// The destroy() method lets the instruction cleanly release any memory that
   /// was allocated via the Cfg's allocator.
   virtual void destroy(Cfg *Func) { Func->deallocateArrayOf<Operand *>(Srcs); }
 
+  /// The CfgNode that contains this instruction
+  CfgNode *BasicBlock = nullptr;
+
   const InstKind Kind;
   /// Number is the instruction number for describing live ranges.
   InstNumberT Number;
   /// Deleted means irrevocably deleted.
   bool Deleted = false;
   /// Dead means one of two things depending on context: (1) pending deletion
   /// after liveness analysis converges, or (2) marked for deletion during
   /// lowering due to a folded bool operation.
   bool Dead = false;
   /// HasSideEffects means the instruction is something like a function call or
@@ skipping 420 matching lines @@
   InstPhi(const InstPhi &) = delete;
   InstPhi &operator=(const InstPhi &) = delete;
 
 public:
   static InstPhi *create(Cfg *Func, SizeT MaxSrcs, Variable *Dest) {
     return new (Func->allocate<InstPhi>()) InstPhi(Func, MaxSrcs, Dest);
   }
   void addArgument(Operand *Source, CfgNode *Label);
   Operand *getOperandForTarget(CfgNode *Target) const;
   CfgNode *getLabel(SizeT Index) const { return Labels[Index]; }
+  void setLabel(SizeT Index, CfgNode *Label) { Labels[Index] = Label; }
   void livenessPhiOperand(LivenessBV &Live, CfgNode *Target,
                           Liveness *Liveness);
   Inst *lower(Cfg *Func);
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Instr) { return Instr->getKind() == Phi; }
 
 private:
   InstPhi(Cfg *Func, SizeT MaxSrcs, Variable *Dest);
   void destroy(Cfg *Func) override {
     Func->deallocateArrayOf<CfgNode *>(Labels);
@@ skipping 361 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