[CodeGen] Define ABI breaking class members correctly

[kovdan01]

Summary

Non-static class members declared under #ifndef NDEBUG should be declared
under #if LLVM_ENABLE_ABI_BREAKING_CHECKS to make headers library-friendly and
allow cross-linking, as discussed in D120714.

[kovdan01]

Fix typo

[mehdi_amini]

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

601

This is a private header (you're in the lib directory and not in the include directory)

Same for the SystemZ one above I believe.

[kovdan01]

Keep private headers untouched

[kovdan01]

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

601

Makes sense, fixed, thanks!

[mehdi_amini]

LGTM

[kovdan01]

Fix formatting problems found on pre-merge checks

[dexonsmith]

LGTM too; thanks!

[kovdan01]

Accidentally placed this revision ID in commit message related to other patch. Reverted that.

clang/lib/Sema/TypeLocBuilder.h

class TypeLocBuilder {
   char *Buffer;
 
   /// The capacity of the current buffer.
   size_t Capacity;
 
   /// The index of the first occupied byte in the buffer.
   size_t Index;
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   /// The last type pushed on this builder.
   QualType LastTy;
 #endif
 
   /// The inline buffer.
   enum { BufferMaxAlignment = alignof(void *) };
   alignas(BufferMaxAlignment) char InlineBuffer[InlineCapacity];
   unsigned NumBytesAtAlign4, NumBytesAtAlign8;
public:
   TypeSpecTypeLoc pushTypeSpec(QualType T) {
     size_t LocalSize = TypeSpecTypeLoc::LocalDataSize;
     unsigned LocalAlign = TypeSpecTypeLoc::LocalDataAlignment;
     return pushImpl(T, LocalSize, LocalAlign).castAs<TypeSpecTypeLoc>();
   }
 
   /// Resets this builder to the newly-initialized state.
   void clear() {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     LastTy = QualType();
 #endif
     Index = Capacity;
     NumBytesAtAlign4 = NumBytesAtAlign8 = 0;
   }
 
   /// Tell the TypeLocBuilder that the type it is storing has been
   /// modified in some safe way that doesn't affect type-location information.
   void TypeWasModifiedSafely(QualType T) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     LastTy = T;
 #endif
   }
 
   /// Pushes space for a new TypeLoc of the given type.  Invalidates
   /// any TypeLocs previously retrieved from this builder.
   template <class TyLocType> TyLocType push(QualType T) {
     TyLocType Loc = TypeLoc(T, nullptr).castAs<TyLocType>();
     size_t LocalSize = Loc.getLocalDataSize();
     unsigned LocalAlign = Loc.getLocalDataAlignment();
     return pushImpl(T, LocalSize, LocalAlign).castAs<TyLocType>();
   }
 
   /// Creates a TypeSourceInfo for the given type.
   TypeSourceInfo *getTypeSourceInfo(ASTContext& Context, QualType T) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(T == LastTy && "type doesn't match last type pushed!");
 #endif
 
     size_t FullDataSize = Capacity - Index;
     TypeSourceInfo *DI = Context.CreateTypeSourceInfo(T, FullDataSize);
     memcpy(DI->getTypeLoc().getOpaqueData(), &Buffer[Index], FullDataSize);
     return DI;
   }
 
   /// Copies the type-location information to the given AST context and
   /// returns a \c TypeLoc referring into the AST context.
   TypeLoc getTypeLocInContext(ASTContext &Context, QualType T) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(T == LastTy && "type doesn't match last type pushed!");
 #endif
 
     size_t FullDataSize = Capacity - Index;
     void *Mem = Context.Allocate(FullDataSize);
     memcpy(Mem, &Buffer[Index], FullDataSize);
     return TypeLoc(T, Mem);
   }
 
 private:
 
   TypeLoc pushImpl(QualType T, size_t LocalSize, unsigned LocalAlignment);
 
   /// Grow to the given capacity.
   void grow(size_t NewCapacity);
 
   /// Retrieve a temporary TypeLoc that refers into this \c TypeLocBuilder
   /// object.
   ///
   /// The resulting \c TypeLoc should only be used so long as the
   /// \c TypeLocBuilder is active and has not had more type information
   /// pushed into it.
   TypeLoc getTemporaryTypeLoc(QualType T) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(LastTy == T && "type doesn't match last type pushed!");
 #endif
     return TypeLoc(T, &Buffer[Index]);
   }
 };
 
 }
 
 #endif

