Subzero. WASM. Additional progress.

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 44 matching lines @@
     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
     // 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.
@@ skipping 894 matching lines @@
     Inst::destroy(Func);
   }
 
   const SizeT Id;
   const SizeT NumTargets;
   CfgNode **Targets;
   GlobalString Name; // This JumpTable's name in the output.
   GlobalString FuncName;
 };
 
+/// This instruction inserts an unconditional breakpoint.
+///
+/// On x86, this assembles into an INT 3 instruction.
+///
+/// This instruction is primarily meant for debugging the code generator.
+class InstBreakpoint : public InstHighLevel {
+public:
+  InstBreakpoint() = delete;
+  InstBreakpoint(const InstBreakpoint &) = delete;
+  InstBreakpoint &operator=(const InstBreakpoint &) = delete;
+
+  InstBreakpoint(Cfg *Func);
+
+public:
+  static InstBreakpoint *create(Cfg *Func) {
+    return new (Func->allocate<InstBreakpoint>()) InstBreakpoint(Func);
+  }
+
+  static bool classof(const Inst *Instr) {
+    return Instr->getKind() == Breakpoint;
+  }
+};
+
 /// The Target instruction is the base class for all target-specific
 /// instructions.
 class InstTarget : public Inst {
   InstTarget() = delete;
   InstTarget(const InstTarget &) = delete;
   InstTarget &operator=(const InstTarget &) = delete;
 
 public:
   uint32_t getEmitInstCount() const override { return 1; }
   void dump(const Cfg *Func) const override;
@@ skipping 26 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