Coverage Report

Created: 2022-01-22 13: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 <memory>
98
#include <string>
99
#include <tuple>
100
#include <type_traits>
101
#include <utility>
102
#include <vector>
103
104
using namespace clang;
105
using namespace driver;
106
using namespace options;
107
using namespace llvm::opt;
108
109
//===----------------------------------------------------------------------===//
110
// Initialization.
111
//===----------------------------------------------------------------------===//
112
113
CompilerInvocationRefBase::CompilerInvocationRefBase()
114
    : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
115
      DiagnosticOpts(new DiagnosticOptions()),
116
      HeaderSearchOpts(new HeaderSearchOptions()),
117
      PreprocessorOpts(new PreprocessorOptions()),
118
187k
      AnalyzerOpts(new AnalyzerOptions()) {}
119
120
CompilerInvocationRefBase::CompilerInvocationRefBase(
121
    const CompilerInvocationRefBase &X)
122
    : LangOpts(new LangOptions(*X.getLangOpts())),
123
      TargetOpts(new TargetOptions(X.getTargetOpts())),
124
      DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
125
      HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
126
      PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())),
127
12.0k
      AnalyzerOpts(new AnalyzerOptions(*X.getAnalyzerOpts())) {}
128
129
CompilerInvocationRefBase::CompilerInvocationRefBase(
130
200
    CompilerInvocationRefBase &&X) = default;
131
132
CompilerInvocationRefBase &
133
105
CompilerInvocationRefBase::operator=(CompilerInvocationRefBase X) {
134
105
  LangOpts.swap(X.LangOpts);
135
105
  TargetOpts.swap(X.TargetOpts);
136
105
  DiagnosticOpts.swap(X.DiagnosticOpts);
137
105
  HeaderSearchOpts.swap(X.HeaderSearchOpts);
138
105
  PreprocessorOpts.swap(X.PreprocessorOpts);
139
105
  AnalyzerOpts.swap(X.AnalyzerOpts);
140
105
  return *this;
141
105
}
142
143
CompilerInvocationRefBase &
144
0
CompilerInvocationRefBase::operator=(CompilerInvocationRefBase &&X) = default;
145
146
193k
CompilerInvocationRefBase::~CompilerInvocationRefBase() = default;
147
148
//===----------------------------------------------------------------------===//
149
// Normalizers
150
//===----------------------------------------------------------------------===//
151
152
#define SIMPLE_ENUM_VALUE_TABLE
153
#include "clang/Driver/Options.inc"
154
#undef SIMPLE_ENUM_VALUE_TABLE
155
156
static llvm::Optional<bool> normalizeSimpleFlag(OptSpecifier Opt,
157
                                                unsigned TableIndex,
158
                                                const ArgList &Args,
159
30.6M
                                                DiagnosticsEngine &Diags) {
160
30.6M
  if (Args.hasArg(Opt))
161
222k
    return true;
162
30.3M
  return None;
163
30.6M
}
164
165
static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned,
166
                                                  const ArgList &Args,
167
3.55M
                                                  DiagnosticsEngine &) {
168
3.55M
  if (Args.hasArg(Opt))
169
69.8k
    return false;
170
3.48M
  return None;
171
3.55M
}
172
173
/// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but
174
/// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with
175
/// unnecessary template instantiations and just ignore it with a variadic
176
/// argument.
177
static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args,
178
                                  const char *Spelling,
179
                                  CompilerInvocation::StringAllocator,
180
818k
                                  Option::OptionClass, unsigned, /*T*/...) {
181
818k
  Args.push_back(Spelling);
182
818k
}
183
184
0
template <typename T> static constexpr bool is_uint64_t_convertible() {
185
0
  return !std::is_same<T, uint64_t>::value &&
186
0
         llvm::is_integral_or_enum<T>::value;
187
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>()
188
189
template <typename T,
190
          std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>
191
2.49M
static auto makeFlagToValueNormalizer(T Value) {
192
2.49M
  return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,
193
2.49M
                 DiagnosticsEngine &) -> Optional<T> {
194
2.49M
    if (Args.hasArg(Opt))
195
203
      return Value;
196
2.49M
    return None;
197
2.49M
  };
198
2.49M
}
199
200
template <typename T,
201
          std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false>
