Coverage Report

Created: 2022-05-17 06:19

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Frontend/CompilerInvocation.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- CompilerInvocation.cpp ---------------------------------------------===//
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
#include "clang/Frontend/CompilerInvocation.h"
10
#include "TestModuleFileExtension.h"
11
#include "clang/Basic/Builtins.h"
12
#include "clang/Basic/CharInfo.h"
13
#include "clang/Basic/CodeGenOptions.h"
14
#include "clang/Basic/CommentOptions.h"
15
#include "clang/Basic/DebugInfoOptions.h"
16
#include "clang/Basic/Diagnostic.h"
17
#include "clang/Basic/DiagnosticDriver.h"
18
#include "clang/Basic/DiagnosticOptions.h"
19
#include "clang/Basic/FileSystemOptions.h"
20
#include "clang/Basic/LLVM.h"
21
#include "clang/Basic/LangOptions.h"
22
#include "clang/Basic/LangStandard.h"
23
#include "clang/Basic/ObjCRuntime.h"
24
#include "clang/Basic/Sanitizers.h"
25
#include "clang/Basic/SourceLocation.h"
26
#include "clang/Basic/TargetOptions.h"
27
#include "clang/Basic/Version.h"
28
#include "clang/Basic/Visibility.h"
29
#include "clang/Basic/XRayInstr.h"
30
#include "clang/Config/config.h"
31
#include "clang/Driver/Driver.h"
32
#include "clang/Driver/DriverDiagnostic.h"
33
#include "clang/Driver/Options.h"
34
#include "clang/Frontend/CommandLineSourceLoc.h"
35
#include "clang/Frontend/DependencyOutputOptions.h"
36
#include "clang/Frontend/FrontendDiagnostic.h"
37
#include "clang/Frontend/FrontendOptions.h"
38
#include "clang/Frontend/FrontendPluginRegistry.h"
39
#include "clang/Frontend/MigratorOptions.h"
40
#include "clang/Frontend/PreprocessorOutputOptions.h"
41
#include "clang/Frontend/TextDiagnosticBuffer.h"
42
#include "clang/Frontend/Utils.h"
43
#include "clang/Lex/HeaderSearchOptions.h"
44
#include "clang/Lex/PreprocessorOptions.h"
45
#include "clang/Sema/CodeCompleteOptions.h"
46
#include "clang/Serialization/ASTBitCodes.h"
47
#include "clang/Serialization/ModuleFileExtension.h"
48
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
49
#include "llvm/ADT/APInt.h"
50
#include "llvm/ADT/ArrayRef.h"
51
#include "llvm/ADT/CachedHashString.h"
52
#include "llvm/ADT/DenseSet.h"
53
#include "llvm/ADT/FloatingPointMode.h"
54
#include "llvm/ADT/Hashing.h"
55
#include "llvm/ADT/None.h"
56
#include "llvm/ADT/Optional.h"
57
#include "llvm/ADT/STLExtras.h"
58
#include "llvm/ADT/SmallString.h"
59
#include "llvm/ADT/SmallVector.h"
60
#include "llvm/ADT/StringRef.h"
61
#include "llvm/ADT/StringSwitch.h"
62
#include "llvm/ADT/Triple.h"
63
#include "llvm/ADT/Twine.h"
64
#include "llvm/Config/llvm-config.h"
65
#include "llvm/IR/DebugInfoMetadata.h"
66
#include "llvm/Linker/Linker.h"
67
#include "llvm/MC/MCTargetOptions.h"
68
#include "llvm/Option/Arg.h"
69
#include "llvm/Option/ArgList.h"
70
#include "llvm/Option/OptSpecifier.h"
71
#include "llvm/Option/OptTable.h"
72
#include "llvm/Option/Option.h"
73
#include "llvm/ProfileData/InstrProfReader.h"
74
#include "llvm/Remarks/HotnessThresholdParser.h"
75
#include "llvm/Support/CodeGen.h"
76
#include "llvm/Support/Compiler.h"
77
#include "llvm/Support/Error.h"
78
#include "llvm/Support/ErrorHandling.h"
79
#include "llvm/Support/ErrorOr.h"
80
#include "llvm/Support/FileSystem.h"
81
#include "llvm/Support/HashBuilder.h"
82
#include "llvm/Support/Host.h"
83
#include "llvm/Support/MathExtras.h"
84
#include "llvm/Support/MemoryBuffer.h"
85
#include "llvm/Support/Path.h"
86
#include "llvm/Support/Process.h"
87
#include "llvm/Support/Regex.h"
88
#include "llvm/Support/VersionTuple.h"
89
#include "llvm/Support/VirtualFileSystem.h"
90
#include "llvm/Support/raw_ostream.h"
91
#include "llvm/Target/TargetOptions.h"
92
#include <algorithm>
93
#include <atomic>
94
#include <cassert>
95
#include <cstddef>
96
#include <cstring>
97
#include <fstream>
98
#include <memory>
99
#include <string>
100
#include <tuple>
101
#include <type_traits>
102
#include <utility>
103
#include <vector>
104
105
using namespace clang;
106
using namespace driver;
107
using namespace options;
108
using namespace llvm::opt;
109
110
//===----------------------------------------------------------------------===//
111
// Helpers.
112
//===----------------------------------------------------------------------===//
113
114
// Parse misexpect tolerance argument value.
115
// Valid option values are integers in the range [0, 100)
116
70.3k
inline Expected<Optional<uint64_t>> parseToleranceOption(StringRef Arg) {
117
70.3k
  int64_t Val;
118
70.3k
  if (Arg.getAsInteger(10, Val))
119
0
    return llvm::createStringError(llvm::inconvertibleErrorCode(),
120
0
                                   "Not an integer: %s", Arg.data());
121
70.3k
  return Val;
122
70.3k
}
123
124
//===----------------------------------------------------------------------===//
125
// Initialization.
126
//===----------------------------------------------------------------------===//
127
128
CompilerInvocationRefBase::CompilerInvocationRefBase()
129
    : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
