Turn off dump/emit routines when building minimal subzero.

src/IceInstX8632.h

 //===- subzero/src/IceInstX8632.h - Low-level x86 instructions --*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the InstX8632 and OperandX8632 classes and
@@ skipping 23 matching lines @@
   OperandX8632 &operator=(const OperandX8632 &) = delete;
 
 public:
   enum OperandKindX8632 {
     k__Start = Operand::kTarget,
     kMem,
     kSplit
   };
   using Operand::dump;
   void dump(const Cfg *, Ostream &Str) const override {
-    Str << "<OperandX8632>";
+    if (ALLOW_DUMP)
+      Str << "<OperandX8632>";
   }
 
 protected:
   OperandX8632(OperandKindX8632 Kind, Type Ty)
       : Operand(static_cast<OperandKind>(Kind), Ty) {}
   ~OperandX8632() override {}
 };
 
 // OperandX8632Mem represents the m32 addressing mode, with optional
 // base and index registers, a constant offset, and a fixed shift
@@ skipping 403 matching lines @@
 class InstX8632InplaceopGPR : public InstX8632 {
   InstX8632InplaceopGPR(const InstX8632InplaceopGPR &) = delete;
   InstX8632InplaceopGPR &operator=(const InstX8632InplaceopGPR &) = delete;
 
 public:
   static InstX8632InplaceopGPR *create(Cfg *Func, Operand *SrcDest) {
     return new (Func->allocate<InstX8632InplaceopGPR>())
         InstX8632InplaceopGPR(Func, SrcDest);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 1);
     Str << "\t" << Opcode << "\t";
     getSrc(0)->emit(Func);
   }
   void emitIAS(const Cfg *Func) const override {
     assert(getSrcSize() == 1);
     const Variable *Var = getDest();
     Type Ty = Var->getType();
     emitIASOpTyGPR(Func, Ty, Var, Emitter);
   }
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632InplaceopGPR(Cfg *Func, Operand *SrcDest)
       : InstX8632(Func, K, 1, llvm::dyn_cast<Variable>(SrcDest)) {
@@ skipping 16 matching lines @@
 class InstX8632UnaryopGPR : public InstX8632 {
   InstX8632UnaryopGPR(const InstX8632UnaryopGPR &) = delete;
   InstX8632UnaryopGPR &operator=(const InstX8632UnaryopGPR &) = delete;
 
 public:
   static InstX8632UnaryopGPR *create(Cfg *Func, Variable *Dest, Operand *Src) {
     return new (Func->allocate<InstX8632UnaryopGPR>())
         InstX8632UnaryopGPR(Func, Dest, Src);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 1);
     Type SrcTy = getSrc(0)->getType();
     Type DestTy = getDest()->getType();
     Str << "\t" << Opcode << getWidthString(SrcTy);
     // Movsx and movzx need both the source and dest type width letter
     // to define the operation.  The other unary operations have the
     // same source and dest type and as a result need only one letter.
     if (SrcTy != DestTy)
       Str << getWidthString(DestTy);
     Str << "\t";
     getSrc(0)->emit(Func);
     Str << ", ";
     getDest()->emit(Func);
   }
   void emitIAS(const Cfg *Func) const override {
     assert(getSrcSize() == 1);
     const Variable *Var = getDest();
     Type Ty = Var->getType();
     const Operand *Src = getSrc(0);
     emitIASRegOpTyGPR(Func, Ty, Var, Src, Emitter);
   }
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getSrc(0)->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632UnaryopGPR(Cfg *Func, Variable *Dest, Operand *Src)
       : InstX8632(Func, K, 1, Dest) {
@@ skipping 12 matching lines @@
 class InstX8632UnaryopXmm : public InstX8632 {
   InstX8632UnaryopXmm(const InstX8632UnaryopXmm &) = delete;
   InstX8632UnaryopXmm &operator=(const InstX8632UnaryopXmm &) = delete;
 
 public:
   static InstX8632UnaryopXmm *create(Cfg *Func, Variable *Dest, Operand *Src) {
     return new (Func->allocate<InstX8632UnaryopXmm>())
         InstX8632UnaryopXmm(Func, Dest, Src);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 1);
     Str << "\t" << Opcode << "\t";
     getSrc(0)->emit(Func);
     Str << ", ";
     getDest()->emit(Func);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = getDest()->getType();
     assert(getSrcSize() == 1);
     emitIASRegOpTyXMM(Func, Ty, getDest(), getSrc(0), Emitter);
   }
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632UnaryopXmm(Cfg *Func, Variable *Dest, Operand *Src)
       : InstX8632(Func, K, 1, Dest) {
@@ skipping 19 matching lines @@
   InstX8632BinopGPRShift &operator=(const InstX8632BinopGPRShift &) = delete;
 
 public:
   // Create a binary-op GPR shift instruction.
   static InstX8632BinopGPRShift *create(Cfg *Func, Variable *Dest,
                                         Operand *Source) {
     return new (Func->allocate<InstX8632BinopGPRShift>())
         InstX8632BinopGPRShift(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     const bool ShiftHack = true;
     emitTwoAddress(Opcode, this, Func, ShiftHack);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = getDest()->getType();
     assert(getSrcSize() == 2);
     emitIASGPRShift(Func, Ty, getDest(), getSrc(1), Emitter);
   }
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632BinopGPRShift(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX8632(Func, K, 2, Dest) {
@@ skipping 10 matching lines @@
   InstX8632BinopGPR(const InstX8632BinopGPR &) = delete;
   InstX8632BinopGPR &operator=(const InstX8632BinopGPR &) = delete;
 
 public:
   // Create an ordinary binary-op instruction like add or sub.
   static InstX8632BinopGPR *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632BinopGPR>())
         InstX8632BinopGPR(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     const bool ShiftHack = false;
     emitTwoAddress(Opcode, this, Func, ShiftHack);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = getDest()->getType();
     assert(getSrcSize() == 2);
     emitIASRegOpTyGPR(Func, Ty, getDest(), getSrc(1), Emitter);
   }
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632BinopGPR(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX8632(Func, K, 2, Dest) {
@@ skipping 10 matching lines @@
   InstX8632BinopXmm(const InstX8632BinopXmm &) = delete;
   InstX8632BinopXmm &operator=(const InstX8632BinopXmm &) = delete;
 
 public:
   // Create an XMM binary-op instruction like addss or addps.
   static InstX8632BinopXmm *create(Cfg *Func, Variable *Dest, Operand *Source) {
     return new (Func->allocate<InstX8632BinopXmm>())
         InstX8632BinopXmm(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     const bool ShiftHack = false;
     emitTwoAddress(Opcode, this, Func, ShiftHack);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = getDest()->getType();
     if (NeedsElementType)
       Ty = typeElementType(Ty);
     assert(getSrcSize() == 2);
     emitIASRegOpTyXMM(Func, Ty, getDest(), getSrc(1), Emitter);
   }
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632BinopXmm(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX8632(Func, K, 2, Dest) {
@@ skipping 15 matching lines @@
   InstX8632BinopXmmShift &operator=(const InstX8632BinopXmmShift &) = delete;
 
 public:
   // Create an XMM binary-op shift operation.
   static InstX8632BinopXmmShift *create(Cfg *Func, Variable *Dest,
                                         Operand *Source) {
     return new (Func->allocate<InstX8632BinopXmmShift>())
         InstX8632BinopXmmShift(Func, Dest, Source);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     const bool ShiftHack = false;
     emitTwoAddress(Opcode, this, Func, ShiftHack);
   }
   void emitIAS(const Cfg *Func) const override {
     Type Ty = getDest()->getType();
     assert(Ty == IceType_v8i16 || Ty == IceType_v8i1 || Ty == IceType_v4i32 ||
            Ty == IceType_v4i1);
     Type ElementTy = typeElementType(Ty);
     assert(getSrcSize() == 2);
     emitIASXmmShift(Func, ElementTy, getDest(), getSrc(1), Emitter);
   }
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632BinopXmmShift(Cfg *Func, Variable *Dest, Operand *Source)
       : InstX8632(Func, K, 2, Dest) {
@@ skipping 10 matching lines @@
   InstX8632Ternop &operator=(const InstX8632Ternop &) = delete;
 
 public:
   // Create a ternary-op instruction like div or idiv.
   static InstX8632Ternop *create(Cfg *Func, Variable *Dest, Operand *Source1,
                                  Operand *Source2) {
     return new (Func->allocate<InstX8632Ternop>())
         InstX8632Ternop(Func, Dest, Source1, Source2);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 3);
     Str << "\t" << Opcode << "\t";
     getSrc(2)->emit(Func);
     Str << ", ";
     getSrc(1)->emit(Func);
     Str << ", ";
     getDest()->emit(Func);
   }
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632Ternop(Cfg *Func, Variable *Dest, Operand *Source1, Operand *Source2)
       : InstX8632(Func, K, 3, Dest) {
@@ skipping 11 matching lines @@
   InstX8632ThreeAddressop(const InstX8632ThreeAddressop &) = delete;
   InstX8632ThreeAddressop &operator=(const InstX8632ThreeAddressop &) = delete;
 
 public:
   static InstX8632ThreeAddressop *create(Cfg *Func, Variable *Dest,
                                          Operand *Source0, Operand *Source1) {
     return new (Func->allocate<InstX8632ThreeAddressop>())
         InstX8632ThreeAddressop(Func, Dest, Source0, Source1);
   }
   void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrEmit();
     assert(getSrcSize() == 2);
     Str << "\t" << Opcode << "\t";
     getSrc(1)->emit(Func);
     Str << ", ";
     getSrc(0)->emit(Func);
     Str << ", ";
     getDest()->emit(Func);
   }
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = " << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632ThreeAddressop(Cfg *Func, Variable *Dest, Operand *Source0,
                           Operand *Source1)
@@ skipping 18 matching lines @@
     return new (Func->allocate<InstX8632Movlike>())
         InstX8632Movlike(Func, Dest, Source);
   }
   bool isRedundantAssign() const override {
     return checkForRedundantAssign(getDest(), getSrc(0));
   }
   bool isSimpleAssign() const override { return true; }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
     Ostream &Str = Func->getContext()->getStrDump();
     Str << Opcode << "." << getDest()->getType() << " ";
     dumpDest(Func);
     Str << ", ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstX8632Movlike(Cfg *Func, Variable *Dest, Operand *Source)
@@ skipping 662 matching lines @@
 template <> void InstX8632Pinsr::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movsx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movzx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pmull::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pshufd::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Shufps::emitIAS(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H