202
2.49M
static auto makeFlagToValueNormalizer(T Value) {
203
2.49M
  return makeFlagToValueNormalizer(uint64_t(Value));
204
2.49M
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<llvm::RoundingMode, false>(llvm::RoundingMode)
Line
Count
Source
202
138k
static auto makeFlagToValueNormalizer(T Value) {
203
138k
  return makeFlagToValueNormalizer(uint64_t(Value));
204
138k
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::FrontendOptions::'unnamed0', false>(clang::FrontendOptions::'unnamed0')
Line
Count
Source
202
2.08M
static auto makeFlagToValueNormalizer(T Value) {
203
2.08M
  return makeFlagToValueNormalizer(uint64_t(Value));
204
2.08M
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::DisableValidationForModuleKind, false>(clang::DisableValidationForModuleKind)
Line
Count
Source
202
138k
static auto makeFlagToValueNormalizer(T Value) {
203
138k
  return makeFlagToValueNormalizer(uint64_t(Value));
204
138k
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::DependencyOutputFormat, false>(clang::DependencyOutputFormat)
Line
Count
Source
202
138k
static auto makeFlagToValueNormalizer(T Value) {
203
138k
  return makeFlagToValueNormalizer(uint64_t(Value));
204
138k
}
205
206
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue,
207
27.9M
                                        OptSpecifier OtherOpt) {
208
27.9M
  return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned,
209
27.9M
                                       const ArgList &Args,
210
27.9M
                                       DiagnosticsEngine &) -> Optional<bool> {
211
27.9M
    if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
212
704k
      return A->getOption().matches(Opt) ? 
Value506k
:
OtherValue197k
;
213
704k
    }
214
27.2M
    return None;
215
27.9M
  };
216
27.9M
}
217
218
839k
static auto makeBooleanOptionDenormalizer(bool Value) {
219
839k
  return [Value](SmallVectorImpl<const char *> &Args, const char *Spelling,
220
839k
                 CompilerInvocation::StringAllocator, Option::OptionClass,
221
839k
                 unsigned, bool KeyPath) {
222
839k
    if (KeyPath == Value)
223
504k
      Args.push_back(Spelling);
224
839k
  };
225
839k
}
226
227
static void denormalizeStringImpl(SmallVectorImpl<const char *> &Args,
228
                                  const char *Spelling,
229
                                  CompilerInvocation::StringAllocator SA,
230
                                  Option::OptionClass OptClass, unsigned,
231
3.11M
                                  const Twine &Value) {
232
3.11M
  switch (OptClass) {
233
936k
  case Option::SeparateClass:
234
2.06M
  case Option::JoinedOrSeparateClass:
235
2.06M
  case Option::JoinedAndSeparateClass:
236
2.06M
    Args.push_back(Spelling);
237
2.06M
    Args.push_back(SA(Value));
238
2.06M
    break;
239
1.02M
  case Option::JoinedClass:
240
1.04M
  case Option::CommaJoinedClass:
241
1.04M
    Args.push_back(SA(Twine(Spelling) + Value));
242
1.04M
    break;
243
0
  default:
244
0
    llvm_unreachable("Cannot denormalize an option with option class "
245
3.11M
                     "incompatible with string denormalization.");
246
3.11M
  }
247
3.11M
}
248
249
template <typename T>
250
static void
251
denormalizeString(SmallVectorImpl<const char *> &Args, const char *Spelling,
252
                  CompilerInvocation::StringAllocator SA,
253
3.11M
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
254
3.11M
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
255
3.11M
}
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
253
1.73M
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
254
1.73M
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
255
1.73M
}
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
253
222k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
254
222k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
255
222k
}
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
253
306k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
254
306k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
255
306k
}
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
253
850k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
254
850k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
255
850k
}
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
253
20
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
254
20
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
255
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
253
22
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
254
22
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
255
22
}
256
257
static Optional<SimpleEnumValue>
258
268k
findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name) {
259
369k
  for (int I = 0, E = Table.Size; I != E; 
++I101k
)
260
369k
    if (Name == Table.Table[I].Name)
261
268k
      return Table.Table[I];
262
263
15
  return None;
264
268k
}
265
266
static Optional<SimpleEnumValue>
267
306k
findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) {
268
370k
  for (int I = 0, E = Table.Size; I != E; 
++I63.3k
)
269
370k
    if (Value == Table.Table[I].Value)
270
306k
      return Table.Table[I];
271
272
18.4E
  return None;
273
306k
}
274
275
static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt,
276
                                                    unsigned TableIndex,
