Turn off dump/emit routines when building minimal subzero.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- 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 Operand class and its target-independent
@@ skipping 47 matching lines @@
   SizeT getNumVars() const { return NumVars; }
   Variable *getVar(SizeT I) const {
     assert(I < getNumVars());
     return Vars[I];
   }
   virtual void emit(const Cfg *Func) const = 0;
   // The dump(Func,Str) implementation must be sure to handle the
   // situation where Func==NULL.
   virtual void dump(const Cfg *Func, Ostream &Str) const = 0;
   void dump(const Cfg *Func) const {
+    if (!ALLOW_DUMP)
+      return;
     assert(Func);
     dump(Func, Func->getContext()->getStrDump());
   }
-  void dump(Ostream &Str) const { dump(NULL, Str); }
+  void dump(Ostream &Str) const {
+    if (ALLOW_DUMP)
+      dump(NULL, Str);
+  }
 
   // Query whether this object was allocated in isolation, or added to
   // some higher-level pool.  This determines whether a containing
   // object's destructor should delete this object.  Generally,
   // constants are pooled globally, variables are pooled per-CFG, and
   // target-specific operands are not pooled.
   virtual bool isPooled() const { return false; }
 
   virtual ~Operand() {}
 
@@ skipping 59 matching lines @@
            "Attempt to build primitive constant when IR generation disabled");
     return new (Ctx->allocate<ConstantPrimitive>())
         ConstantPrimitive(Ty, Value, PoolEntryID);
   }
   T getValue() const { return Value; }
   using Constant::emit;
   // The target needs to implement this for each ConstantPrimitive
   // specialization.
   void emit(GlobalContext *Ctx) const override;
   using Constant::dump;
-  void dump(const Cfg *, Ostream &Str) const override { Str << getValue(); }
+  void dump(const Cfg *, Ostream &Str) const override {
+    if (ALLOW_DUMP)
+      Str << getValue();
+  }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == K;
   }
 
 private:
   ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID)
       : Constant(K, Ty, PoolEntryID), Value(Value) {}
   ~ConstantPrimitive() override {}
   const T Value;
 };
 
 typedef ConstantPrimitive<uint32_t, Operand::kConstInteger32> ConstantInteger32;
 typedef ConstantPrimitive<uint64_t, Operand::kConstInteger64> ConstantInteger64;
 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
 
 template <> inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
+  if (!ALLOW_DUMP)
+    return;
   if (getType() == IceType_i1)
     Str << (getValue() ? "true" : "false");
   else
     Str << static_cast<int32_t>(getValue());
 }
 
 template <> inline void ConstantInteger64::dump(const Cfg *, Ostream &Str) const {
+  if (!ALLOW_DUMP)
+    return;
   assert(getType() == IceType_i64);
   Str << static_cast<int64_t>(getValue());
 }
 
 // RelocatableTuple bundles the parameters that are used to
 // construct an ConstantRelocatable.  It is done this way so that
 // ConstantRelocatable can fit into the global constant pool
 // template mechanism.
 class RelocatableTuple {
   // RelocatableTuple(const RelocatableTuple &) = delete;
@@ skipping 65 matching lines @@
                                uint32_t PoolEntryID) {
     assert(!Ctx->isIRGenerationDisabled() &&
            "Attempt to build undefined constant when IR generation disabled");
     return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty, PoolEntryID);
   }
 
   using Constant::emit;
   using Constant::dump;
   // The target needs to implement this.
   void emit(GlobalContext *Ctx) const override;
-  void dump(const Cfg *, Ostream &Str) const override { Str << "undef"; }
+  void dump(const Cfg *, Ostream &Str) const override {
+    if (ALLOW_DUMP)
+      Str << "undef";
+  }
 
   static bool classof(const Operand *Operand) {
     return Operand->getKind() == kConstUndef;
   }
 
 private:
   ConstantUndef(Type Ty, uint32_t PoolEntryID)
       : Constant(kConstUndef, Ty, PoolEntryID) {}
   ~ConstantUndef() override {}
 };
@@ skipping 360 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H