130
      DiagnosticOpts(new DiagnosticOptions()),
131
      HeaderSearchOpts(new HeaderSearchOptions()),
132
      PreprocessorOpts(new PreprocessorOptions()),
133
190k
      AnalyzerOpts(new AnalyzerOptions()) {}
134
135
CompilerInvocationRefBase::CompilerInvocationRefBase(
136
    const CompilerInvocationRefBase &X)
137
    : LangOpts(new LangOptions(*X.getLangOpts())),
138
      TargetOpts(new TargetOptions(X.getTargetOpts())),
139
      DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
140
      HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
141
      PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())),
142
12.7k
      AnalyzerOpts(new AnalyzerOptions(*X.getAnalyzerOpts())) {}
143
144
CompilerInvocationRefBase::CompilerInvocationRefBase(
145
308
    CompilerInvocationRefBase &&X) = default;
146
147
CompilerInvocationRefBase &
148
151
CompilerInvocationRefBase::operator=(CompilerInvocationRefBase X) {
149
151
  LangOpts.swap(X.LangOpts);
150
151
  TargetOpts.swap(X.TargetOpts);
151
151
  DiagnosticOpts.swap(X.DiagnosticOpts);
152
151
  HeaderSearchOpts.swap(X.HeaderSearchOpts);
153
151
  PreprocessorOpts.swap(X.PreprocessorOpts);
154
151
  AnalyzerOpts.swap(X.AnalyzerOpts);
155
151
  return *this;
156
151
}
157
158
CompilerInvocationRefBase &
159
0
CompilerInvocationRefBase::operator=(CompilerInvocationRefBase &&X) = default;
160
161
197k
CompilerInvocationRefBase::~CompilerInvocationRefBase() = default;
162
163
//===----------------------------------------------------------------------===//
164
// Normalizers
165
//===----------------------------------------------------------------------===//
166
167
#define SIMPLE_ENUM_VALUE_TABLE
168
#include "clang/Driver/Options.inc"
169
#undef SIMPLE_ENUM_VALUE_TABLE
170
171
static llvm::Optional<bool> normalizeSimpleFlag(OptSpecifier Opt,
172
                                                unsigned TableIndex,
173
                                                const ArgList &Args,
174
31.6M
                                                DiagnosticsEngine &Diags) {
175
31.6M
  if (Args.hasArg(Opt))
176
229k
    return true;
177
31.4M
  return None;
178
31.6M
}
179
180
static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned,
181
                                                  const ArgList &Args,
182
3.47M
                                                  DiagnosticsEngine &) {
183
3.47M
  if (Args.hasArg(Opt))
184
70.7k
    return false;
185
3.40M
  return None;
186
3.47M
}
187
188
/// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but
189
/// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with
190
/// unnecessary template instantiations and just ignore it with a variadic
191
/// argument.
192
static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args,
193
                                  const char *Spelling,
194
                                  CompilerInvocation::StringAllocator,
195
974k
                                  Option::OptionClass, unsigned, /*T*/...) {
196
974k
  Args.push_back(Spelling);
197
974k
}
198
199
0
template <typename T> static constexpr bool is_uint64_t_convertible() {
200
0
  return !std::is_same<T, uint64_t>::value &&
201
0
         llvm::is_integral_or_enum<T>::value;
202
0
}
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<unsigned long long>()
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<clang::DependencyOutputFormat>()
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<clang::FrontendOptions::'unnamed0'>()
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<llvm::RoundingMode>()
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<clang::DisableValidationForModuleKind>()
203
204
template <typename T,
205
          std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>
206
2.53M
static auto makeFlagToValueNormalizer(T Value) {
207
2.53M
  return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,
208
2.53M
                 DiagnosticsEngine &) -> Optional<T> {
209
2.53M
    if (Args.hasArg(Opt))
210
203
      return Value;
211
2.53M
    return None;
212
2.53M
  };
213
2.53M
}
214
215
template <typename T,
216
          std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false>
