Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Support/ScopedPrinter.h
Line
Count
Source (jump to first uncovered line)
1
//===-- ScopedPrinter.h ---------------------------------------------------===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
10
#ifndef LLVM_SUPPORT_SCOPEDPRINTER_H
11
#define LLVM_SUPPORT_SCOPEDPRINTER_H
12
13
#include "llvm/ADT/APSInt.h"
14
#include "llvm/ADT/ArrayRef.h"
15
#include "llvm/ADT/SmallVector.h"
16
#include "llvm/ADT/StringRef.h"
17
#include "llvm/Support/DataTypes.h"
18
#include "llvm/Support/Endian.h"
19
#include "llvm/Support/raw_ostream.h"
20
#include <algorithm>
21
22
namespace llvm {
23
24
template <typename T> struct EnumEntry {
25
  StringRef Name;
26
  // While Name suffices in most of the cases, in certain cases
27
  // GNU style and LLVM style of ELFDumper do not
28
  // display same string for same enum. The AltName if initialized appropriately
29
  // will hold the string that GNU style emits.
30
  // Example:
31
  // "EM_X86_64" string on LLVM style for Elf_Ehdr->e_machine corresponds to
32
  // "Advanced Micro Devices X86-64" on GNU style
33
  StringRef AltName;
34
  T Value;
35
  EnumEntry(StringRef N, StringRef A, T V) : Name(N), AltName(A), Value(V) {}
36
24.6M
  EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
llvm::EnumEntry<llvm::codeview::TypeLeafKind>::EnumEntry(llvm::StringRef, llvm::codeview::TypeLeafKind)
Line
Count
Source
36
16.3M
  EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
llvm::EnumEntry<unsigned short>::EnumEntry(llvm::StringRef, unsigned short)
Line
Count
Source
36
3.70M
  EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
llvm::EnumEntry<unsigned char>::EnumEntry(llvm::StringRef, unsigned char)
Line
Count
Source
36
4.60M
  EnumEntry(StringRef N, T V) : Name(N), AltName(N), Value(V) {}
37
};
38
39
struct HexNumber {
40
  // To avoid sign-extension we have to explicitly cast to the appropriate
41
  // unsigned type. The overloads are here so that every type that is implicitly
42
  // convertible to an integer (including enums and endian helpers) can be used
43
  // without requiring type traits or call-site changes.
44
0
  HexNumber(char Value) : Value(static_cast<unsigned char>(Value)) {}
45
0
  HexNumber(signed char Value) : Value(static_cast<unsigned char>(Value)) {}
46
0
  HexNumber(signed short Value) : Value(static_cast<unsigned short>(Value)) {}
47
1.39k
  HexNumber(signed int Value) : Value(static_cast<unsigned int>(Value)) {}
48
0
  HexNumber(signed long Value) : Value(static_cast<unsigned long>(Value)) {}
49
  HexNumber(signed long long Value)
50
0
      : Value(static_cast<unsigned long long>(Value)) {}
51
15.3k
  HexNumber(unsigned char Value) : Value(Value) {}
52
3.47k
  HexNumber(unsigned short Value) : Value(Value) {}
53
182k
  HexNumber(unsigned int Value) : Value(Value) {}
54
0
  HexNumber(unsigned long Value) : Value(Value) {}
55
407k
  HexNumber(unsigned long long Value) : Value(Value) {}
56
  uint64_t Value;
57
};
58
59
raw_ostream &operator<<(raw_ostream &OS, const HexNumber &Value);
60
const std::string to_hexString(uint64_t Value, bool UpperCase = true);
61
62
7.40k
template <class T> const std::string to_string(const T &Value) {
63
7.40k
  std::string number;
64
7.40k
  llvm::raw_string_ostream stream(number);
65
7.40k
  stream << Value;
66
7.40k
  return stream.str();
67
7.40k
}
68
69
class ScopedPrinter {
70
public:
71
2.43k
  ScopedPrinter(raw_ostream &OS) : OS(OS), IndentLevel(0) {}
72
73
0
  void flush() { OS.flush(); }
74
75
158k
  void indent(int Levels = 1) { IndentLevel += Levels; }
76
77
158k
  void unindent(int Levels = 1) {
78
158k
    IndentLevel = std::max(0, IndentLevel - Levels);
79
158k
  }
80
81
0
  void resetIndent() { IndentLevel = 0; }
82
83
215
  void setPrefix(StringRef P) { Prefix = P; }
84
85
2.06M
  void printIndent() {
86
2.06M
    OS << Prefix;
87
5.93M
    for (int i = 0; 
i < IndentLevel5.93M
;
++i3.87M
)
88
3.87M
      OS << "  ";
89
2.06M
  }
90
91
49.9k
  template <typename T> HexNumber hex(T Value) { return HexNumber(Value); }
llvm::HexNumber llvm::ScopedPrinter::hex<unsigned char>(unsigned char)
Line
Count
Source
91
15.3k
  template <typename T> HexNumber hex(T Value) { return HexNumber(Value); }
Unexecuted instantiation: llvm::HexNumber llvm::ScopedPrinter::hex<llvm::support::detail::packed_endian_specific_integral<unsigned short, (llvm::support::endianness)1, 1ul> >(llvm::support::detail::packed_endian_specific_integral<unsigned short, (llvm::support::endianness)1, 1ul>)
llvm::HexNumber llvm::ScopedPrinter::hex<unsigned long long>(unsigned long long)
Line
Count
Source
91
2.40k
  template <typename T> HexNumber hex(T Value) { return HexNumber(Value); }
llvm::HexNumber llvm::ScopedPrinter::hex<unsigned short>(unsigned short)
Line
Count
Source
91
2.51k
  template <typename T> HexNumber hex(T Value) { return HexNumber(Value); }
llvm::HexNumber llvm::ScopedPrinter::hex<unsigned int>(unsigned int)
Line
Count
Source
91
29.6k
  template <typename T> HexNumber hex(T Value) { return HexNumber(Value); }
llvm::HexNumber llvm::ScopedPrinter::hex<int>(int)
Line
Count
Source
91
15
  template <typename T> HexNumber hex(T Value) { return HexNumber(Value); }
92
93
  template <typename T, typename TEnum>
94
  void printEnum(StringRef Label, T Value,
95
16.0k
                 ArrayRef<EnumEntry<TEnum>> EnumValues) {
96
16.0k
    StringRef Name;
97
16.0k
    bool Found = false;
98
243k
    for (const auto &EnumItem : EnumValues) {
99
243k
      if (
EnumItem.Value == Value243k
) {
100
16.0k
        Name = EnumItem.Name;
101
16.0k
        Found = true;
102
16.0k
        break;
103
16.0k
      }
104
243k
    }
105
16.0k
106
16.0k
    if (
Found16.0k
) {
107
16.0k
      startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
108
16.0k
    } else {
109
0
      startLine() << Label << ": " << hex(Value) << "\n";
110
0
    }
111
16.0k
  }
void llvm::ScopedPrinter::printEnum<unsigned int, llvm::codeview::TypeLeafKind>(llvm::StringRef, unsigned int, llvm::ArrayRef<llvm::EnumEntry<llvm::codeview::TypeLeafKind> >)
Line
Count
Source
95
8.65k
                 ArrayRef<EnumEntry<TEnum>> EnumValues) {
96
8.65k
    StringRef Name;
97
8.65k
    bool Found = false;
98
212k
    for (const auto &EnumItem : EnumValues) {
99
212k
      if (
EnumItem.Value == Value212k
) {
100
8.65k
        Name = EnumItem.Name;
101
8.65k
        Found = true;
102
8.65k
        break;
103
8.65k
      }
104
212k
    }
105
8.65k
106
8.65k
    if (
Found8.65k
) {
107
8.65k
      startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
108
8.65k
    } else {
109
0
      startLine() << Label << ": " << hex(Value) << "\n";
110
0
    }
111
8.65k
  }
Unexecuted instantiation: void llvm::ScopedPrinter::printEnum<unsigned short, llvm::codeview::TypeLeafKind>(llvm::StringRef, unsigned short, llvm::ArrayRef<llvm::EnumEntry<llvm::codeview::TypeLeafKind> >)
void llvm::ScopedPrinter::printEnum<unsigned int, unsigned short>(llvm::StringRef, unsigned int, llvm::ArrayRef<llvm::EnumEntry<unsigned short> >)
Line
Count
Source
95
32
                 ArrayRef<EnumEntry<TEnum>> EnumValues) {
96
32
    StringRef Name;
97
32
    bool Found = false;
98
119
    for (const auto &EnumItem : EnumValues) {
99
119
      if (
EnumItem.Value == Value119
) {
100
32
        Name = EnumItem.Name;
101
32
        Found = true;
102
32
        break;
103
32
      }
104
119
    }
105
32
106
32
    if (
Found32
) {
107
32
      startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
108
32
    } else {
109
0
      startLine() << Label << ": " << hex(Value) << "\n";
110
0
    }
111
32
  }
