Subzero: Improve the usability of UnimplementedError during lowering.

src/IceTargetLowering.h

 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 27 matching lines @@
 #define UnimplementedError(Flags)                                              \
   do {                                                                         \
     if (!static_cast<const ClFlags &>(Flags).getSkipUnimplemented()) {         \
       /* Use llvm_unreachable instead of report_fatal_error, which gives       \
          better stack traces. */                                               \
       llvm_unreachable("Not yet implemented");                                 \
       abort();                                                                 \
     }                                                                          \
   } while (0)
 
+// UnimplementedLoweringError is similar in style to UnimplementedError.  Given
+// a TargetLowering object pointer and an Inst pointer, it adds appropriate
+// FakeDef and FakeUse instructions to try maintain liveness consistency.
+#define UnimplementedLoweringError(Target, Instr)                              \
+  do {                                                                         \
+    if ((Target)->Ctx->getFlags().getSkipUnimplemented()) {                    \
+      (Target)->addFakeDefUses(Instr);                                         \
+    } else {                                                                   \
+      /* Use llvm_unreachable instead of report_fatal_error, which gives       \
+         better stack traces. */                                               \
+      llvm_unreachable("Not yet implemented");                                 \
+      abort();                                                                 \
+    }                                                                          \
+  } while (0)
+
 /// LoweringContext makes it easy to iterate through non-deleted instructions in
 /// a node, and insert new (lowered) instructions at the current point. Along
 /// with the instruction list container and associated iterators, it holds the
 /// current node, which is needed when inserting new instructions in order to
 /// track whether variables are used as single-block or multi-block.
 class LoweringContext {
   LoweringContext(const LoweringContext &) = delete;
   LoweringContext &operator=(const LoweringContext &) = delete;
 
 public:
@@ skipping 308 matching lines @@
 
   virtual void doAddressOptLoad() {}
   virtual void doAddressOptStore() {}
   virtual void doMockBoundsCheck(Operand *) {}
   virtual void randomlyInsertNop(float Probability,
                                  RandomNumberGenerator &RNG) = 0;
   /// This gives the target an opportunity to post-process the lowered expansion
   /// before returning.
   virtual void postLower() {}
 
+  /// When the SkipUnimplemented flag is set, addFakeDefUses() gets invoked by
+  /// the UnimplementedLoweringError macro to insert fake uses of all the
+  /// instruction variables and a fake def of the instruction dest, in order to
+  /// preserve integrity of liveness analysis.
+  void addFakeDefUses(const Inst *Instr);
+
   /// Find (non-SSA) instructions where the Dest variable appears in some source
   /// operand, and set the IsDestRedefined flag.  This keeps liveness analysis
   /// consistent.
   void markRedefinitions();
 
   /// Make a pass over the Cfg to determine which variables need stack slots and
   /// place them in a sorted list (SortedSpilledVariables). Among those, vars,
   /// classify the spill variables as local to the basic block vs global
   /// (multi-block) in order to compute the parameters GlobalsSize and
   /// SpillAreaSizeBytes (represents locals or general vars if the coalescing of
@@ skipping 142 matching lines @@
   virtual void lower() {}
 
 protected:
   explicit TargetHeaderLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H