277
                                                    const ArgList &Args,
278
4.97M
                                                    DiagnosticsEngine &Diags) {
279
4.97M
  assert(TableIndex < SimpleEnumValueTablesSize);
280
0
  const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
281
282
4.97M
  auto *Arg = Args.getLastArg(Opt);
283
4.97M
  if (!Arg)
284
4.71M
    return None;
285
286
268k
  StringRef ArgValue = Arg->getValue();
287
268k
  if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue))
288
268k
    return MaybeEnumVal->Value;
289
290
44
  Diags.Report(diag::err_drv_invalid_value)
291
44
      << Arg->getAsString(Args) << ArgValue;
292
44
  return None;
293
268k
}
294
295
static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args,
296
                                      const char *Spelling,
297
                                      CompilerInvocation::StringAllocator SA,
298
                                      Option::OptionClass OptClass,
299
306k
                                      unsigned TableIndex, unsigned Value) {
300
306k
  assert(TableIndex < SimpleEnumValueTablesSize);
301
0
  const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
302
306k
  if (auto 
MaybeEnumVal306k
= findValueTableByValue(Table, Value)) {
303
306k
    denormalizeString(Args, Spelling, SA, OptClass, TableIndex,
304
306k
                      MaybeEnumVal->Name);
305
18.4E
  } else {
306
18.4E
    llvm_unreachable("The simple enum value was not correctly defined in "
307
18.4E
                     "the tablegen option description");
308
18.4E
  }
309
306k
}
310
311
template <typename T>
312
static void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args,
313
                                  const char *Spelling,
314
                                  CompilerInvocation::StringAllocator SA,
315
                                  Option::OptionClass OptClass,
316
306k
                                  unsigned TableIndex, T Value) {
317
306k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
318
306k
                                   static_cast<unsigned>(Value));
319
306k
}
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
316
278k
                                  unsigned TableIndex, T Value) {
317
278k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
318
278k
                                   static_cast<unsigned>(Value));
319
278k
}
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
316
24.7k
                                  unsigned TableIndex, T Value) {
317
24.7k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
318
24.7k
                                   static_cast<unsigned>(Value));
319
24.7k
}
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
316
48
                                  unsigned TableIndex, T Value) {
317
48
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
318
48
                                   static_cast<unsigned>(Value));
319
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
316
50
                                  unsigned TableIndex, T Value) {
317
50
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
318
50
                                   static_cast<unsigned>(Value));
319
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
316
58
                                  unsigned TableIndex, T Value) {
317
58
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
318
58
                                   static_cast<unsigned>(Value));
319
58
}
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
316
2.77k
                                  unsigned TableIndex, T Value) {
317
2.77k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
318
2.77k
                                   static_cast<unsigned>(Value));
319
2.77k
}
320
321
static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex,
322
                                             const ArgList &Args,
323
7.94M
                                             DiagnosticsEngine &Diags) {
324
7.94M
  auto *Arg = Args.getLastArg(Opt);
325
7.94M
  if (!Arg)
326
7.38M
    return None;
327
568k
  return std::string(Arg->getValue());
328
7.94M
}
329
330
template <typename IntTy>
331
static Optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int,
332
                                               const ArgList &Args,