void llvm::ScopedPrinter::printEnum<unsigned short, unsigned short>(llvm::StringRef, unsigned short, llvm::ArrayRef<llvm::EnumEntry<unsigned short> >)
Line
Count
Source
95
18
                 ArrayRef<EnumEntry<TEnum>> EnumValues) {
96
18
    StringRef Name;
97
18
    bool Found = false;
98
266
    for (const auto &EnumItem : EnumValues) {
99
266
      if (
EnumItem.Value == Value266
) {
100
18
        Name = EnumItem.Name;
101
18
        Found = true;
102
18
        break;
103
18
      }
104
266
    }
105
18
106
18
    if (
Found18
) {
107
18
      startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
108
18
    } else {
109
0
      startLine() << Label << ": " << hex(Value) << "\n";
110
0
    }
111
18
  }
void llvm::ScopedPrinter::printEnum<unsigned char, unsigned char>(llvm::StringRef, unsigned char, llvm::ArrayRef<llvm::EnumEntry<unsigned char> >)
Line
Count
Source
95
6.94k
                 ArrayRef<EnumEntry<TEnum>> EnumValues) {
96
6.94k
    StringRef Name;
97
6.94k
    bool Found = false;
98
27.4k
    for (const auto &EnumItem : EnumValues) {
99
27.4k
      if (
EnumItem.Value == Value27.4k
) {
100
6.94k
        Name = EnumItem.Name;
101
6.94k
        Found = true;
102
6.94k
        break;
103
6.94k
      }
104
27.4k
    }
105
6.94k
106
6.94k
    if (
Found6.94k
) {
107
6.94k
      startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
108
6.94k
    } else {
109
0
      startLine() << Label << ": " << hex(Value) << "\n";
110
0
    }
111
6.94k
  }
void llvm::ScopedPrinter::printEnum<unsigned int, unsigned char>(llvm::StringRef, unsigned int, llvm::ArrayRef<llvm::EnumEntry<unsigned char> >)
Line
Count
Source
95
438
                 ArrayRef<EnumEntry<TEnum>> EnumValues) {
96
438
    StringRef Name;
97
438
    bool Found = false;
98
2.95k
    for (const auto &EnumItem : EnumValues) {
99
2.95k
      if (
EnumItem.Value == Value2.95k
) {
100
438
        Name = EnumItem.Name;
101
438
        Found = true;
102
438
        break;
103
438
      }
104
2.95k
    }
105
438
106
438
    if (
Found438
) {
107
438
      startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
108
438
    } else {
109
0
      startLine() << Label << ": " << hex(Value) << "\n";
110
0
    }
111
438
  }
112
113
  template <typename T, typename TFlag>
114
  void printFlags(StringRef Label, T Value, ArrayRef<EnumEntry<TFlag>> Flags,
115
                  TFlag EnumMask1 = {}, TFlag EnumMask2 = {},
116
1.00k
                  TFlag EnumMask3 = {}) {
117
1.00k
    typedef EnumEntry<TFlag> FlagEntry;
118
1.00k
    typedef SmallVector<FlagEntry, 10> FlagVector;
119
1.00k
    FlagVector SetFlags;
120
1.00k
121
7.73k
    for (const auto &Flag : Flags) {
122
7.73k
      if (Flag.Value == 0)
123
0
        continue;
124
7.73k
125
7.73k
      TFlag EnumMask{};
126
7.73k
      if (Flag.Value & EnumMask1)
127
0
        EnumMask = EnumMask1;
128
7.73k
      else 
if (7.73k
Flag.Value & EnumMask27.73k
)
129
0
        EnumMask = EnumMask2;
130
7.73k
      else 
if (7.73k
Flag.Value & EnumMask37.73k
)
131
0
        EnumMask = EnumMask3;
132
7.73k
      bool IsEnum = (Flag.Value & EnumMask) != 0;
133
7.73k
      if (
(!IsEnum && 7.73k
(Value & Flag.Value) == Flag.Value7.73k
) ||
134
7.73k
          
(IsEnum && 6.79k
(Value & EnumMask) == Flag.Value0
)) {
135
938
        SetFlags.push_back(Flag);
136
938
      }
137
7.73k
    }
138
1.00k
139
1.00k
    std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>);
140
1.00k
141
1.00k
    startLine() << Label << " [ (" << hex(Value) << ")\n";
142
938
    for (const auto &Flag : SetFlags) {
143
938
      startLine() << "  " << Flag.Name << " (" << hex(Flag.Value) << ")\n";
144
938
    }
145
1.00k
    startLine() << "]\n";
146
1.00k
  }
void llvm::ScopedPrinter::printFlags<unsigned int, unsigned short>(llvm::StringRef, unsigned int, llvm::ArrayRef<llvm::EnumEntry<unsigned short> >, unsigned short, unsigned short, unsigned short)
Line
Count
Source
116
45
                  TFlag EnumMask3 = {}) {
117
45
    typedef EnumEntry<TFlag> FlagEntry;
118
45
    typedef SmallVector<FlagEntry, 10> FlagVector;
119
45
    FlagVector SetFlags;
120
45
121
225
    for (const auto &Flag : Flags) {
122
225
      if (Flag.Value == 0)
123
0
        continue;
124
225
125
225
      TFlag EnumMask{};
126
225
      if (Flag.Value & EnumMask1)
127
0
        EnumMask = EnumMask1;
128
225
      else 
if (225
Flag.Value & EnumMask2225
)
129
0
        EnumMask = EnumMask2;
130
225
      else 
if (225
Flag.Value & EnumMask3225
)
131
0
        EnumMask = EnumMask3;
132
225
      bool IsEnum = (Flag.Value & EnumMask) != 0;
133
225
      if (
(!IsEnum && 225
(Value & Flag.Value) == Flag.Value225
) ||
134
225
          
(IsEnum && 180
(Value & EnumMask) == Flag.Value0
)) {
135
45
        SetFlags.push_back(Flag);
136
45
      }
137
225
    }
138
45
139
45
    std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>);
140
45
141
45
    startLine() << Label << " [ (" << hex(Value) << ")\n";
142
45
    for (const auto &Flag : SetFlags) {
143
45
      startLine() << "  " << Flag.Name << " (" << hex(Flag.Value) << ")\n";
144
45
    }
145
45
    startLine() << "]\n";
146
45
  }
void llvm::ScopedPrinter::printFlags<unsigned short, unsigned short>(llvm::StringRef, unsigned short, llvm::ArrayRef<llvm::EnumEntry<unsigned short> >, unsigned short, unsigned short, unsigned short)
Line
Count
Source
116
500
                  TFlag EnumMask3 = {}) {
117
500
    typedef EnumEntry<TFlag> FlagEntry;
118
500
    typedef SmallVector<FlagEntry, 10> FlagVector;
119
500
    FlagVector SetFlags;
120
500
121
5.47k
    for (const auto &Flag : Flags) {
122
5.47k
      if (Flag.Value == 0)
123
0
        continue;
124
5.47k
125
5.47k
      TFlag EnumMask{};
126
5.47k
      if (Flag.Value & EnumMask1)
127
0
        EnumMask = EnumMask1;
128
5.47k
      else 
if (5.47k
Flag.Value & EnumMask25.47k
)
129
0
        EnumMask = EnumMask2;
130
5.47k
      else 
if (5.47k
Flag.Value & EnumMask35.47k
)
131
0
        EnumMask = EnumMask3;
132
5.47k
      bool IsEnum = (Flag.Value & EnumMask) != 0;
133
5.47k
      if (
(!IsEnum && 5.47k
(Value & Flag.Value) == Flag.Value5.47k
) ||
134
5.47k
          
(IsEnum && 4.72k
(Value & EnumMask) == Flag.Value0
)) {
135
748
        SetFlags.push_back(Flag);
136
748
      }
137
5.47k
    }
138
500
139
500
    std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>);
140
500
141
500
    startLine() << Label << " [ (" << hex(Value) << ")\n";
142
748
    for (const auto &Flag : SetFlags) {
143
748
      startLine() << "  " << Flag.Name << " (" << hex(Flag.Value) << ")\n";
144
748
    }
145
500
    startLine() << "]\n";
146
500
  }
void llvm::ScopedPrinter::printFlags<unsigned char, unsigned char>(llvm::StringRef, unsigned char, llvm::ArrayRef<llvm::EnumEntry<unsigned char> >, unsigned char, unsigned char, unsigned char)
Line
Count
Source
116
458
                  TFlag EnumMask3 = {}) {
117
458
    typedef EnumEntry<TFlag> FlagEntry;
118
458
    typedef SmallVector<FlagEntry, 10> FlagVector;
119
458
    FlagVector SetFlags;
120
458
121
2.02k
    for (const auto &Flag : Flags) {
122
2.02k
      if (Flag.Value == 0)
123
0
        continue;
124
2.02k
125
2.02k
      TFlag EnumMask{};
126
2.02k
      if (Flag.Value & EnumMask1)
127
0
        EnumMask = EnumMask1;
128
2.02k
      else 
if (2.02k
Flag.Value & EnumMask22.02k
)
129
0
        EnumMask = EnumMask2;
130
2.02k
      else 
if (2.02k
Flag.Value & EnumMask32.02k
)
131
0
        EnumMask = EnumMask3;
132
2.02k
      bool IsEnum = (Flag.Value & EnumMask) != 0;
133
2.02k
      if (
(!IsEnum && 2.02k
(Value & Flag.Value) == Flag.Value2.02k
) ||
134
2.02k
          
(IsEnum && 1.88k
(Value & EnumMask) == Flag.Value0
)) {
135
145
        SetFlags.push_back(Flag);
136
145
      }
137
2.02k
    }
138
458
139
458
    std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>);
140
458
141
458
    startLine() << Label << " [ (" << hex(Value) << ")\n";
142
145
    for (const auto &Flag : SetFlags) {
143
145
      startLine() << "  " << Flag.Name << " (" << hex(Flag.Value) << ")\n";
144
145
    }
145
458
    startLine() << "]\n";
146
458
  }
147
148
  template <typename T> void printFlags(StringRef Label, T Value) {
149
    startLine() << Label << " [ (" << hex(Value) << ")\n";
150
    uint64_t Flag = 1;
151
    uint64_t Curr = Value;
152
    while (Curr > 0) {
153
      if (Curr & 1)
154
        startLine() << "  " << hex(Flag) << "\n";
155
      Curr >>= 1;
156
      Flag <<= 1;
157
    }
158
    startLine() << "]\n";
159
  }
160
161
403k
  void printNumber(StringRef Label, uint64_t Value) {
162
403k
    startLine() << Label << ": " << Value << "\n";
163
403k
  }
164
165
284k
  void printNumber(StringRef Label, uint32_t Value) {
166
284k
    startLine() << Label << ": " << Value << "\n";
167
284k
  }
168
169
6.13k
  void printNumber(StringRef Label, uint16_t Value) {
170
6.13k
    startLine() << Label << ": " << Value << "\n";
171
6.13k
  }
172
173
1.42k
  void printNumber(StringRef Label, uint8_t Value) {
174
1.42k
    startLine() << Label << ": " << unsigned(Value) << "\n";
175
1.42k
  }
176
177
0
  void printNumber(StringRef Label, int64_t Value) {
178
0
    startLine() << Label << ": " << Value << "\n";
179
0
  }
180
181
139k
  void printNumber(StringRef Label, int32_t Value) {
182
139k
    startLine() << Label << ": " << Value << "\n";
183
139k
  }
184
185
0
  void printNumber(StringRef Label, int16_t Value) {
186
0
    startLine() << Label << ": " << Value << "\n";
187
0
  }
188
189
0
  void printNumber(StringRef Label, int8_t Value) {
190
0
    startLine() << Label << ": " << int(Value) << "\n";
191
0
  }
192
193
6.03k
  void printNumber(StringRef Label, const APSInt &Value) {
194
6.03k
    startLine() << Label << ": " << Value << "\n";
195
6.03k
  }
196
197
  void printBoolean(StringRef Label, bool Value) {
198
    startLine() << Label << ": " << (Value ? "Yes" : "No") << '\n';
199
  }
200
201
  template <typename... T> void printVersion(StringRef Label, T... Version) {
202
    startLine() << Label << ": ";
203
    printVersionInternal(Version...);
204
    getOStream() << "\n";
205
  }
206
207
  template <typename T> void printList(StringRef Label, const T &List) {
208
    startLine() << Label << ": [";
209
    bool Comma = false;
210
    for (const auto &Item : List) {
211
      if (Comma)
212
        OS << ", ";
213
      OS << Item;
214
      Comma = true;
215
    }
216
    OS << "]\n";
217
  }
218
219
  template <typename T, typename U>
220
  void printList(StringRef Label, const T &List, const U &Printer) {
221
    startLine() << Label << ": [";
222
    bool Comma = false;
223
    for (const auto &Item : List) {
224
      if (Comma)
225
        OS << ", ";
226
      Printer(OS, Item);
227
      Comma = true;
228
    }
229
    OS << "]\n";
230
  }
231
232
  template <typename T> void printHexList(StringRef Label, const T &List) {
233
    startLine() << Label << ": [";
234
    bool Comma = false;
235
    for (const auto &Item : List) {
236
      if (Comma)
237
        OS << ", ";
238
      OS << hex(Item);
239
      Comma = true;
240
    }
241
    OS << "]\n";
242
  }
243
244
7.41k
  template <typename T> void printHex(StringRef Label, T Value) {
245
7.41k
    startLine() << Label << ": " << hex(Value) << "\n";
246
7.41k
  }
void llvm::ScopedPrinter::printHex<unsigned int>(llvm::StringRef, unsigned int)
Line
Count
Source
244
5.02k
  template <typename T> void printHex(StringRef Label, T Value) {
245
5.02k
    startLine() << Label << ": " << hex(Value) << "\n";
246
5.02k
  }
void llvm::ScopedPrinter::printHex<int>(llvm::StringRef, int)
Line
Count
Source
244
15
  template <typename T> void printHex(StringRef Label, T Value) {
245
15
    startLine() << Label << ": " << hex(Value) << "\n";
246
15
  }
void llvm::ScopedPrinter::printHex<unsigned short>(llvm::StringRef, unsigned short)
Line
Count
Source
244
445
  template <typename T> void printHex(StringRef Label, T Value) {
245
445
    startLine() << Label << ": " << hex(Value) << "\n";
246
445
  }
void llvm::ScopedPrinter::printHex<unsigned long long>(llvm::StringRef, unsigned long long)
Line
Count
Source
244
1.92k
  template <typename T> void printHex(StringRef Label, T Value) {
245
1.92k
    startLine() << Label << ": " << hex(Value) << "\n";
246
1.92k
  }
247
248
6.31k
  template <typename T> void printHex(StringRef Label, StringRef Str, T Value) {
249
6.31k
    startLine() << Label << ": " << Str << " (" << hex(Value) << ")\n";
250
6.31k
  }
251
252
  template <typename T>
253
  void printSymbolOffset(StringRef Label, StringRef Symbol, T Value) {
254
    startLine() << Label << ": " << Symbol << '+' << hex(Value) << '\n';
255
  }
256
257
0
  void printString(StringRef Value) { startLine() << Value << "\n"; }
258
259
11.0k
  void printString(StringRef Label, StringRef Value) {
260
11.0k
    startLine() << Label << ": " << Value << "\n";
261
11.0k
  }
262
263
547
  void printString(StringRef Label, const std::string &Value) {
264
547
    startLine() << Label << ": " << Value << "\n";
265
547
  }
266
267
  template <typename T>
268
  void printNumber(StringRef Label, StringRef Str, T Value) {
269
    startLine() << Label << ": " << Str << " (" << Value << ")\n";
270
  }
271
272
0
  void printBinary(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value) {
273
0
    printBinaryImpl(Label, Str, Value, false);
274
0
  }
275
276
0
  void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) {
277
0
    auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
278
0
                          Value.size());
279
0
    printBinaryImpl(Label, Str, V, false);
280
0
  }
281
282
0
  void printBinary(StringRef Label, ArrayRef<uint8_t> Value) {
283
0
    printBinaryImpl(Label, StringRef(), Value, false);
284
0
  }
285
286
0
  void printBinary(StringRef Label, ArrayRef<char> Value) {
287
0
    auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
288
0
                          Value.size());