clang/lib/Sema/TypeLocBuilder.cpp

if (Buffer != InlineBuffer)
     delete[] Buffer;
 
   Buffer = NewBuffer;
   Capacity = NewCapacity;
   Index = NewIndex;
 }
 
 TypeLoc TypeLocBuilder::pushImpl(QualType T, size_t LocalSize, unsigned LocalAlignment) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   QualType TLast = TypeLoc(T, nullptr).getNextTypeLoc().getType();
   assert(TLast == LastTy &&
          "mismatch between last type and new type's inner type");
   LastTy = T;
 #endif
 
   assert(LocalAlignment <= BufferMaxAlignment && "Unexpected alignment");
 

llvm/include/llvm/CodeGen/GlobalISel/GISelWorkList.h

 //
 // FIXME: Does it make sense to factor out common code with the
 // instcombinerWorkList?
 template<unsigned N>
 class GISelWorkList {
   SmallVector<MachineInstr *, N> Worklist;
   DenseMap<MachineInstr *, unsigned> WorklistMap;
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   bool Finalized = true;
 #endif
 
 public:
   GISelWorkList() : WorklistMap(N) {}
 
   bool empty() const { return WorklistMap.empty(); }
 
   unsigned size() const { return WorklistMap.size(); }
 
   // Since we don't know ahead of time how many instructions we're going to add
   // to the worklist, and migrating densemap's elements is quite expensive
   // everytime we resize, only insert to the smallvector (typically during the
   // initial phase of populating lists). Before the worklist can be used,
   // finalize should be called. Also assert with NDEBUG if list is ever used
   // without finalizing. Note that unlike insert, we won't check for duplicates
   // - so the ideal place to use this is during the initial prepopulating phase
   // of most passes.
   void deferred_insert(MachineInstr *I) {
     Worklist.push_back(I);
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     Finalized = false;
 #endif
   }
 
   // This should only be called when using deferred_insert.
   // This asserts that the WorklistMap is empty, and then
   // inserts all the elements in the Worklist into the map.
   // It also asserts if there are any duplicate elements found.
   void finalize() {
     assert(WorklistMap.empty() && "Expecting empty worklistmap");
     if (Worklist.size() > N)
       WorklistMap.reserve(Worklist.size());
     for (unsigned i = 0; i < Worklist.size(); ++i)
       if (!WorklistMap.try_emplace(Worklist[i], i).second)
         llvm_unreachable("Duplicate elements in the list");
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     Finalized = true;
 #endif
   }
 
   /// Add the specified instruction to the worklist if it isn't already in it.
   void insert(MachineInstr *I) {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(Finalized && "GISelWorkList used without finalizing");
+#endif
     if (WorklistMap.try_emplace(I, Worklist.size()).second)
       Worklist.push_back(I);
   }
 
   /// Remove I from the worklist if it exists.
   void remove(const MachineInstr *I) {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert((Finalized || WorklistMap.empty()) && "Neither finalized nor empty");
+#endif
     auto It = WorklistMap.find(I);
     if (It == WorklistMap.end())
       return; // Not in worklist.
 
     // Don't bother moving everything down, just null out the slot.
     Worklist[It->second] = nullptr;
 
     WorklistMap.erase(It);
   }
 
   void clear() {
     Worklist.clear();
     WorklistMap.clear();
   }
 
   MachineInstr *pop_back_val() {
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(Finalized && "GISelWorkList used without finalizing");
+#endif
     MachineInstr *I;
     do {
       I = Worklist.pop_back_val();
     } while(!I);
     assert(I && "Pop back on empty worklist");
     WorklistMap.erase(I);
     return I;
   }
 };
 
 } // end namespace llvm.
 
 #endif

llvm/include/llvm/CodeGen/MachineScheduler.h