217
2.53M
static auto makeFlagToValueNormalizer(T Value) {
218
2.53M
  return makeFlagToValueNormalizer(uint64_t(Value));
219
2.53M
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<llvm::RoundingMode, false>(llvm::RoundingMode)
Line
Count
Source
217
140k
static auto makeFlagToValueNormalizer(T Value) {
218
140k
  return makeFlagToValueNormalizer(uint64_t(Value));
219
140k
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::FrontendOptions::'unnamed0', false>(clang::FrontendOptions::'unnamed0')
Line
Count
Source
217
2.11M
static auto makeFlagToValueNormalizer(T Value) {
218
2.11M
  return makeFlagToValueNormalizer(uint64_t(Value));
219
2.11M
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::DisableValidationForModuleKind, false>(clang::DisableValidationForModuleKind)
Line
Count
Source
217
140k
static auto makeFlagToValueNormalizer(T Value) {
218
140k
  return makeFlagToValueNormalizer(uint64_t(Value));
219
140k
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::DependencyOutputFormat, false>(clang::DependencyOutputFormat)
Line
Count
Source
217
140k
static auto makeFlagToValueNormalizer(T Value) {
218
140k
  return makeFlagToValueNormalizer(uint64_t(Value));
219
140k
}
220
221
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue,
222
29.1M
                                        OptSpecifier OtherOpt) {
223
29.1M
  return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned,
224
29.1M
                                       const ArgList &Args,
225
29.1M
                                       DiagnosticsEngine &) -> Optional<bool> {
226
29.1M
    if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
227
765k
      return A->getOption().matches(Opt) ? 
Value538k
:
OtherValue226k
;
228
765k
    }
229
28.3M
    return None;
230
29.1M
  };
231
29.1M
}
232
233
763k
static auto makeBooleanOptionDenormalizer(bool Value) {
234
763k
  return [Value](SmallVectorImpl<const char *> &Args, const char *Spelling,
235
763k
                 CompilerInvocation::StringAllocator, Option::OptionClass,
236
763k
                 unsigned, bool KeyPath) {
237
763k
    if (KeyPath == Value)
238
537k
      Args.push_back(Spelling);
239
763k
  };
240
763k
}
241
242
static void denormalizeStringImpl(SmallVectorImpl<const char *> &Args,
243
                                  const char *Spelling,
244
                                  CompilerInvocation::StringAllocator SA,
245
                                  Option::OptionClass OptClass, unsigned,
246
3.14M
                                  const Twine &Value) {
247
3.14M
  switch (OptClass) {
248
815k
  case Option::SeparateClass:
249
1.93M
  case Option::JoinedOrSeparateClass:
250
1.93M
  case Option::JoinedAndSeparateClass:
251
1.93M
    Args.push_back(Spelling);
252
1.93M
    Args.push_back(SA(Value));
253
1.93M
    break;
254
1.19M
  case Option::JoinedClass:
255
1.21M
  case Option::CommaJoinedClass:
256
1.21M
    Args.push_back(SA(Twine(Spelling) + Value));
257
1.21M
    break;
258
0
  default:
259
0
    llvm_unreachable("Cannot denormalize an option with option class "
260
3.14M
                     "incompatible with string denormalization.");
261
3.14M
  }
262
3.14M
}
263
264
template <typename T>
265
static void
266
denormalizeString(SmallVectorImpl<const char *> &Args, const char *Spelling,
267
                  CompilerInvocation::StringAllocator SA,
268
3.14M
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
3.14M
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
3.14M
}
CompilerInvocation.cpp:void denormalizeString<llvm::Twine>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, llvm::Twine)
Line
Count
Source
268
1.87M
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
1.87M
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
1.87M
}
CompilerInvocation.cpp:void denormalizeString<unsigned int>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, unsigned int)
Line
Count
Source
268
231k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
231k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
231k
}
CompilerInvocation.cpp:void denormalizeString<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
Line
Count
Source
268
868k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
868k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
868k
}
CompilerInvocation.cpp:void denormalizeString<char const*>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, char const*)
Line
Count
Source
268
169k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
169k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
169k
}
CompilerInvocation.cpp:void denormalizeString<int>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, int)
Line
Count
Source
268
20
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
20
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
20
}
CompilerInvocation.cpp:void denormalizeString<unsigned long long>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, unsigned long long)
Line
Count
Source
268
22
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
22
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
22
}
271
272
static Optional<SimpleEnumValue>
273
202k
findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name) {
274
309k
  for (int I = 0, E = Table.Size; I != E; 
++I106k
)
275
309k
    if (Name == Table.Table[I].Name)
276
202k
      return Table.Table[I];
277
278
10
  return None;
279
202k
}
280
281
static Optional<SimpleEnumValue>
282
169k
findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) {
283
235k
  for (int I = 0, E = Table.Size; I != E; 
++I66.1k
)
284
235k
    if (Value == Table.Table[I].Value)
285
169k
      return Table.Table[I];
286
287
18.4E
  return None;
288
169k
}
289
290
static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt,
291
                                                    unsigned TableIndex,
292
                                                    const ArgList &Args,
293
5.62M
                                                    DiagnosticsEngine &Diags) {
294
5.62M
  assert(TableIndex < SimpleEnumValueTablesSize);
295
0
  const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
296
297
5.62M
  auto *Arg = Args.getLastArg(Opt);
298
5.62M
  if (!Arg)
299
5.42M
    return None;
300
301
203k
  StringRef ArgValue = Arg->getValue();
302
203k
  if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue))
303
202k
    return MaybeEnumVal->Value;
304
305
139
  Diags.Report(diag::err_drv_invalid_value)
306
139
      << Arg->getAsString(Args) << ArgValue;
307
139
  return None;
308
203k
}
309
310
static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args,
311
                                      const char *Spelling,
312
                                      CompilerInvocation::StringAllocator SA,
313
                                      Option::OptionClass OptClass,
