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 50 matching lines @@
     Select,
     Store,
     Switch,
     Assign,       // 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
+    Breakpoint,   // not part of LLVM/PNaCl bitcode

[Jim Stichnoth, 2016/04/14 20:03:44]

Sort this - between Assign and BundleLock

[Eric Holk, 2016/04/15 15:24:26]

Done.

     // 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.
     Target,
     Target_Max = std::numeric_limits<uint8_t>::max(),
   };
   static_assert(Target <= Target_Max, "Must not be above max.");
   InstKind getKind() const { return Kind; }
   virtual const char *getInstName() const;
@@ skipping 888 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.
+///

[John, 2016/04/12 20:34:27]

What's the use case for this? I would think that simply emitting an int3/ud2
directly is enough for your debugging needs...

[Eric Holk, 2016/04/12 21:30:10]

I used it when I was debugging indirect calls. I had the Wasm translator insert
an int3 right before the indirect call started to make it easier to know which
generated code corresponded to that instruction.

Jim suggested adding some command-line arguments to insert breakpoints, such as
something like --break-before-inst=NNN, to insert a breakpoint before
instruction number NNN.

This high level instruction helps to control where the breakpoint happens
relative to the high level instructions. I think most of this information is
lost by the time we get to the emitter.

+/// 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