protected:
 
   /// The bottom of the unscheduled zone.
   MachineBasicBlock::iterator CurrentBottom;
 
   /// Record the next node in a scheduled cluster.
   const SUnit *NextClusterPred = nullptr;
   const SUnit *NextClusterSucc = nullptr;
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   /// The number of instructions scheduled so far. Used to cut off the
   /// scheduler at the point determined by misched-cutoff.
   unsigned NumInstrsScheduled = 0;
 #endif
 
 public:
   ScheduleDAGMI(MachineSchedContext *C, std::unique_ptr<MachineSchedStrategy> S,
                 bool RemoveKillFlags)
private:
 
   // For each PIdx, stores first index into ReservedCycles that corresponds to
   // it.
   SmallVector<unsigned, 16> ReservedCyclesIndex;
 
   // For each PIdx, stores the resource group IDs of its subunits
   SmallVector<APInt, 16> ResourceGroupSubUnitMasks;
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   // Remember the greatest possible stall as an upper bound on the number of
   // times we should retry the pending queue because of a hazard.
   unsigned MaxObservedStall;
 #endif
 
 public:
   /// Pending queues extend the ready queues with the same ID and the
   /// PendingFlag set.

llvm/include/llvm/CodeGen/PBQP/ReductionRules.h

Solution backpropagate(GraphT& G, StackT stack) {
     Solution s;
 
     while (!stack.empty()) {
       NodeId NId = stack.back();
       stack.pop_back();
 
       RawVector v = G.getNodeCosts(NId);
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
       // Although a conservatively allocatable node can be allocated to a register,
       // spilling it may provide a lower cost solution. Assert here that spilling
       // is done by choice, not because there were no register available.
       if (G.getNodeMetadata(NId).wasConservativelyAllocatable())
         assert(hasRegisterOptions(v) && "A conservatively allocatable node "
                                         "must have available register options");
 #endif
 

llvm/include/llvm/CodeGen/RegAllocPBQP.h

using ReductionState = enum {
     NotProvablyAllocatable,
     ConservativelyAllocatable,
     OptimallyReducible
   };
 
   NodeMetadata() = default;
 
   NodeMetadata(const NodeMetadata &Other)
     : RS(Other.RS), NumOpts(Other.NumOpts), DeniedOpts(Other.DeniedOpts),
       OptUnsafeEdges(new unsigned[NumOpts]), VReg(Other.VReg),
       AllowedRegs(Other.AllowedRegs)
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
       , everConservativelyAllocatable(Other.everConservativelyAllocatable)
 #endif
   {
     if (NumOpts > 0) {
       std::copy(&Other.OptUnsafeEdges[0], &Other.OptUnsafeEdges[NumOpts],
                 &OptUnsafeEdges[0]);
     }
   }
 
void setup(const Vector& Costs) {
     OptUnsafeEdges = std::unique_ptr<unsigned[]>(new unsigned[NumOpts]());
   }
 
   ReductionState getReductionState() const { return RS; }
   void setReductionState(ReductionState RS) {
     assert(RS >= this->RS && "A node's reduction state can not be downgraded");
     this->RS = RS;
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
     // Remember this state to assert later that a non-infinite register
     // option was available.
     if (RS == ConservativelyAllocatable)
       everConservativelyAllocatable = true;
 #endif
   }
 
   void handleAddEdge(const MatrixMetadata& MD, bool Transpose) {
#endif
   }
 
   bool isConservativelyAllocatable() const {
     return (DeniedOpts < NumOpts) ||
       (std::find(&OptUnsafeEdges[0], &OptUnsafeEdges[NumOpts], 0) !=
        &OptUnsafeEdges[NumOpts]);
   }
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   bool wasConservativelyAllocatable() const {
     return everConservativelyAllocatable;
   }
 #endif
 
 private:
   ReductionState RS = Unprocessed;
   unsigned NumOpts = 0;
   unsigned DeniedOpts = 0;
   std::unique_ptr<unsigned[]> OptUnsafeEdges;
   Register VReg;
   GraphMetadata::AllowedRegVecRef AllowedRegs;
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   bool everConservativelyAllocatable = false;
 #endif
 };
 
 class RegAllocSolverImpl {
 private:
   using RAMatrix = MDMatrix<MatrixMetadata>;
 

llvm/include/llvm/CodeGen/SelectionDAG.h

 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dumpDotGraph(const Twine &FileName, const Twine &Title);
 #endif
 
   /// Pop up a GraphViz/gv window with the DAG rendered using 'dot'.
   void viewGraph(const std::string &Title);
   void viewGraph();
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   std::map<const SDNode *, std::string> NodeGraphAttrs;
 #endif
 
   /// Clear all previously defined node graph attributes.
   /// Intended to be used from a debugging tool (eg. gdb).
   void clearGraphAttrs();
 
   /// Set graph attributes for a node. (eg. "color=red".)

llvm/lib/CodeGen/MachineScheduler.cpp

if (LIS)
     LIS->handleMove(*MI, /*UpdateFlags=*/true);
 
   // Recede RegionBegin if an instruction moves above the first.
   if (RegionBegin == InsertPos)
     RegionBegin = MI;
 }
 
 bool ScheduleDAGMI::checkSchedLimit() {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   if (NumInstrsScheduled == MISchedCutoff && MISchedCutoff != ~0U) {
     CurrentTop = CurrentBottom;
     return false;
   }
   ++NumInstrsScheduled;
 #endif
   return true;
 }
void SchedBoundary::reset() {
   DependentLatency = 0;
   RetiredMOps = 0;
   MaxExecutedResCount = 0;
   ZoneCritResIdx = 0;
   IsResourceLimited = false;
   ReservedCycles.clear();
   ReservedCyclesIndex.clear();
   ResourceGroupSubUnitMasks.clear();
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   // Track the maximum number of stall cycles that could arise either from the
   // latency of a DAG edge or the number of cycles that a processor resource is
   // reserved (SchedBoundary::ReservedCycles).
   MaxObservedStall = 0;
 #endif
   // Reserve a zero-count for invalid CritResIdx.
   ExecutedResCounts.resize(1);
   assert(!ExecutedResCounts[0] && "nonzero count for bad resource");
if (SchedModel->hasInstrSchedModel() && SU->hasReservedResource) {
     for (const MCWriteProcResEntry &PE :
           make_range(SchedModel->getWriteProcResBegin(SC),
                      SchedModel->getWriteProcResEnd(SC))) {
       unsigned ResIdx = PE.ProcResourceIdx;
       unsigned Cycles = PE.Cycles;
       unsigned NRCycle, InstanceIdx;
       std::tie(NRCycle, InstanceIdx) = getNextResourceCycle(SC, ResIdx, Cycles);
       if (NRCycle > CurrCycle) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
         MaxObservedStall = std::max(Cycles, MaxObservedStall);
 #endif
         LLVM_DEBUG(dbgs() << "  SU(" << SU->NodeNum << ") "
                           << SchedModel->getResourceName(ResIdx)
                           << '[' << InstanceIdx - ReservedCyclesIndex[ResIdx]  << ']'
                           << "=" << NRCycle << "c\n");
         return true;
       }
getOtherResourceCount(unsigned &OtherCritIdx) {
   }
   return OtherCritCount;
 }
 
 void SchedBoundary::releaseNode(SUnit *SU, unsigned ReadyCycle, bool InPQueue,
                                 unsigned Idx) {
   assert(SU->getInstr() && "Scheduled SUnit must have instr");
 
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   // ReadyCycle was been bumped up to the CurrCycle when this node was
   // scheduled, but CurrCycle may have been eagerly advanced immediately after
   // scheduling, so may now be greater than ReadyCycle.
   if (ReadyCycle > CurrCycle)
     MaxObservedStall = std::max(ReadyCycle - CurrCycle, MaxObservedStall);
 #endif
 
   if (ReadyCycle < MinReadyCycle)

llvm/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp

LLVM_DUMP_METHOD void SelectionDAG::dumpDotGraph(const Twine &FileName,
                                                  const Twine &Title) {
   dumpDotGraphToFile(this, FileName, Title);
 }
 #endif
 
 /// clearGraphAttrs - Clear all previously defined node graph attributes.
 /// Intended to be used from a debugging tool (eg. gdb).
 void SelectionDAG::clearGraphAttrs() {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   NodeGraphAttrs.clear();
 #else
-  errs() << "SelectionDAG::clearGraphAttrs is only available in debug builds"
-         << " on systems with Graphviz or gv!\n";
+  errs() << "SelectionDAG::clearGraphAttrs is only available in builds with "
+         << "ABI breaking checks enabled on systems with Graphviz or gv!\n";
 #endif
 }
 
 
 /// setGraphAttrs - Set graph attributes for a node. (eg. "color=red".)
 ///
 void SelectionDAG::setGraphAttrs(const SDNode *N, const char *Attrs) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   NodeGraphAttrs[N] = Attrs;
 #else
-  errs() << "SelectionDAG::setGraphAttrs is only available in debug builds"
-         << " on systems with Graphviz or gv!\n";
+  errs() << "SelectionDAG::setGraphAttrs is only available in builds with "
+         << "ABI breaking checks enabled on systems with Graphviz or gv!\n";
 #endif
 }
 
 
 /// getGraphAttrs - Get graph attributes for a node. (eg. "color=red".)
 /// Used from getNodeAttributes.
 std::string SelectionDAG::getGraphAttrs(const SDNode *N) const {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   std::map<const SDNode *, std::string>::const_iterator I =
     NodeGraphAttrs.find(N);
 
   if (I != NodeGraphAttrs.end())
     return I->second;
   else
     return "";
 #else
-  errs() << "SelectionDAG::getGraphAttrs is only available in debug builds"
-         << " on systems with Graphviz or gv!\n";
+  errs() << "SelectionDAG::getGraphAttrs is only available in builds with "
+         << "ABI breaking checks enabled on systems with Graphviz or gv!\n";
   return std::string();
 #endif
 }
 
 /// setGraphColor - Convenience for setting node color attribute.
 ///
 void SelectionDAG::setGraphColor(const SDNode *N, const char *Color) {
-#ifndef NDEBUG
+#if LLVM_ENABLE_ABI_BREAKING_CHECKS
   NodeGraphAttrs[N] = std::string("color=") + Color;
 #else
-  errs() << "SelectionDAG::setGraphColor is only available in debug builds"
-         << " on systems with Graphviz or gv!\n";
+  errs() << "SelectionDAG::setGraphColor is only available in builds with "
+         << "ABI breaking checks enabled on systems with Graphviz or gv!\n";
 #endif
 }
 
 /// setSubgraphColorHelper - Implement setSubgraphColor.  Return
 /// whether we truncated the search.
 ///
 bool SelectionDAG::setSubgraphColorHelper(SDNode *N, const char *Color, DenseSet<SDNode *> &visited,
                                           int level, bool &printed) {

llvm/lib/Target/SystemZ/SystemZHazardRecognizer.h

public:
   /// instructions this returns 0.
   int groupingCost(SUnit *SU) const;
 
   /// Return the cost of SU in regards to processor resources usage.
   /// A positive value means it would be better to wait with SU, while
   /// a negative value means it would be good to schedule SU next.
   int resourcesCost(SUnit *SU);
 
+  // TODO: place CurGroupDbg under #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 #ifndef NDEBUG
   // Debug dumping.
   std::string CurGroupDbg; // current group as text
   void dumpSU(SUnit *SU, raw_ostream &OS) const;
   void dumpCurrGroup(std::string Msg = "") const;
   void dumpProcResourceCounters() const;
   void dumpState() const;
 #endif

mlir/lib/Target/SPIRV/Deserialization/Deserializer.h

private:
 
   /// A list of IDs for all types forward-declared through OpTypeForwardPointer
   /// instructions.
   SetVector<uint32_t> typeForwardPointerIDs;
 
   /// A list of all structs which have unresolved member types.
   SmallVector<DeferredStructTypeInfo, 0> deferredStructTypesInfos;
 
+  // TODO: place logger under #if LLVM_ENABLE_ABI_BREAKING_CHECKS
 #ifndef NDEBUG
   /// A logger used to emit information during the deserialzation process.
   llvm::ScopedPrinter logger;
 #endif
 };
 
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_TARGET_SPIRV_DESERIALIZER_H