314
169k
                                      unsigned TableIndex, unsigned Value) {
315
169k
  assert(TableIndex < SimpleEnumValueTablesSize);
316
0
  const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
317
169k
  if (auto 
MaybeEnumVal169k
= findValueTableByValue(Table, Value)) {
318
169k
    denormalizeString(Args, Spelling, SA, OptClass, TableIndex,
319
169k
                      MaybeEnumVal->Name);
320
18.4E
  } else {
321
18.4E
    llvm_unreachable("The simple enum value was not correctly defined in "
322
18.4E
                     "the tablegen option description");
323
18.4E
  }
324
169k
}
325
326
template <typename T>
327
static void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args,
328
                                  const char *Spelling,
329
                                  CompilerInvocation::StringAllocator SA,
330
                                  Option::OptionClass OptClass,
331
169k
                                  unsigned TableIndex, T Value) {
332
169k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
169k
                                   static_cast<unsigned>(Value));
334
169k
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<unsigned int>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, unsigned int)
Line
Count
Source
331
145k
                                  unsigned TableIndex, T Value) {
332
145k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
145k
                                   static_cast<unsigned>(Value));
334
145k
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<llvm::Reloc::Model>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, llvm::Reloc::Model)
Line
Count
Source
331
21.3k
                                  unsigned TableIndex, T Value) {
332
21.3k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
21.3k
                                   static_cast<unsigned>(Value));
334
21.3k
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::LangOptions::GPUDefaultStreamKind>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::LangOptions::GPUDefaultStreamKind)
Line
Count
Source
331
6
                                  unsigned TableIndex, T Value) {
332
6
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
6
                                   static_cast<unsigned>(Value));
334
6
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::LangOptions::CoreFoundationABI>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::LangOptions::CoreFoundationABI)
Line
Count
Source
331
48
                                  unsigned TableIndex, T Value) {
332
48
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
48
                                   static_cast<unsigned>(Value));
334
48
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::FrontendOptions::'unnamed'>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::FrontendOptions::'unnamed')
Line
Count
Source
331
50
                                  unsigned TableIndex, T Value) {
332
50
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
50
                                   static_cast<unsigned>(Value));
334
50
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<llvm::EABI>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, llvm::EABI)
Line
Count
Source
331
58
                                  unsigned TableIndex, T Value) {
332
58
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
58
                                   static_cast<unsigned>(Value));
334
58
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::TargetOptions::CodeObjectVersionKind>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::TargetOptions::CodeObjectVersionKind)
Line
Count
Source
331
10
                                  unsigned TableIndex, T Value) {
332
10
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
10
                                   static_cast<unsigned>(Value));
334
10
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::ObjCXXARCStandardLibraryKind>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
331
2.77k
                                  unsigned TableIndex, T Value) {
332
2.77k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
2.77k
                                   static_cast<unsigned>(Value));
334
2.77k
}
335
336
static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex,
337
                                             const ArgList &Args,
338
8.35M
                                             DiagnosticsEngine &Diags) {
339
8.35M
  auto *Arg = Args.getLastArg(Opt);
340
8.35M
  if (!Arg)
341
7.77M
    return None;
342
580k
  return std::string(Arg->getValue());
343
8.35M
}
344
345
template <typename IntTy>
346
static Optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int,
347
                                               const ArgList &Args,
348
7.67M
                                               DiagnosticsEngine &Diags) {
349
7.67M
  auto *Arg = Args.getLastArg(Opt);
350
7.67M
  if (!Arg)
351
7.44M
    return None;
352
232k
  IntTy Res;
353
232k
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354
5
    Diags.Report(diag::err_drv_invalid_int_value)
355
5
        << Arg->getAsString(Args) << Arg->getValue();
356
5
    return None;
357
5
  }
358
232k
  return Res;
359
232k
}
CompilerInvocation.cpp:llvm::Optional<unsigned long long> normalizeStringIntegral<unsigned long long>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
348
140k
                                               DiagnosticsEngine &Diags) {
349
140k
  auto *Arg = Args.getLastArg(Opt);
350
140k
  if (!Arg)
351
140k
    return None;
352
28
  IntTy Res;
353
28
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354
0
    Diags.Report(diag::err_drv_invalid_int_value)
355
0
        << Arg->getAsString(Args) << Arg->getValue();
356
0
    return None;
357
0
  }
358
28
  return Res;
359
28
}
CompilerInvocation.cpp:llvm::Optional<unsigned int> normalizeStringIntegral<unsigned int>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
348
7.25M
                                               DiagnosticsEngine &Diags) {
349
7.25M
  auto *Arg = Args.getLastArg(Opt);
350
7.25M
  if (!Arg)
351
7.02M
    return None;
352
232k
  IntTy Res;
353
232k
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354
5
    Diags.Report(diag::err_drv_invalid_int_value)
355
5
        << Arg->getAsString(Args) << Arg->getValue();
356
5
    return None;
357
5
  }
358
232k
  return Res;
359
232k
}
CompilerInvocation.cpp:llvm::Optional<int> normalizeStringIntegral<int>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
348
281k
                                               DiagnosticsEngine &Diags) {
349
281k
  auto *Arg = Args.getLastArg(Opt);
350
281k
  if (!Arg)
351
281k
    return None;
352
28
  IntTy Res;
353
28
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354
0
    Diags.Report(diag::err_drv_invalid_int_value)
355
0
        << Arg->getAsString(Args) << Arg->getValue();
356
0
    return None;
357
0
  }
