llvm/tools/llvm-pdbutil/FormatUtil.h

   1 //===- FormatUtil.h ------------------------------------------- *- C++ --*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_TOOLS_LLVMPDBUTIL_FORMAT_UTIL_H
  10 #define LLVM_TOOLS_LLVMPDBUTIL_FORMAT_UTIL_H
  11
  12 #include "llvm/ADT/ArrayRef.h"
  13 #include "llvm/ADT/StringRef.h"
  14 #include "llvm/DebugInfo/CodeView/CodeView.h"
  15 #include "llvm/Support/Endian.h"
  16 #include "llvm/Support/FormatAdapters.h"
  17 #include "llvm/Support/FormatVariadic.h"
  18
  19 #include <string>
  20 #include <type_traits>
  21
  22 namespace llvm {
  23 namespace pdb {
  24
  25 std::string truncateStringBack(StringRef S, uint32_t MaxLen);
  26 std::string truncateStringMiddle(StringRef S, uint32_t MaxLen);
  27 std::string truncateStringFront(StringRef S, uint32_t MaxLen);
  28 std::string truncateQuotedNameFront(StringRef Label, StringRef Name,
  29                                     uint32_t MaxLen);
  30 std::string truncateQuotedNameBack(StringRef Label, StringRef Name,
  31                                    uint32_t MaxLen);
  32
  33 #define PUSH_MASKED_FLAG(Enum, Mask, TheOpt, Value, Text)                      \
  34   if (Enum::TheOpt == (Value & Mask))                                          \
  35     Opts.push_back(Text);
  36
  37 #define PUSH_FLAG(Enum, TheOpt, Value, Text)                                   \
  38   PUSH_MASKED_FLAG(Enum, Enum::TheOpt, TheOpt, Value, Text)
  39
  40 #define RETURN_CASE(Enum, X, Ret)                                              \
  41   case Enum::X:                                                                \
  42     return Ret;
  43
  44 template <typename T> std::string formatUnknownEnum(T Value) {
  45   return formatv("unknown ({0})", static_cast<std::underlying_type_t<T>>(Value))
  46       .str();
  47 }
  48
  49 std::string formatSegmentOffset(uint16_t Segment, uint32_t Offset);
  50
  51 enum class CharacteristicStyle {
  52   HeaderDefinition, // format as windows header definition
  53   Descriptive,      // format as human readable words
  54 };
  55 std::string formatSectionCharacteristics(
  56     uint32_t IndentLevel, uint32_t C, uint32_t FlagsPerLine,
  57     StringRef Separator,
  58     CharacteristicStyle Style = CharacteristicStyle::HeaderDefinition);
  59
  60 std::string typesetItemList(ArrayRef<std::string> Opts, uint32_t IndentLevel,
  61                             uint32_t GroupSize, StringRef Sep);
  62
  63 std::string typesetStringList(uint32_t IndentLevel,
  64                               ArrayRef<StringRef> Strings);
  65
  66 std::string formatChunkKind(codeview::DebugSubsectionKind Kind,
  67                             bool Friendly = true);
  68 std::string formatSymbolKind(codeview::SymbolKind K);
  69 std::string formatTypeLeafKind(codeview::TypeLeafKind K);
  70
  71 /// Returns the number of digits in the given integer.
  72 inline int NumDigits(uint64_t N) {
  73   if (N < 10ULL)
  74     return 1;
  75   if (N < 100ULL)
  76     return 2;
  77   if (N < 1000ULL)
  78     return 3;
  79   if (N < 10000ULL)
  80     return 4;
  81   if (N < 100000ULL)
  82     return 5;
  83   if (N < 1000000ULL)
  84     return 6;
  85   if (N < 10000000ULL)
  86     return 7;
  87   if (N < 100000000ULL)
  88     return 8;
  89   if (N < 1000000000ULL)
  90     return 9;
  91   if (N < 10000000000ULL)
  92     return 10;
  93   if (N < 100000000000ULL)
  94     return 11;
  95   if (N < 1000000000000ULL)
  96     return 12;
  97   if (N < 10000000000000ULL)
  98     return 13;
  99   if (N < 100000000000000ULL)
 100     return 14;
 101   if (N < 1000000000000000ULL)
 102     return 15;
 103   if (N < 10000000000000000ULL)
 104     return 16;
 105   if (N < 100000000000000000ULL)
 106     return 17;
 107   if (N < 1000000000000000000ULL)
 108     return 18;
 109   if (N < 10000000000000000000ULL)
 110     return 19;
 111   return 20;
 112 }
 113
 114 namespace detail {
 115 template <typename T>
 116 struct EndianAdapter final
 117     : public FormatAdapter<support::detail::packed_endian_specific_integral<
 118           T, support::little, support::unaligned>> {
 119   using EndianType =
 120       support::detail::packed_endian_specific_integral<T, support::little,
 121                                                        support::unaligned>;
 122
 123   explicit EndianAdapter(EndianType &&Item)
 124       : FormatAdapter<EndianType>(std::move(Item)) {}
 125
 126   void format(llvm::raw_ostream &Stream, StringRef Style) override {
 127     format_provider<T>::format(static_cast<T>(this->Item), Stream, Style);
 128   }
 129 };
 130 } // namespace detail
 131
 132 template <typename T>
 133 detail::EndianAdapter<T>
 134 fmtle(support::detail::packed_endian_specific_integral<T, support::little,
 135                                                        support::unaligned>
 136           Value) {
 137   return detail::EndianAdapter<T>(std::move(Value));
 138 }
 139 }
 140 } // namespace llvm
 141 #endif