333
7.55M
                                               DiagnosticsEngine &Diags) {
334
7.55M
  auto *Arg = Args.getLastArg(Opt);
335
7.55M
  if (!Arg)
336
7.32M
    return None;
337
222k
  IntTy Res;
338
222k
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
339
5
    Diags.Report(diag::err_drv_invalid_int_value)
340
5
        << Arg->getAsString(Args) << Arg->getValue();
341
5
    return None;
342
5
  }
343
222k
  return Res;
344
222k
}
CompilerInvocation.cpp:llvm::Optional<unsigned long long> normalizeStringIntegral<unsigned long long>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
333
138k
                                               DiagnosticsEngine &Diags) {
334
138k
  auto *Arg = Args.getLastArg(Opt);
335
138k
  if (!Arg)
336
138k
    return None;
337
24
  IntTy Res;
338
24
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
339
0
    Diags.Report(diag::err_drv_invalid_int_value)
340
0
        << Arg->getAsString(Args) << Arg->getValue();
341
0
    return None;
342
0
  }
343
24
  return Res;
344
24
}
CompilerInvocation.cpp:llvm::Optional<unsigned int> normalizeStringIntegral<unsigned int>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
333
7.13M
                                               DiagnosticsEngine &Diags) {
334
7.13M
  auto *Arg = Args.getLastArg(Opt);
335
7.13M
  if (!Arg)
336
6.91M
    return None;
337
222k
  IntTy Res;
338
222k
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
339
5
    Diags.Report(diag::err_drv_invalid_int_value)
340
5
        << Arg->getAsString(Args) << Arg->getValue();
341
5
    return None;
342
5
  }
343
222k
  return Res;
344
222k
}
CompilerInvocation.cpp:llvm::Optional<int> normalizeStringIntegral<int>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
333
277k
                                               DiagnosticsEngine &Diags) {
334
277k
  auto *Arg = Args.getLastArg(Opt);
335
277k
  if (!Arg)
336
277k
    return None;
337
24
  IntTy Res;
338
24
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
339
0
    Diags.Report(diag::err_drv_invalid_int_value)
340
0
        << Arg->getAsString(Args) << Arg->getValue();
341
0
    return None;
342
0
  }
343
24
  return Res;
344
24
}
345
346
static Optional<std::vector<std::string>>
347
normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args,
348
3.37M
                      DiagnosticsEngine &) {
349
3.37M
  return Args.getAllArgValues(Opt);
350
3.37M
}
351
352
static void denormalizeStringVector(SmallVectorImpl<const char *> &Args,
353
                                    const char *Spelling,
354
                                    CompilerInvocation::StringAllocator SA,
355
                                    Option::OptionClass OptClass,
356
                                    unsigned TableIndex,
357
114k
                                    const std::vector<std::string> &Values) {
358
114k
  switch (OptClass) {
359
29.9k
  case Option::CommaJoinedClass: {
360
29.9k
    std::string CommaJoinedValue;
361
29.9k
    if (
!Values.empty()29.9k
) {
362
29.9k
      CommaJoinedValue.append(Values.front());
363
29.9k
      for (const std::string &Value : llvm::drop_begin(Values, 1)) {
364
248
        CommaJoinedValue.append(",");
365
248
        CommaJoinedValue.append(Value);
366
248
      }
367
29.9k
    }
368
29.9k
    denormalizeString(Args, Spelling, SA, Option::OptionClass::JoinedClass,
369
29.9k
                      TableIndex, CommaJoinedValue);
370
29.9k
    break;
371
0
  }
372
598
  case Option::JoinedClass:
373
77.3k
  case Option::SeparateClass:
374
84.0k
  case Option::JoinedOrSeparateClass:
375
84.0k
    for (const std::string &Value : Values)
376
118k
      denormalizeString(Args, Spelling, SA, OptClass, TableIndex, Value);
377
84.0k
    break;
378
0
  default:
379
0
    llvm_unreachable("Cannot denormalize an option with option class "
380
114k
                     "incompatible with string vector denormalization.");
381
114k
  }
382
114k
}
383
384
static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex,
385
                                             const ArgList &Args,