358
28
  return Res;
359
28
}
360
361
static Optional<std::vector<std::string>>
362
normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args,
363
3.56M
                      DiagnosticsEngine &) {
364
3.56M
  return Args.getAllArgValues(Opt);
365
3.56M
}
366
367
static void denormalizeStringVector(SmallVectorImpl<const char *> &Args,
368
                                    const char *Spelling,
369
                                    CompilerInvocation::StringAllocator SA,
370
                                    Option::OptionClass OptClass,
371
                                    unsigned TableIndex,
372
116k
                                    const std::vector<std::string> &Values) {
373
116k
  switch (OptClass) {
374
31.2k
  case Option::CommaJoinedClass: {
375
31.2k
    std::string CommaJoinedValue;
376
31.2k
    if (!Values.empty()) {
377
31.2k
      CommaJoinedValue.append(Values.front());
378
31.2k
      for (const std::string &Value : llvm::drop_begin(Values, 1)) {
379
316
        CommaJoinedValue.append(",");
380
316
        CommaJoinedValue.append(Value);
381
316
      }
382
31.2k
    }
383
31.2k
    denormalizeString(Args, Spelling, SA, Option::OptionClass::JoinedClass,
384
31.2k
                      TableIndex, CommaJoinedValue);
385
31.2k
    break;
386
0
  }
387
591
  case Option::JoinedClass:
388
78.1k
  case Option::SeparateClass:
389
84.9k
  case Option::JoinedOrSeparateClass:
390
84.9k
    for (const std::string &Value : Values)
391
121k
      denormalizeString(Args, Spelling, SA, OptClass, TableIndex, Value);
392
84.9k
    break;
393
0
  default:
394
0
    llvm_unreachable("Cannot denormalize an option with option class "
395
116k
                     "incompatible with string vector denormalization.");
396
116k
  }
397
116k
}
398
399
static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex,
400
                                             const ArgList &Args,