289
0
    printBinaryImpl(Label, StringRef(), V, false);
290
0
  }
291
292
0
  void printBinary(StringRef Label, StringRef Value) {
293
0
    auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
294
0
                          Value.size());
295
0
    printBinaryImpl(Label, StringRef(), V, false);
296
0
  }
297
298
  void printBinaryBlock(StringRef Label, ArrayRef<uint8_t> Value,
299
0
                        uint32_t StartOffset) {
300
0
    printBinaryImpl(Label, StringRef(), Value, true, StartOffset);
301
0
  }
302
303
0
  void printBinaryBlock(StringRef Label, ArrayRef<uint8_t> Value) {
304
0
    printBinaryImpl(Label, StringRef(), Value, true);
305
0
  }
306
307
2.02k
  void printBinaryBlock(StringRef Label, StringRef Value) {
308
2.02k
    auto V = makeArrayRef(reinterpret_cast<const uint8_t *>(Value.data()),
309
2.02k
                          Value.size());
310
2.02k
    printBinaryImpl(Label, StringRef(), V, true);
311
2.02k
  }
312
313
  template <typename T> void printObject(StringRef Label, const T &Value) {
314
    startLine() << Label << ": " << Value << "\n";
315
  }
316
317
2.06M
  raw_ostream &startLine() {
318
2.06M
    printIndent();
319
2.06M
    return OS;
320
2.06M
  }
321
322
308k
  raw_ostream &getOStream() { return OS; }
323
324
private:
325
  template <typename T> void printVersionInternal(T Value) {
326
    getOStream() << Value;
327
  }
328
329
  template <typename S, typename T, typename... TArgs>
330
  void printVersionInternal(S Value, T Value2, TArgs... Args) {
331
    getOStream() << Value << ".";
332
    printVersionInternal(Value2, Args...);
333
  }
334
335
  template <typename T>
336
401
  static bool flagName(const EnumEntry<T> &lhs, const EnumEntry<T> &rhs) {
337
401
    return lhs.Name < rhs.Name;
338
401
  }
bool llvm::ScopedPrinter::flagName<unsigned short>(llvm::EnumEntry<unsigned short> const&, llvm::EnumEntry<unsigned short> const&)
Line
Count
Source
336
389
  static bool flagName(const EnumEntry<T> &lhs, const EnumEntry<T> &rhs) {
337
389
    return lhs.Name < rhs.Name;
338
389
  }
bool llvm::ScopedPrinter::flagName<unsigned char>(llvm::EnumEntry<unsigned char> const&, llvm::EnumEntry<unsigned char> const&)
Line
Count
Source
336
12
  static bool flagName(const EnumEntry<T> &lhs, const EnumEntry<T> &rhs) {
337
12
    return lhs.Name < rhs.Name;
338
12
  }
339
340
  void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value,
341
                       bool Block, uint32_t StartOffset = 0);
342
343
  raw_ostream &OS;
344
  int IndentLevel;
345
  StringRef Prefix;
346
};
347
348
template <>
349
inline void
350
ScopedPrinter::printHex<support::ulittle16_t>(StringRef Label,
351
0
                                              support::ulittle16_t Value) {
352
0
  startLine() << Label << ": " << hex(Value) << "\n";
353
0
}
354
355
template<char Open, char Close>
356
struct DelimitedScope {
357
  explicit DelimitedScope(ScopedPrinter &W) : W(W) {
358
    W.startLine() << Open << '\n';
359
    W.indent();
360
  }
361
362
4.87k
  DelimitedScope(ScopedPrinter &W, StringRef N) : W(W) {
363
4.87k
    W.startLine() << N;
364
4.87k
    if (!N.empty())
365
4.87k
      W.getOStream() << ' ';
366
4.87k
    W.getOStream() << Open << '\n';
367
4.87k
    W.indent();
368
4.87k
  }
369
370
4.86k
  ~DelimitedScope() {
371
4.86k
    W.unindent();
372
4.86k
    W.startLine() << Close << '\n';
373
4.86k
  }
374
375
  ScopedPrinter &W;
376
};
377
378
using DictScope = DelimitedScope<'{', '}'>;
379
using ListScope = DelimitedScope<'[', ']'>;
380
381
} // namespace llvm
382
383
#endif