Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

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