401
281k
                                             DiagnosticsEngine &Diags) {
402
281k
  auto *Arg = Args.getLastArg(Opt);
403
281k
  if (!Arg)
404
155k
    return None;
405
126k
  return llvm::Triple::normalize(Arg->getValue());
406
281k
}
407
408
template <typename T, typename U>
409
98.9M
static T mergeForwardValue(T KeyPath, U Value) {
410
98.9M
  return static_cast<T>(Value);
411
98.9M
}
CompilerInvocation.cpp:clang::FrontendOptions::'unnamed' mergeForwardValue<clang::FrontendOptions::'unnamed', clang::FrontendOptions::'unnamed'>(clang::FrontendOptions::'unnamed', clang::FrontendOptions::'unnamed')
Line
Count
Source
409
141k
static T mergeForwardValue(T KeyPath, U Value) {
410
141k
  return static_cast<T>(Value);
411
141k
}
CompilerInvocation.cpp:llvm::EABI mergeForwardValue<llvm::EABI, llvm::EABI>(llvm::EABI, llvm::EABI)
Line
Count
Source
409
141k
static T mergeForwardValue(T KeyPath, U Value) {
410
141k
  return static_cast<T>(Value);
411
141k
}
CompilerInvocation.cpp:clang::TargetOptions::CodeObjectVersionKind mergeForwardValue<clang::TargetOptions::CodeObjectVersionKind, clang::TargetOptions::CodeObjectVersionKind>(clang::TargetOptions::CodeObjectVersionKind, clang::TargetOptions::CodeObjectVersionKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned long long mergeForwardValue<unsigned long long, int>(unsigned long long, int)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned long long mergeForwardValue<unsigned long long, unsigned long long>(unsigned long long, unsigned long long)
Line
Count
Source
409
22
static T mergeForwardValue(T KeyPath, U Value) {
410
22
  return static_cast<T>(Value);
411
22
}
CompilerInvocation.cpp:clang::ObjCXXARCStandardLibraryKind mergeForwardValue<clang::ObjCXXARCStandardLibraryKind, clang::ObjCXXARCStandardLibraryKind>(clang::ObjCXXARCStandardLibraryKind, clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:clang::DisableValidationForModuleKind mergeForwardValue<clang::DisableValidationForModuleKind, clang::DisableValidationForModuleKind>(clang::DisableValidationForModuleKind, clang::DisableValidationForModuleKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:clang::DependencyOutputFormat mergeForwardValue<clang::DependencyOutputFormat, clang::DependencyOutputFormat>(clang::DependencyOutputFormat, clang::DependencyOutputFormat)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, bool>(unsigned int, bool)
Line
Count
Source
409
62.1M
static T mergeForwardValue(T KeyPath, U Value) {
410
62.1M
  return static_cast<T>(Value);
411
62.1M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, unsigned int>(unsigned int, unsigned int)
Line
Count
Source
409
3.83M
static T mergeForwardValue(T KeyPath, U Value) {
410
3.83M
  return static_cast<T>(Value);
411
3.83M
}
CompilerInvocation.cpp:std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > mergeForwardValue<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
Line
Count
Source
409
9.34M
static T mergeForwardValue(T KeyPath, U Value) {
410
9.34M
  return static_cast<T>(Value);
411
9.34M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, int>(unsigned int, int)
Line
Count
Source
409
6.60M
static T mergeForwardValue(T KeyPath, U Value) {
410
6.60M
  return static_cast<T>(Value);
411
6.60M
}
CompilerInvocation.cpp:bool mergeForwardValue<bool, bool>(bool, bool)
Line
Count
Source
409
1.83M
static T mergeForwardValue(T KeyPath, U Value) {
410
1.83M
  return static_cast<T>(Value);
411
1.83M
}
CompilerInvocation.cpp:std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > mergeForwardValue<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >)
Line
Count
Source
409
7.13M
static T mergeForwardValue(T KeyPath, U Value) {
410
7.13M
  return static_cast<T>(Value);
411
7.13M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::EmbedBitcodeKind>(unsigned int, clang::CodeGenOptions::EmbedBitcodeKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::SwiftAsyncFramePointerKind>(unsigned int, clang::CodeGenOptions::SwiftAsyncFramePointerKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::AsanDetectStackUseAfterReturnMode>(unsigned int, llvm::AsanDetectStackUseAfterReturnMode)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::AsanDtorKind>(unsigned int, llvm::AsanDtorKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::VectorLibrary>(unsigned int, clang::CodeGenOptions::VectorLibrary)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::TLSModel>(unsigned int, clang::CodeGenOptions::TLSModel)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > mergeForwardValue<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const*>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const*)
Line
Count
Source
409
563k
static T mergeForwardValue(T KeyPath, U Value) {
410
563k
  return static_cast<T>(Value);
411
563k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind>(unsigned int, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::InlineAsmDialectKind>(unsigned int, clang::CodeGenOptions::InlineAsmDialectKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::DebuggerKind>(unsigned int, llvm::DebuggerKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::DebugCompressionType>(unsigned int, llvm::DebugCompressionType)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:llvm::Reloc::Model mergeForwardValue<llvm::Reloc::Model, llvm::Reloc::Model>(llvm::Reloc::Model, llvm::Reloc::Model)
Line
Count
Source
409
187k
static T mergeForwardValue(T KeyPath, U Value) {
410
187k
  return static_cast<T>(Value);
411
187k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::FramePointerKind>(unsigned int, clang::CodeGenOptions::FramePointerKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::ProfileInstrKind>(unsigned int, clang::CodeGenOptions::ProfileInstrKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::ObjCDispatchMethodKind>(unsigned int, clang::CodeGenOptions::ObjCDispatchMethodKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::OverloadsShown>(unsigned int, clang::OverloadsShown)
Line
Count
Source
409
185k
static T mergeForwardValue(T KeyPath, U Value) {
410
185k
  return static_cast<T>(Value);
411
185k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::DiagnosticOptions::TextDiagnosticFormat>(unsigned int, clang::DiagnosticOptions::TextDiagnosticFormat)
Line
Count
Source
409
185k
static T mergeForwardValue(T KeyPath, U Value) {
410
185k
  return static_cast<T>(Value);
411
185k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::DiagnosticOptions::'unnamed'>(unsigned int, clang::DiagnosticOptions::'unnamed')
Line
Count
Source
409
1.11M
static T mergeForwardValue(T KeyPath, U Value) {
410
1.11M
  return static_cast<T>(Value);
411
1.11M
}
CompilerInvocation.cpp:clang::LangOptions::GPUDefaultStreamKind mergeForwardValue<clang::LangOptions::GPUDefaultStreamKind, clang::LangOptions::GPUDefaultStreamKind>(clang::LangOptions::GPUDefaultStreamKind, clang::LangOptions::GPUDefaultStreamKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:clang::LangOptions::CoreFoundationABI mergeForwardValue<clang::LangOptions::CoreFoundationABI, clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI, clang::LangOptions::CoreFoundationABI)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ExceptionHandlingKind>(unsigned int, clang::LangOptions::ExceptionHandlingKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::FPEvalMethodKind>(unsigned int, clang::LangOptions::FPEvalMethodKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::FPExceptionModeKind>(unsigned int, clang::LangOptions::FPExceptionModeKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ExtendArgsKind>(unsigned int, clang::LangOptions::ExtendArgsKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::RoundingMode>(unsigned int, llvm::RoundingMode)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::LaxVectorConversionKind>(unsigned int, clang::LangOptions::LaxVectorConversionKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::PragmaMSPointersToMembersKind>(unsigned int, clang::LangOptions::PragmaMSPointersToMembersKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::TrivialAutoVarInitKind>(unsigned int, clang::LangOptions::TrivialAutoVarInitKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::Visibility>(unsigned int, clang::Visibility)
Line
Count
Source
409
703k
static T mergeForwardValue(T KeyPath, U Value) {
410
703k
  return static_cast<T>(Value);
411
703k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ThreadModelKind>(unsigned int, clang::LangOptions::ThreadModelKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::AltivecSrcCompatKind>(unsigned int, clang::LangOptions::AltivecSrcCompatKind)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::StackProtectorMode>(unsigned int, clang::LangOptions::StackProtectorMode)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::AddrSpaceMapMangling>(unsigned int, clang::LangOptions::AddrSpaceMapMangling)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::DefaultCallingConvention>(unsigned int, clang::LangOptions::DefaultCallingConvention)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::SYCLMajorVersion>(unsigned int, clang::LangOptions::SYCLMajorVersion)
Line
Count
Source
409
140k
static T mergeForwardValue(T KeyPath, U Value) {
410
140k
  return static_cast<T>(Value);
411
140k
}
412
413
2.11M
template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) {
414
2.11M
  return KeyPath | Value;
415
2.11M
}
416
417
91.5M
template <typename T> static T extractForwardValue(T KeyPath) {
418
91.5M
  return KeyPath;
419
91.5M
}
CompilerInvocation.cpp:clang::FrontendOptions::'unnamed' extractForwardValue<clang::FrontendOptions::'unnamed'>(clang::FrontendOptions::'unnamed')
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:llvm::EABI extractForwardValue<llvm::EABI>(llvm::EABI)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:clang::TargetOptions::CodeObjectVersionKind extractForwardValue<clang::TargetOptions::CodeObjectVersionKind>(clang::TargetOptions::CodeObjectVersionKind)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:unsigned long long extractForwardValue<unsigned long long>(unsigned long long)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:clang::ObjCXXARCStandardLibraryKind extractForwardValue<clang::ObjCXXARCStandardLibraryKind>(clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:clang::DisableValidationForModuleKind extractForwardValue<clang::DisableValidationForModuleKind>(clang::DisableValidationForModuleKind)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:clang::DependencyOutputFormat extractForwardValue<clang::DependencyOutputFormat>(clang::DependencyOutputFormat)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:unsigned int extractForwardValue<unsigned int>(unsigned int)
Line
Count
Source
417
75.6M
template <typename T> static T extractForwardValue(T KeyPath) {
418
75.6M
  return KeyPath;
419
75.6M
}
CompilerInvocation.cpp:std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > extractForwardValue<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
Line
Count
Source
417
9.14M
template <typename T> static T extractForwardValue(T KeyPath) {
418
9.14M
  return KeyPath;
419
9.14M
}
CompilerInvocation.cpp:bool extractForwardValue<bool>(bool)
Line
Count
Source
417
1.82M
template <typename T> static T extractForwardValue(T KeyPath) {
418
1.82M
  return KeyPath;
419
1.82M
}
CompilerInvocation.cpp:std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > extractForwardValue<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >)
Line
Count
Source
417
3.51M
template <typename T> static T extractForwardValue(T KeyPath) {
418
3.51M
  return KeyPath;
419
3.51M
}
CompilerInvocation.cpp:llvm::Reloc::Model extractForwardValue<llvm::Reloc::Model>(llvm::Reloc::Model)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:clang::LangOptions::GPUDefaultStreamKind extractForwardValue<clang::LangOptions::GPUDefaultStreamKind>(clang::LangOptions::GPUDefaultStreamKind)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
CompilerInvocation.cpp:clang::LangOptions::CoreFoundationABI extractForwardValue<clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI)
Line
Count
Source
417
140k
template <typename T> static T extractForwardValue(T KeyPath) {
418
140k
  return KeyPath;
419
140k
}
420
421
template <typename T, typename U, U Value>
422
2.11M
static T extractMaskValue(T KeyPath) {
423
2.11M
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)140
:
T()2.11M
;
424
2.11M
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')1>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)14
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')2>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)18
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')12>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)10
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')3324>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')4>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)10
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')8>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)24
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')4096>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')16>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)6
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')32>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)20
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')64>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)12
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')128>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')256>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')512>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')1024>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()140k
;
424
140k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')2048>(unsigned int)
Line
Count
Source
422
140k
static T extractMaskValue(T KeyPath) {
423
140k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)8
:
T()140k
;
424
140k
}
425
426
#define PARSE_OPTION_WITH_MARSHALLING(                                         \
427
    ARGS, DIAGS, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,       \
428
    IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)             \
429
113M
  if ((FLAGS)&options::CC1Option) {                                            \
430
95.1M
    KEYPATH = MERGER(KEYPATH, 
DEFAULT_VALUE1.18M
); \
431
104M
    if (IMPLIED_CHECK)                                                         \
432
95.1M
      
KEYPATH = MERGER(KEYPATH, 80.4k
IMPLIED_VALUE0
); \
433
96.5M
    if (SHOULD_PARSE)                                                          \
434
95.1M
      
if (auto 92.3M
MaybeValue92.3M
= NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
435
92.3M
        KEYPATH =                                                              \
436
5.77M
            MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue));      \
437
95.1M
  }
438
439
// Capture the extracted value as a lambda argument to avoid potential issues
440
// with lifetime extension of the reference.
441
#define GENERATE_OPTION_WITH_MARSHALLING(                                      \
442
    ARGS, STRING_ALLOCATOR, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH,       \
443
    DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR,      \
444
    TABLE_INDEX)                                                               \
445
111M
  if ((FLAGS)&options::CC1Option) {                                            \
446
93.6M
    [&](const auto &Extracted) {                                               \
447
93.6M
      if (ALWAYS_EMIT ||                                                       \
448
93.6M
          (Extracted !=                                                        \
449
93.5M
           static_cast<decltype(KEYPATH)>((
IMPLIED_CHECK8.89M
) ?
(80.4k
IMPLIED_VALUE0
) \
450
93.5M
                                                          : 
(93.4M
DEFAULT_VALUE1.18M
)))) \
451
93.6M
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2.28M
                     TABLE_INDEX, Extracted);                                  \
453
93.6M
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_23::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_24::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
562k
           static_cast<decltype(KEYPATH)>(
(140k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)16
\
450
140k
                                                          : 
(DEFAULT_VALUE)140k
))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_25::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_26::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_28::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_29::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_30::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
49
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_32::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_33::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
44
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_34::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
22
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_35::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_36::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
66.8k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_37::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
66.8k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_38::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_40::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_41::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
162
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_43::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
34
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_45::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_47::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_48::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_49::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
58
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_50::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_51::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_52::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_53::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
39.9k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_55::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_56::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_58::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
206
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_60::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_61::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_62::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_64::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_66::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_67::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_68::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_69::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_70::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
70
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_71::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
70
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_72::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
90
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_73::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
90
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_74::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_75::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_76::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_77::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
32
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_78::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
32
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_79::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_80::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_81::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_82::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_83::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_84::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_85::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_86::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
28
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_87::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
28
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_88::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_89::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_90::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_91::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_92::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_93::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_94::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_96::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
38
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_98::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_99::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_101::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_102::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_103::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_104::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_105::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_107::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_109::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_110::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_111::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_112::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_113::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_114::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_116::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
230
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_117::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
78
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_118::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_119::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
15.4k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_121::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
638
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_122::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_124::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2.78k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_126::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_127::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_128::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_129::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_131::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_132::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_133::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_135::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_136::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_139::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_140::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_142::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_143::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_145::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
26
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_146::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_147::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_148::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_149::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_151::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
30.9k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_153::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
56
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_155::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
40
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_157::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_159::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_161::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_163::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_165::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
56
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_167::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_168::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
166
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_170::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
36
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_172::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_173::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_175::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_177::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_179::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_181::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_183::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_184::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_187::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_188::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_190::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_191::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
116
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_192::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
5
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_194::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
7
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_196::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
108
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_198::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
222
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_200::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_201::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_202::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_203::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_204::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_205::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_206::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_207::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_208::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_209::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_211::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_212::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_213::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_215::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_216::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_217::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_218::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6.98k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_219::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
84
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_220::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
246
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_221::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_222::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_223::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_224::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_225::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_226::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_227::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_228::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_229::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_230::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
34
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_231::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
130
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_232::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
126
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_234::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_235::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
30
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_236::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
7.24k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_237::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
56.0k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_238::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
24
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_239::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_240::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_241::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_242::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_243::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_244::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
7.21k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_245::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_246::operator()<llvm::Reloc::Model>(llvm::Reloc::Model const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
21.3k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_247::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_248::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.13k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_249::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_250::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
582
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_251::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_252::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.88k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_253::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
42
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_254::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
42
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_255::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_256::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_257::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_258::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_259::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_260::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
126
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_261::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_262::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
255
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_263::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_264::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_265::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
55.9k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_266::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.78k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_267::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_268::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_269::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
242
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_270::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
69.5k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_271::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
40.4k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_272::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
40.4k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_273::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
394
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_274::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
380
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_275::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
254
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_276::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_277::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
38
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_278::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_279::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_280::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_281::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_282::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_283::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_284::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_285::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_286::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_287::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_288::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
22
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_289::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_290::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_291::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_292::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_293::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_294::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
266
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_295::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_296::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
136
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_297::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
260
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_298::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
178
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_299::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
178
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_300::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
145
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_301::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
145
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_302::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_303::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_304::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
32
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_305::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_306::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_307::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_308::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
71.2k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_309::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
71.2k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_310::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.25k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_311::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.25k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_312::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
23.2k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_313::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
23.2k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_314::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_315::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_316::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_317::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
22
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_318::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
71.3k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_319::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_320::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_321::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
51
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_322::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_323::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_324::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_325::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
52
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_343::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
30.9k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_344::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_346::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_347::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_348::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
236
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_349::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_350::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_352::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_353::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_354::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_355::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_356::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_357::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_358::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_359::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_361::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_363::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
442
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_364::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.19k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_365::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
838
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_366::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_367::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
278
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_368::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_369::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_370::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_371::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
73.0k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_372::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_373::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_374::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_375::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_376::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_377::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_461::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_462::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_463::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_464::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_465::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_466::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
50
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_468::operator()<clang::LangOptions::GPUDefaultStreamKind>(clang::LangOptions::GPUDefaultStreamKind const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_469::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_471::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_473::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_475::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_477::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_478::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
50
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_479::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_480::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_482::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.99k
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_484::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
22
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_485::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_487::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
192
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_489::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
190k
                                                          : 
(140k
DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
50
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_490::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
190k
                                                          : 
(140k
DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
50
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_491::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
112
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_493::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_495::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_497::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_498::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_500::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
24
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_501::operator()<bool>(bool const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
42
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_502::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
140k
                                                          : (DEFAULT_VALUE)))) \
451
140k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
140k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_504::operator()<clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI const&) const
Line
Count
Source
446
140k
    [&](const auto &Extracted) {                                               \
447
140k
      if (ALWAYS_EMIT ||                                                       \
448
140k
          (Extracted !=                                                        \
449
140k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALU