[Alignment][NFC] Allow to print alignment to raw_ostream

[gchatelet]

Summary

This is patch is part of a series to introduce an Alignment type.
See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2019-July/133851.html
See this patch for the introduction of the type: https://reviews.llvm.org/D64790

[courbet]

I'd rather have every user forced to think whether they want to use the value or its internal (log) representation, e.g. .p2align vs MIR format. If only for debug, then:

#ifndef NDEBUG
std::string Align::DebugStr() const {
  return "Align(" + value + ")";
}
#endif

WDYT ?

[gchatelet]

In D77386#1959463, @courbet wrote:

I'd rather have every user forced to think whether they want to use the value or its internal (log) representation, e.g. .p2align vs MIR format. If only for debug, then:

#ifndef NDEBUG
std::string Align::DebugStr() const {
  return "Align(" + value + ")";
}
#endif

WDYT ?

Sounds good to me, I was not absolutely convinced either.
The main motivation was indeed debugging for upcoming patches. I think it's better to resort on a DebugStr function then.

llvm/include/llvm/CodeGen/MIRYamlMapping.h

static void enumeration(yaml::IO &IO,
     IO.enumCase(EntryKind, "inline", MachineJumpTableInfo::EK_Inline);
     IO.enumCase(EntryKind, "custom32", MachineJumpTableInfo::EK_Custom32);
   }
 };
 
 template <> struct ScalarTraits<MaybeAlign> {
   static void output(const MaybeAlign &Alignment, void *,
                      llvm::raw_ostream &out) {
-    out << uint64_t(Alignment ? Alignment->value() : 0U);
+    out << Alignment;
   }
   static StringRef input(StringRef Scalar, void *, MaybeAlign &Alignment) {
     unsigned long long n;
     if (getAsUnsignedInteger(Scalar, 10, n))
       return "invalid number";
     if (n > 0 && !isPowerOf2_64(n))
       return "must be 0 or a power of two";
     Alignment = MaybeAlign(n);

llvm/include/llvm/Support/raw_ostream.h

 #include <cstdint>
 #include <cstring>
 #include <string>
 #include <system_error>
 #include <type_traits>
 
 namespace llvm {
 
+struct Align;
+struct MaybeAlign;
+
 class formatv_object_base;
 class format_object_base;
 class FormattedString;
 class FormattedNumber;
 class FormattedBytes;
 
 namespace sys {
 namespace fs {
raw_ostream &operator<<(int N) {
     return this->operator<<(static_cast<long>(N));
   }
 
   raw_ostream &operator<<(double N);
 
   /// Output \p N in hexadecimal, without any prefix or padding.
   raw_ostream &write_hex(unsigned long long N);
 
+  raw_ostream &operator<<(const Align &A);
+  raw_ostream &operator<<(const MaybeAlign &MA);
+
   // Change the foreground color of text.
   raw_ostream &operator<<(Colors C);
 
   /// Output a formatted UUID with dash separators.
   using uuid_t = uint8_t[16];
   raw_ostream &write_uuid(const uuid_t UUID);
 
   /// Output \p Str, turning '\\', '\t', '\n', '"', and anything that doesn't

llvm/lib/CodeGen/MIRPrinter.cpp

void MIPrinter::print(const MachineBasicBlock &MBB) {
   }
   if (MBB.isEHFuncletEntry()) {
     OS << (HasAttributes ? ", " : " (");
     OS << "ehfunclet-entry";
     HasAttributes = true;
   }
   if (MBB.getAlignment() != Align(1)) {
     OS << (HasAttributes ? ", " : " (");
-    OS << "align " << MBB.getAlignment().value();
+    OS << "align " << MBB.getAlignment();
     HasAttributes = true;
   }
   if (MBB.getSectionType() != MBBS_None) {
     OS << (HasAttributes ? ", " : " (");
     OS << "bbsections ";
     switch (MBB.getSectionType()) {
     case MBBS_Entry:
       OS << "Entry";

llvm/lib/CodeGen/MachineFrameInfo.cpp

if (MaxAlignment < Alignment)
     MaxAlignment = Alignment;
 }
 
 /// Clamp the alignment if requested and emit a warning.
 static inline Align clampStackAlignment(bool ShouldClamp, Align Alignment,
                                         Align StackAlignment) {
   if (!ShouldClamp || Alignment <= StackAlignment)
     return Alignment;
-  LLVM_DEBUG(dbgs() << "Warning: requested alignment " << Alignment.value()
-                    << " exceeds the stack alignment " << StackAlignment.value()
+  LLVM_DEBUG(dbgs() << "Warning: requested alignment " << Alignment
+                    << " exceeds the stack alignment " << StackAlignment
                     << " when stack realignment is off" << '\n');
   return StackAlignment;
 }
 
 int MachineFrameInfo::CreateStackObject(uint64_t Size, Align Alignment,
                                         bool IsSpillSlot,
                                         const AllocaInst *Alloca,
                                         uint8_t StackID) {
for (unsigned i = 0, e = Objects.size(); i != e; ++i) {
     if (SO.Size == ~0ULL) {
       OS << "dead\n";
       continue;
     }
     if (SO.Size == 0)
       OS << "variable sized";
     else
       OS << "size=" << SO.Size;
-    OS << ", align=" << SO.Alignment.value();
+    OS << ", align=" << SO.Alignment;
 
     if (i < NumFixedObjects)
       OS << ", fixed";
     if (i < NumFixedObjects || SO.SPOffset != -1) {
       int64_t Off = SO.SPOffset - ValOffset;
       OS << ", at location [SP";
       if (Off > 0)
         OS << "+" << Off;

llvm/lib/CodeGen/MachineOperand.cpp

default: {
       Formatter->printCustomPseudoSourceValue(OS, MST, *PVal);
       OS << '\"';
       break;
     }
     }
   }
   MachineOperand::printOperandOffset(OS, getOffset());
   if (getBaseAlign() != getSize())
-    OS << ", align " << getBaseAlign().value();
+    OS << ", align " << getBaseAlign();
   auto AAInfo = getAAInfo();
   if (AAInfo.TBAA) {
     OS << ", !tbaa ";
     AAInfo.TBAA->printAsOperand(OS, MST);
   }
   if (AAInfo.Scope) {
     OS << ", !alias.scope ";
     AAInfo.Scope->printAsOperand(OS, MST);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

LLVM_DEBUG(
                   "object size\n");
     return;
   }
   Align RequiredAlignment = AI->getAlign().getValueOr(
       FuncInfo.MF->getDataLayout().getABITypeAlign(AI->getAllocatedType()));
   if (MFI.getObjectAlign(FixedIndex) < RequiredAlignment) {
     LLVM_DEBUG(dbgs() << "  argument copy elision failed: alignment of alloca "
                          "greater than stack argument alignment ("
-                      << RequiredAlignment.value() << " vs "
-                      << MFI.getObjectAlign(FixedIndex).value() << ")\n");
+                      << RequiredAlignment << " vs "
+                      << MFI.getObjectAlign(FixedIndex) << ")\n");
     return;
   }
 
   // Perform the elision. Delete the old stack object and replace its only use
   // in the variable info map. Mark the stack object as mutable.
   LLVM_DEBUG({
     dbgs() << "Eliding argument copy from " << Arg << " to " << *AI << '\n'
            << "  Replacing frame index " << OldIndex << " with " << FixedIndex

llvm/lib/MC/MCFragment.cpp

case MCFragment::FT_LEB: {
     const auto *LF = cast<MCLEBFragment>(this);
     OS << "\n       ";
     OS << " Value:" << LF->getValue() << " Signed:" << LF->isSigned();
     break;
   }
   case MCFragment::FT_BoundaryAlign: {
     const auto *BF = cast<MCBoundaryAlignFragment>(this);
     OS << "\n       ";
-    OS << " BoundarySize:" << BF->getAlignment().value()
+    OS << " BoundarySize:" << BF->getAlignment()
        << " LastFragment:" << BF->getLastFragment()
        << " Size:" << BF->getSize();
     break;
   }
   case MCFragment::FT_SymbolId: {
     const auto *F = cast<MCSymbolIdFragment>(this);
     OS << "\n       ";
     OS << " Sym:" << F->getSymbol();

llvm/lib/Support/raw_ostream.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/config.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/NativeFormatting.h"
 #include "llvm/Support/Process.h"
raw_ostream &raw_ostream::operator<<(long long N) {
   return *this;
 }
 
 raw_ostream &raw_ostream::write_hex(unsigned long long N) {
   llvm::write_hex(*this, N, HexPrintStyle::Lower);
   return *this;
 }
 
+raw_ostream &raw_ostream::operator<<(const Align &A) {
+  return this->operator<<(A.value());
+}
+
+raw_ostream &raw_ostream::operator<<(const MaybeAlign &MA) {
+  return this->operator<<(uint64_t(MA ? MA->value() : 0U));
+}
+
 raw_ostream &raw_ostream::operator<<(Colors C) {
   if (C == Colors::RESET)
     resetColor();
   else
     changeColor(C);
   return *this;
 }
 

llvm/lib/Target/Mips/MipsRegisterInfo.cpp

eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj,
   int FrameIndex = MI.getOperand(FIOperandNum).getIndex();
   uint64_t stackSize = MF.getFrameInfo().getStackSize();
   int64_t spOffset = MF.getFrameInfo().getObjectOffset(FrameIndex);
 
   LLVM_DEBUG(errs() << "FrameIndex : " << FrameIndex << "\n"
                     << "spOffset   : " << spOffset << "\n"
                     << "stackSize  : " << stackSize << "\n"
                     << "alignment  : "
-                    << MF.getFrameInfo().getObjectAlign(FrameIndex).value()
-                    << "\n");
+                    << MF.getFrameInfo().getObjectAlign(FrameIndex) << "\n");
 
   eliminateFI(MI, FIOperandNum, FrameIndex, stackSize, spOffset);
 }
 
 Register MipsRegisterInfo::
 getFrameRegister(const MachineFunction &MF) const {
   const MipsSubtarget &Subtarget = MF.getSubtarget<MipsSubtarget>();
   const TargetFrameLowering *TFI = Subtarget.getFrameLowering();

llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp

if (!PAL.hasParamAttribute(paramIndex, Attribute::ByVal)) {
       if (Ty->isAggregateType() || Ty->isVectorTy() || Ty->isIntegerTy(128)) {
         // Just print .param .align <a> .b8 .param[size];
         // <a> = PAL.getparamalignment
         // size = typeallocsize of element type
         const Align align = DL.getValueOrABITypeAlignment(
             PAL.getParamAlignment(paramIndex), Ty);
 
         unsigned sz = DL.getTypeAllocSize(Ty);
-        O << "\t.param .align " << align.value() << " .b8 ";
+        O << "\t.param .align " << align << " .b8 ";
         printParamName(I, paramIndex, O);
         O << "[" << sz << "]";
 
         continue;
       }
       // Just a scalar
       auto *PTy = dyn_cast<PointerType>(Ty);
       if (isKernelFunc) {
if (isABI || isKernelFunc) {
       // prepare parameters for the call.
       //
       // TODO: this will need to be undone when we get to support multi-TU
       // device-side compilation as it breaks ABI compatibility with nvcc.
       // Hopefully ptxas bug is fixed by then.
       if (!isKernelFunc && align < Align(4))
         align = Align(4);
       unsigned sz = DL.getTypeAllocSize(ETy);
-      O << "\t.param .align " << align.value() << " .b8 ";
+      O << "\t.param .align " << align << " .b8 ";
       printParamName(I, paramIndex, O);
       O << "[" << sz << "]";
       continue;
     } else {
       // Split the ETy into constituent parts and
       // print .param .b<size> <name> for each part.
       // Further, if a part is vector, print the above for
       // each vector element.
void NVPTXAsmPrinter::setAndEmitFunctionVirtualRegisters(
   // virtual register number starting from 1 with that class.
   const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
   //unsigned numRegClasses = TRI->getNumRegClasses();
 
   // Emit the Fake Stack Object
   const MachineFrameInfo &MFI = MF.getFrameInfo();
   int NumBytes = (int) MFI.getStackSize();
   if (NumBytes) {
-    O << "\t.local .align " << MFI.getMaxAlign().value() << " .b8 \t"
-      << DEPOTNAME << getFunctionNumber() << "[" << NumBytes << "];\n";
+    O << "\t.local .align " << MFI.getMaxAlign() << " .b8 \t" << DEPOTNAME
+      << getFunctionNumber() << "[" << NumBytes << "];\n";
     if (static_cast<const NVPTXTargetMachine &>(MF.getTarget()).is64Bit()) {
       O << "\t.reg .b64 \t%SP;\n";
       O << "\t.reg .b64 \t%SPL;\n";
     } else {
       O << "\t.reg .b32 \t%SP;\n";
       O << "\t.reg .b32 \t%SPL;\n";
     }
   }

llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp

std::string NVPTXTargetLowering::getPrototype(
     ImmutableCallSite CS) const {
   auto PtrVT = getPointerTy(DL);
 
   bool isABI = (STI.getSmVersion() >= 20);
   assert(isABI && "Non-ABI compilation is not supported");
   if (!isABI)
     return "";
 
-  std::stringstream O;
+  std::string Buffer;
+  raw_string_ostream O(Buffer);
   O << "prototype_" << uniqueCallSite << " : .callprototype ";
 
   if (retTy->getTypeID() == Type::VoidTyID) {
     O << "()";
   } else {
     O << "(";
     if (retTy->isFloatingPointTy() || (retTy->isIntegerTy() && !retTy->isIntegerTy(128))) {
       unsigned size = 0;
if (retTy->isFloatingPointTy() || (retTy->isIntegerTy() && !retTy->isIntegerTy(128))) {
       if (size < 32)
         size = 32;
 
       O << ".param .b" << size << " _";
     } else if (isa<PointerType>(retTy)) {
       O << ".param .b" << PtrVT.getSizeInBits() << " _";
     } else if (retTy->isAggregateType() || retTy->isVectorTy() ||
                retTy->isIntegerTy(128)) {
-      O << ".param .align " << (retAlignment ? retAlignment->value() : 0)
-        << " .b8 _[" << DL.getTypeAllocSize(retTy) << "]";
+      O << ".param .align " << retAlignment << " .b8 _["
+        << DL.getTypeAllocSize(retTy) << "]";
     } else {
       llvm_unreachable("Unknown return type");
     }
     O << ") ";
   }
   O << "_ (";
 
   bool first = true;
if (!Outs[OIdx].Flags.isByVal()) {
       continue;
     }
     auto *PTy = dyn_cast<PointerType>(Ty);
     assert(PTy && "Param with byval attribute should be a pointer type");
     Type *ETy = PTy->getElementType();
 
     Align align = Outs[OIdx].Flags.getNonZeroByValAlign();
     unsigned sz = DL.getTypeAllocSize(ETy);
-    O << ".param .align " << align.value() << " .b8 ";
+    O << ".param .align " << align << " .b8 ";
     O << "_";
     O << "[" << sz << "]";
   }
   O << ");";
   return O.str();
 }
 
 Align NVPTXTargetLowering::getArgumentAlignment(SDValue Callee,