Subzero. ARM32. Vector lowering. Subtract.

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 11 matching lines @@
 
 #ifndef SUBZERO_SRC_ICETARGETLOWERING_H
 #define SUBZERO_SRC_ICETARGETLOWERING_H
 
 #include "IceCfgNode.h"
 #include "IceDefs.h"
 #include "IceInst.h" // for the names of the Inst subtypes
 #include "IceOperand.h"
 #include "IceTypes.h"
 
+#include "llvm/Support/raw_ostream.h"
+
 #include <utility>
 
 namespace Ice {
 
 // UnimplementedError is defined as a macro so that we can get actual line
 // numbers.
 #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 {                                                                   \
+      std::string Buffer;                                                      \
+      llvm::raw_string_ostream StrBuf(Buffer);                                 \
+      StrBuf << "Not yet implemented: " << Instr->getInstName();               \
       /* Use llvm_unreachable instead of report_fatal_error, which gives       \
          better stack traces. */                                               \
-      llvm_unreachable("Not yet implemented");                                 \
+      llvm_unreachable(StrBuf.str().c_str());                                  \

[John, 2016/01/26 19:07:17]

just do

llvm_unreachable("Not yet implemented: " + Instr->getInstName());

[Eric Holk, 2016/01/26 22:49:24]

Ok.

       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 {
@@ skipping 491 matching lines @@
   virtual void lower() {}
 
 protected:
   explicit TargetHeaderLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H