386
138k
                                             DiagnosticsEngine &Diags) {
387
138k
  auto *Arg = Args.getLastArg(Opt);
388
138k
  if (!Arg)
389
13.7k
    return None;
390
125k
  return llvm::Triple::normalize(Arg->getValue());
391
138k
}
392
393
template <typename T, typename U>
394
94.9M
static T mergeForwardValue(T KeyPath, U Value) {
395
94.9M
  return static_cast<T>(Value);
396
94.9M
}
CompilerInvocation.cpp:clang::FrontendOptions::'unnamed' mergeForwardValue<clang::FrontendOptions::'unnamed', clang::FrontendOptions::'unnamed'>(clang::FrontendOptions::'unnamed', clang::FrontendOptions::'unnamed')
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:llvm::EABI mergeForwardValue<llvm::EABI, llvm::EABI>(llvm::EABI, llvm::EABI)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned long long mergeForwardValue<unsigned long long, int>(unsigned long long, int)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned long long mergeForwardValue<unsigned long long, unsigned long long>(unsigned long long, unsigned long long)
Line
Count
Source
394
22
static T mergeForwardValue(T KeyPath, U Value) {
395
22
  return static_cast<T>(Value);
396
22
}
CompilerInvocation.cpp:clang::ObjCXXARCStandardLibraryKind mergeForwardValue<clang::ObjCXXARCStandardLibraryKind, clang::ObjCXXARCStandardLibraryKind>(clang::ObjCXXARCStandardLibraryKind, clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
394
141k
static T mergeForwardValue(T KeyPath, U Value) {
395
141k
  return static_cast<T>(Value);
396
141k
}
CompilerInvocation.cpp:clang::DisableValidationForModuleKind mergeForwardValue<clang::DisableValidationForModuleKind, clang::DisableValidationForModuleKind>(clang::DisableValidationForModuleKind, clang::DisableValidationForModuleKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:clang::DependencyOutputFormat mergeForwardValue<clang::DependencyOutputFormat, clang::DependencyOutputFormat>(clang::DependencyOutputFormat, clang::DependencyOutputFormat)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, bool>(unsigned int, bool)
Line
Count
Source
394
60.0M
static T mergeForwardValue(T KeyPath, U Value) {
395
60.0M
  return static_cast<T>(Value);
396
60.0M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, unsigned int>(unsigned int, unsigned int)
Line
Count
Source
394
3.78M
static T mergeForwardValue(T KeyPath, U Value) {
395
3.78M
  return static_cast<T>(Value);
396
3.78M
}
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
394
8.78M
static T mergeForwardValue(T KeyPath, U Value) {
395
8.78M
  return static_cast<T>(Value);
396
8.78M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, int>(unsigned int, int)
Line
Count
Source
394
6.50M
static T mergeForwardValue(T KeyPath, U Value) {
395
6.50M
  return static_cast<T>(Value);
396
6.50M
}
CompilerInvocation.cpp:bool mergeForwardValue<bool, bool>(bool, bool)
Line
Count
Source
394
1.80M
static T mergeForwardValue(T KeyPath, U Value) {
395
1.80M
  return static_cast<T>(Value);
396
1.80M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::EmbedBitcodeKind>(unsigned int, clang::CodeGenOptions::EmbedBitcodeKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::SwiftAsyncFramePointerKind>(unsigned int, clang::CodeGenOptions::SwiftAsyncFramePointerKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
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
394
6.74M
static T mergeForwardValue(T KeyPath, U Value) {
395
6.74M
  return static_cast<T>(Value);
396
6.74M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::AsanDetectStackUseAfterReturnMode>(unsigned int, llvm::AsanDetectStackUseAfterReturnMode)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::AsanDtorKind>(unsigned int, llvm::AsanDtorKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::VectorLibrary>(unsigned int, clang::CodeGenOptions::VectorLibrary)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::TLSModel>(unsigned int, clang::CodeGenOptions::TLSModel)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
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
394
554k
static T mergeForwardValue(T KeyPath, U Value) {
395
554k
  return static_cast<T>(Value);
396
554k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::InlineAsmDialectKind>(unsigned int, clang::CodeGenOptions::InlineAsmDialectKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::DebuggerKind>(unsigned int, llvm::DebuggerKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::DebugCompressionType>(unsigned int, llvm::DebugCompressionType)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:llvm::Reloc::Model mergeForwardValue<llvm::Reloc::Model, llvm::Reloc::Model>(llvm::Reloc::Model, llvm::Reloc::Model)
Line
Count
Source
394
186k
static T mergeForwardValue(T KeyPath, U Value) {
395
186k
  return static_cast<T>(Value);
396
186k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::FramePointerKind>(unsigned int, clang::CodeGenOptions::FramePointerKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::ProfileInstrKind>(unsigned int, clang::CodeGenOptions::ProfileInstrKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::ObjCDispatchMethodKind>(unsigned int, clang::CodeGenOptions::ObjCDispatchMethodKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::OverloadsShown>(unsigned int, clang::OverloadsShown)
Line
Count
Source
394
181k
static T mergeForwardValue(T KeyPath, U Value) {
395
181k
  return static_cast<T>(Value);
396
181k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::DiagnosticOptions::TextDiagnosticFormat>(unsigned int, clang::DiagnosticOptions::TextDiagnosticFormat)
Line
Count
Source
394
181k
static T mergeForwardValue(T KeyPath, U Value) {
395
181k
  return static_cast<T>(Value);
396
181k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::DiagnosticOptions::'unnamed'>(unsigned int, clang::DiagnosticOptions::'unnamed')
Line
Count
Source
394
1.08M
static T mergeForwardValue(T KeyPath, U Value) {
395
1.08M
  return static_cast<T>(Value);
396
1.08M
}
CompilerInvocation.cpp:clang::LangOptions::CoreFoundationABI mergeForwardValue<clang::LangOptions::CoreFoundationABI, clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI, clang::LangOptions::CoreFoundationABI)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ExceptionHandlingKind>(unsigned int, clang::LangOptions::ExceptionHandlingKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::FPExceptionModeKind>(unsigned int, clang::LangOptions::FPExceptionModeKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ExtendArgsKind>(unsigned int, clang::LangOptions::ExtendArgsKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::RoundingMode>(unsigned int, llvm::RoundingMode)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::LaxVectorConversionKind>(unsigned int, clang::LangOptions::LaxVectorConversionKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::PragmaMSPointersToMembersKind>(unsigned int, clang::LangOptions::PragmaMSPointersToMembersKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::TrivialAutoVarInitKind>(unsigned int, clang::LangOptions::TrivialAutoVarInitKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::Visibility>(unsigned int, clang::Visibility)
Line
Count
Source
394
691k
static T mergeForwardValue(T KeyPath, U Value) {
395
691k
  return static_cast<T>(Value);
396
691k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ThreadModelKind>(unsigned int, clang::LangOptions::ThreadModelKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::AltivecSrcCompatKind>(unsigned int, clang::LangOptions::AltivecSrcCompatKind)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::StackProtectorMode>(unsigned int, clang::LangOptions::StackProtectorMode)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::AddrSpaceMapMangling>(unsigned int, clang::LangOptions::AddrSpaceMapMangling)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::DefaultCallingConvention>(unsigned int, clang::LangOptions::DefaultCallingConvention)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::SYCLMajorVersion>(unsigned int, clang::LangOptions::SYCLMajorVersion)
Line
Count
Source
394
138k
static T mergeForwardValue(T KeyPath, U Value) {
395
138k
  return static_cast<T>(Value);
396
138k
}
397
398
2.08M
template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) {
399
2.08M
  return KeyPath | Value;
400
2.08M
}
401
402
87.8M
template <typename T> static T extractForwardValue(T KeyPath) {
403
87.8M
  return KeyPath;
404
87.8M
}
CompilerInvocation.cpp:clang::FrontendOptions::'unnamed' extractForwardValue<clang::FrontendOptions::'unnamed'>(clang::FrontendOptions::'unnamed')
Line
Count
Source
402
138k
template <typename T> static T extractForwardValue(T KeyPath) {
403
138k
  return KeyPath;
404
138k
}
CompilerInvocation.cpp:llvm::EABI extractForwardValue<llvm::EABI>(llvm::EABI)
Line
Count
Source
402
138k
template <typename T> static T extractForwardValue(T KeyPath) {
403
138k
  return KeyPath;
404
138k
}
CompilerInvocation.cpp:unsigned long long extractForwardValue<unsigned long long>(unsigned long long)
Line
Count
Source
402
138k
template <typename T> static T extractForwardValue(T KeyPath) {
403
138k
  return KeyPath;
404
138k
}
CompilerInvocation.cpp:clang::ObjCXXARCStandardLibraryKind extractForwardValue<clang::ObjCXXARCStandardLibraryKind>(clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
402
138k
template <typename T> static T extractForwardValue(T KeyPath) {
403
138k
  return KeyPath;
404
138k
}
CompilerInvocation.cpp:clang::DisableValidationForModuleKind extractForwardValue<clang::DisableValidationForModuleKind>(clang::DisableValidationForModuleKind)
Line
Count
Source
402
138k
template <typename T> static T extractForwardValue(T KeyPath) {
403
138k
  return KeyPath;
404
138k
}
CompilerInvocation.cpp:clang::DependencyOutputFormat extractForwardValue<clang::DependencyOutputFormat>(clang::DependencyOutputFormat)
Line
Count
Source
402
138k
template <typename T> static T extractForwardValue(T KeyPath) {
403
138k
  return KeyPath;
404
138k
}
CompilerInvocation.cpp:unsigned int extractForwardValue<unsigned int>(unsigned int)
Line
Count
Source
402
73.0M
template <typename T> static T extractForwardValue(T KeyPath) {
403
73.0M
  return KeyPath;
404
73.0M
}
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
402
8.58M
template <typename T> static T extractForwardValue(T KeyPath) {
403
8.58M
  return KeyPath;
404
8.58M
}
CompilerInvocation.cpp:bool extractForwardValue<bool>(bool)
Line
Count
Source
402
1.79M
template <typename T> static T extractForwardValue(T KeyPath) {
403
1.79M
  return KeyPath;
404
1.79M
}
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
402
3.32M
template <typename T> static T extractForwardValue(T KeyPath) {
403
3.32M
  return KeyPath;
404
3.32M
}
CompilerInvocation.cpp:llvm::Reloc::Model extractForwardValue<llvm::Reloc::Model>(llvm::Reloc::Model)
Line
Count
Source
402
138k
template <typename T> static T extractForwardValue(T KeyPath) {
403
138k
  return KeyPath;
404
138k
}
CompilerInvocation.cpp:clang::LangOptions::CoreFoundationABI extractForwardValue<clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI)
Line
Count
Source
402
138k
template <typename T> static T extractForwardValue(T KeyPath) {
403
138k
  return KeyPath;
404
138k
}
405
406
template <typename T, typename U, U Value>
407
2.07M
static T extractMaskValue(T KeyPath) {
408
2.07M
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)140
:
T()2.07M
;
409
2.07M
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')1>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)14
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')2>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)18
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')12>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)10
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')3324>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')4>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)10
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')8>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)24
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')4096>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')16>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)6
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')32>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)20
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')64>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)12
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')128>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')256>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')512>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')1024>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()138k
;
409
138k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')2048>(unsigned int)
Line
Count
Source
407
138k
static T extractMaskValue(T KeyPath) {
408
138k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)8
:
T()138k
;
409
138k
}
410
411
#define PARSE_OPTION_WITH_MARSHALLING(                                         \
412
    ARGS, DIAGS, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,       \
413
    IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)             \
414
108M
  if ((FLAGS)&options::CC1Option) {                                            \
415
91.4M
    KEYPATH = MERGER(KEYPATH, 
DEFAULT_VALUE1.17M
); \
416
100M
    if (IMPLIED_CHECK)                                                         \
417
91.4M
      
KEYPATH = MERGER(KEYPATH, 79.3k
IMPLIED_VALUE0
); \
418
92.8M
    if (SHOULD_PARSE)                                                          \
419
91.4M
      
if (auto 88.6M
MaybeValue88.6M
= NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
420
88.6M
        KEYPATH =                                                              \
421
5.55M
            MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue));      \
422
91.4M
  }
423
424
// Capture the extracted value as a lambda argument to avoid potential issues
425
// with lifetime extension of the reference.
426
#define GENERATE_OPTION_WITH_MARSHALLING(                                      \
427
    ARGS, STRING_ALLOCATOR, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH,       \
428
    DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR,      \
429
    TABLE_INDEX)                                                               \
430
106M
  if ((FLAGS)&options::CC1Option) {                                            \
431
89.9M
    [&](const auto &Extracted) {                                               \
432
89.9M
      if (ALWAYS_EMIT ||                                                       \
433
89.9M
          (Extracted !=                                                        \
434
89.6M
           static_cast<decltype(KEYPATH)>((
IMPLIED_CHECK8.75M
) ?
(79.2k
IMPLIED_VALUE0
) \
435
89.6M
                                                          : 
(89.5M
DEFAULT_VALUE1.16M
)))) \
436
89.9M
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2.46M
                     TABLE_INDEX, Extracted);                                  \
438
89.9M
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
553k
           static_cast<decltype(KEYPATH)>(
(138k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)16
\
435
138k
                                                          : 
(DEFAULT_VALUE)138k
))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
45
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
44
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
24
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
65.3k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
65.3k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_39::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
160
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_42::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
34
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_44::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
20
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_46::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
60
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
16
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
39.7k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_54::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
28
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_57::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
182
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_59::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_63::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_65::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
68
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
68
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
92
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
92
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
38
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
28
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
28
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
38
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_97::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
125
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
125
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_100::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_108::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
14
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
243
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_115::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
82
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
15.3k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
598
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_120::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2.79k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_125::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_130::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_137::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
14
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
14
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
28
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_144::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
29.7k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_150::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
52
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_152::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
40
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_154::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_156::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_158::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_160::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_162::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
18
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_164::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
110
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
36
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_169::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_174::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_176::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_178::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_180::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_186::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
116
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
5
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
7
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
84
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
194
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_197::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
12
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_199::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
12
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_214::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6.82k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
84
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
246
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
16
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
34
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
130
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
130
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
16
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
34
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
7.02k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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*)::$_233::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
54.5k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
24
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
7.04k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<llvm::Reloc::Model>(llvm::Reloc::Model const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
24.7k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
1.05k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
560
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
18
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
1.78k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
38
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
38
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
20
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
20
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
126
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
266
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
54.4k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
1.71k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
12
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
204
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
68.0k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
40.1k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
40.1k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
422
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
406
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
260
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
50
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
30
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
26
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
22
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
268
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
22
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
134
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
268
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
174
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
174
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
145
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
145
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
24
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
69.7k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
69.7k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
1.24k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
14
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
14
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
22
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
69.9k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
18
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
20
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
51
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
50
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_337::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
29.7k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_338::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
20
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_340::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_341::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_342::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
236
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
14
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
14
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
18
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_351::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
12
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
438
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
1.15k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
828
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_360::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
18
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
285
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_362::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
12
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
71.4k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
12
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_453::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_454::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_455::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_456::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_457::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_458::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
30
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_460::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
32
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_470::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
6
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
0
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
1.99k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
22
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_476::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
168
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
188k
                                                          : 
(138k
DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
46
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_481::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
188k
                                                          : 
(138k
DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
46
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
116
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_486::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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
12
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
24
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<bool>(bool const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
42
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
48
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_494::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
10
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_496::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
4
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
58.5k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_499::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
8
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_503::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
2
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_505::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
18
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_507::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
3.01k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_508::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
64.7k
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_510::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
435
138k
                                                          : (DEFAULT_VALUE)))) \
436
138k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
437
182
                     TABLE_INDEX, Extracted);                                  \
438
138k
    }(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)::$_511::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
431
138k
    [&](const auto &Extracted) {                                               \
432
138k
      if (ALWAYS_EMIT ||                                                       \
433
138k
          (Extracted !=                                                        \
434
138k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE