Coverage Report

Created: 2021-08-24 07:12

/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/Host.h"
82
#include "llvm/Support/MathExtras.h"
83
#include "llvm/Support/MemoryBuffer.h"
84
#include "llvm/Support/Path.h"
85
#include "llvm/Support/Process.h"
86
#include "llvm/Support/Regex.h"
87
#include "llvm/Support/VersionTuple.h"
88
#include "llvm/Support/VirtualFileSystem.h"
89
#include "llvm/Support/raw_ostream.h"
90
#include "llvm/Target/TargetOptions.h"
91
#include <algorithm>
92
#include <atomic>
93
#include <cassert>
94
#include <cstddef>
95
#include <cstring>
96
#include <memory>
97
#include <string>
98
#include <tuple>
99
#include <type_traits>
100
#include <utility>
101
#include <vector>
102
103
using namespace clang;
104
using namespace driver;
105
using namespace options;
106
using namespace llvm::opt;
107
108
//===----------------------------------------------------------------------===//
109
// Initialization.
110
//===----------------------------------------------------------------------===//
111
112
CompilerInvocationRefBase::CompilerInvocationRefBase()
113
    : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
114
      DiagnosticOpts(new DiagnosticOptions()),
115
      HeaderSearchOpts(new HeaderSearchOptions()),
116
      PreprocessorOpts(new PreprocessorOptions()),
117
194k
      AnalyzerOpts(new AnalyzerOptions()) {}
118
119
CompilerInvocationRefBase::CompilerInvocationRefBase(
120
    const CompilerInvocationRefBase &X)
121
    : LangOpts(new LangOptions(*X.getLangOpts())),
122
      TargetOpts(new TargetOptions(X.getTargetOpts())),
123
      DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
124
      HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
125
      PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())),
126
11.4k
      AnalyzerOpts(new AnalyzerOptions(*X.getAnalyzerOpts())) {}
127
128
CompilerInvocationRefBase::CompilerInvocationRefBase(
129
111
    CompilerInvocationRefBase &&X) = default;
130
131
CompilerInvocationRefBase &
132
61
CompilerInvocationRefBase::operator=(CompilerInvocationRefBase X) {
133
61
  LangOpts.swap(X.LangOpts);
134
61
  TargetOpts.swap(X.TargetOpts);
135
61
  DiagnosticOpts.swap(X.DiagnosticOpts);
136
61
  HeaderSearchOpts.swap(X.HeaderSearchOpts);
137
61
  PreprocessorOpts.swap(X.PreprocessorOpts);
138
61
  AnalyzerOpts.swap(X.AnalyzerOpts);
139
61
  return *this;
140
61
}
141
142
CompilerInvocationRefBase &
143
0
CompilerInvocationRefBase::operator=(CompilerInvocationRefBase &&X) = default;
144
145
199k
CompilerInvocationRefBase::~CompilerInvocationRefBase() = default;
146
147
//===----------------------------------------------------------------------===//
148
// Normalizers
149
//===----------------------------------------------------------------------===//
150
151
#define SIMPLE_ENUM_VALUE_TABLE
152
#include "clang/Driver/Options.inc"
153
#undef SIMPLE_ENUM_VALUE_TABLE
154
155
static llvm::Optional<bool> normalizeSimpleFlag(OptSpecifier Opt,
156
                                                unsigned TableIndex,
157
                                                const ArgList &Args,
158
30.3M
                                                DiagnosticsEngine &Diags) {
159
30.3M
  if (Args.hasArg(Opt))
160
301k
    return true;
161
30.0M
  return None;
162
30.3M
}
163
164
static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned,
165
                                                  const ArgList &Args,
166
3.51M
                                                  DiagnosticsEngine &) {
167
3.51M
  if (Args.hasArg(Opt))
168
70.1k
    return false;
169
3.43M
  return None;
170
3.51M
}
171
172
/// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but
173
/// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with
174
/// unnecessary template instantiations and just ignore it with a variadic
175
/// argument.
176
static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args,
177
                                  const char *Spelling,
178
                                  CompilerInvocation::StringAllocator,
179
891k
                                  Option::OptionClass, unsigned, /*T*/...) {
180
891k
  Args.push_back(Spelling);
181
891k
}
182
183
0
template <typename T> static constexpr bool is_uint64_t_convertible() {
184
0
  return !std::is_same<T, uint64_t>::value &&
185
0
         llvm::is_integral_or_enum<T>::value;
186
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>()
187
188
template <typename T,
189
          std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>
190
2.46M
static auto makeFlagToValueNormalizer(T Value) {
191
2.46M
  return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,
192
2.46M
                 DiagnosticsEngine &) -> Optional<T> {
193
2.46M
    if (Args.hasArg(Opt))
194
197
      return Value;
195
2.46M
    return None;
196
2.46M
  };
197
2.46M
}
198
199
template <typename T,
200
          std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false>
201
2.46M
static auto makeFlagToValueNormalizer(T Value) {
202
2.46M
  return makeFlagToValueNormalizer(uint64_t(Value));
203
2.46M
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<llvm::RoundingMode, false>(llvm::RoundingMode)
Line
Count
Source
201
136k
static auto makeFlagToValueNormalizer(T Value) {
202
136k
  return makeFlagToValueNormalizer(uint64_t(Value));
203
136k
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::FrontendOptions::'unnamed0', false>(clang::FrontendOptions::'unnamed0')
Line
Count
Source
201
2.05M
static auto makeFlagToValueNormalizer(T Value) {
202
2.05M
  return makeFlagToValueNormalizer(uint64_t(Value));
203
2.05M
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::DisableValidationForModuleKind, false>(clang::DisableValidationForModuleKind)
Line
Count
Source
201
136k
static auto makeFlagToValueNormalizer(T Value) {
202
136k
  return makeFlagToValueNormalizer(uint64_t(Value));
203
136k
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::DependencyOutputFormat, false>(clang::DependencyOutputFormat)
Line
Count
Source
201
136k
static auto makeFlagToValueNormalizer(T Value) {
202
136k
  return makeFlagToValueNormalizer(uint64_t(Value));
203
136k
}
204
205
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue,
206
25.8M
                                        OptSpecifier OtherOpt) {
207
25.8M
  return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned,
208
25.8M
                                       const ArgList &Args,
209
25.8M
                                       DiagnosticsEngine &) -> Optional<bool> {
210
25.8M
    if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
211
467k
      return A->getOption().matches(Opt) ? 
Value382k
:
OtherValue84.6k
;
212
467k
    }
213
25.3M
    return None;
214
25.8M
  };
215
25.8M
}
216
217
465k
static auto makeBooleanOptionDenormalizer(bool Value) {
218
465k
  return [Value](SmallVectorImpl<const char *> &Args, const char *Spelling,
219
465k
                 CompilerInvocation::StringAllocator, Option::OptionClass,
220
465k
                 unsigned, bool KeyPath) {
221
465k
    if (KeyPath == Value)
222
381k
      Args.push_back(Spelling);
223
465k
  };
224
465k
}
225
226
static void denormalizeStringImpl(SmallVectorImpl<const char *> &Args,
227
                                  const char *Spelling,
228
                                  CompilerInvocation::StringAllocator SA,
229
                                  Option::OptionClass OptClass, unsigned,
230
2.92M
                                  const Twine &Value) {
231
2.92M
  switch (OptClass) {
232
849k
  case Option::SeparateClass:
233
1.96M
  case Option::JoinedOrSeparateClass:
234
1.96M
  case Option::JoinedAndSeparateClass:
235
1.96M
    Args.push_back(Spelling);
236
1.96M
    Args.push_back(SA(Value));
237
1.96M
    break;
238
940k
  case Option::JoinedClass:
239
960k
  case Option::CommaJoinedClass:
240
960k
    Args.push_back(SA(Twine(Spelling) + Value));
241
960k
    break;
242
0
  default:
243
0
    llvm_unreachable("Cannot denormalize an option with option class "
244
2.92M
                     "incompatible with string denormalization.");
245
2.92M
  }
246
2.92M
}
247
248
template <typename T>
249
static void
250
denormalizeString(SmallVectorImpl<const char *> &Args, const char *Spelling,
251
                  CompilerInvocation::StringAllocator SA,
252
2.92M
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
253
2.92M
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
254
2.92M
}
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
252
1.71M
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
253
1.71M
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
254
1.71M
}
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
252
148k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
253
148k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
254
148k
}
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
252
300k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
253
300k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
254
300k
}
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
252
766k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
253
766k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
254
766k
}
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
252
12
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
253
12
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
254
12
}
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
252
22
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
253
22
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
254
22
}
255
256
static Optional<SimpleEnumValue>
257
262k
findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name) {
258
360k
  for (int I = 0, E = Table.Size; I != E; 
++I97.9k
)
259
360k
    if (Name == Table.Table[I].Name)
260
262k
      return Table.Table[I];
261
262
13
  return None;
263
262k
}
264
265
static Optional<SimpleEnumValue>
266
300k
findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) {
267
361k
  for (int I = 0, E = Table.Size; I != E; 
++I61.2k
)
268
361k
    if (Value == Table.Table[I].Value)
269
300k
      return Table.Table[I];
270
271
2
  return None;
272
300k
}
273
274
static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt,
275
                                                    unsigned TableIndex,
276
                                                    const ArgList &Args,
277
4.91M
                                                    DiagnosticsEngine &Diags) {
278
4.91M
  assert(TableIndex < SimpleEnumValueTablesSize);
279
0
  const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
280
281
4.91M
  auto *Arg = Args.getLastArg(Opt);
282
4.91M
  if (!Arg)
283
4.65M
    return None;
284
285
262k
  StringRef ArgValue = Arg->getValue();
286
262k
  if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue))
287
262k
    return MaybeEnumVal->Value;
288
289
30
  Diags.Report(diag::err_drv_invalid_value)
290
30
      << Arg->getAsString(Args) << ArgValue;
291
30
  return None;
292
262k
}
293
294
static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args,
295
                                      const char *Spelling,
296
                                      CompilerInvocation::StringAllocator SA,
297
                                      Option::OptionClass OptClass,
298
300k
                                      unsigned TableIndex, unsigned Value) {
299
300k
  assert(TableIndex < SimpleEnumValueTablesSize);
300
0
  const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
301
300k
  if (auto 
MaybeEnumVal300k
= findValueTableByValue(Table, Value)) {
302
300k
    denormalizeString(Args, Spelling, SA, OptClass, TableIndex,
303
300k
                      MaybeEnumVal->Name);
304
18.4E
  } else {
305
18.4E
    llvm_unreachable("The simple enum value was not correctly defined in "
306
18.4E
                     "the tablegen option description");
307
18.4E
  }
308
300k
}
309
310
template <typename T>
311
static void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args,
312
                                  const char *Spelling,
313
                                  CompilerInvocation::StringAllocator SA,
314
                                  Option::OptionClass OptClass,
315
300k
                                  unsigned TableIndex, T Value) {
316
300k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
317
300k
                                   static_cast<unsigned>(Value));
318
300k
}
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
315
273k
                                  unsigned TableIndex, T Value) {
316
273k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
317
273k
                                   static_cast<unsigned>(Value));
318
273k
}
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
315
24.2k
                                  unsigned TableIndex, T Value) {
316
24.2k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
317
24.2k
                                   static_cast<unsigned>(Value));
318
24.2k
}
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
315
48
                                  unsigned TableIndex, T Value) {
316
48
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
317
48
                                   static_cast<unsigned>(Value));
318
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
315
50
                                  unsigned TableIndex, T Value) {
316
50
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
317
50
                                   static_cast<unsigned>(Value));
318
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
315
58
                                  unsigned TableIndex, T Value) {
316
58
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
317
58
                                   static_cast<unsigned>(Value));
318
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
315
2.77k
                                  unsigned TableIndex, T Value) {
316
2.77k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
317
2.77k
                                   static_cast<unsigned>(Value));
318
2.77k
}
319
320
static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex,
321
                                             const ArgList &Args,
322
7.71M
                                             DiagnosticsEngine &Diags) {
323
7.71M
  auto *Arg = Args.getLastArg(Opt);
324
7.71M
  if (!Arg)
325
7.15M
    return None;
326
555k
  return std::string(Arg->getValue());
327
7.71M
}
328
329
template <typename IntTy>
330
static Optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int,
331
                                               const ArgList &Args,
332
6.90M
                                               DiagnosticsEngine &Diags) {
333
6.90M
  auto *Arg = Args.getLastArg(Opt);
334
6.90M
  if (!Arg)
335
6.75M
    return None;
336
149k
  IntTy Res;
337
149k
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
338
3
    Diags.Report(diag::err_drv_invalid_int_value)
339
3
        << Arg->getAsString(Args) << Arg->getValue();
340
3
    return None;
341
3
  }
342
149k
  return Res;
343
149k
}
CompilerInvocation.cpp:llvm::Optional<unsigned long long> normalizeStringIntegral<unsigned long long>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
332
136k
                                               DiagnosticsEngine &Diags) {
333
136k
  auto *Arg = Args.getLastArg(Opt);
334
136k
  if (!Arg)
335
136k
    return None;
336
24
  IntTy Res;
337
24
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
338
0
    Diags.Report(diag::err_drv_invalid_int_value)
339
0
        << Arg->getAsString(Args) << Arg->getValue();
340
0
    return None;
341
0
  }
342
24
  return Res;
343
24
}
CompilerInvocation.cpp:llvm::Optional<unsigned int> normalizeStringIntegral<unsigned int>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
332
6.49M
                                               DiagnosticsEngine &Diags) {
333
6.49M
  auto *Arg = Args.getLastArg(Opt);
334
6.49M
  if (!Arg)
335
6.34M
    return None;
336
149k
  IntTy Res;
337
149k
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
338
3
    Diags.Report(diag::err_drv_invalid_int_value)
339
3
        << Arg->getAsString(Args) << Arg->getValue();
340
3
    return None;
341
3
  }
342
149k
  return Res;
343
149k
}
CompilerInvocation.cpp:llvm::Optional<int> normalizeStringIntegral<int>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
332
273k
                                               DiagnosticsEngine &Diags) {
333
273k
  auto *Arg = Args.getLastArg(Opt);
334
273k
  if (!Arg)
335
273k
    return None;
336
9
  IntTy Res;
337
9
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
338
0
    Diags.Report(diag::err_drv_invalid_int_value)
339
0
        << Arg->getAsString(Args) << Arg->getValue();
340
0
    return None;
341
0
  }
342
9
  return Res;
343
9
}
344
345
static Optional<std::vector<std::string>>
346
normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args,
347
3.32M
                      DiagnosticsEngine &) {
348
3.32M
  return Args.getAllArgValues(Opt);
349
3.32M
}
350
351
static void denormalizeStringVector(SmallVectorImpl<const char *> &Args,
352
                                    const char *Spelling,
353
                                    CompilerInvocation::StringAllocator SA,
354
                                    Option::OptionClass OptClass,
355
                                    unsigned TableIndex,
356
47.8k
                                    const std::vector<std::string> &Values) {
357
47.8k
  switch (OptClass) {
358
28.9k
  case Option::CommaJoinedClass: {
359
28.9k
    std::string CommaJoinedValue;
360
28.9k
    if (!Values.empty()) {
361
28.9k
      CommaJoinedValue.append(Values.front());
362
28.9k
      for (const std::string &Value : llvm::drop_begin(Values, 1)) {
363
152
        CommaJoinedValue.append(",");
364
152
        CommaJoinedValue.append(Value);
365
152
      }
366
28.9k
    }
367
28.9k
    denormalizeString(Args, Spelling, SA, Option::OptionClass::JoinedClass,
368
28.9k
                      TableIndex, CommaJoinedValue);
369
28.9k
    break;
370
0
  }
371
535
  case Option::JoinedClass:
372
12.4k
  case Option::SeparateClass:
373
18.9k
  case Option::JoinedOrSeparateClass:
374
18.9k
    for (const std::string &Value : Values)
375
50.7k
      denormalizeString(Args, Spelling, SA, OptClass, TableIndex, Value);
376
18.9k
    break;
377
0
  default:
378
0
    llvm_unreachable("Cannot denormalize an option with option class "
379
47.8k
                     "incompatible with string vector denormalization.");
380
47.8k
  }
381
47.8k
}
382
383
static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex,
384
                                             const ArgList &Args,
385
136k
                                             DiagnosticsEngine &Diags) {
386
136k
  auto *Arg = Args.getLastArg(Opt);
387
136k
  if (!Arg)
388
13.3k
    return None;
389
123k
  return llvm::Triple::normalize(Arg->getValue());
390
136k
}
391
392
template <typename T, typename U>
393
91.2M
static T mergeForwardValue(T KeyPath, U Value) {
394
91.2M
  return static_cast<T>(Value);
395
91.2M
}
CompilerInvocation.cpp:clang::FrontendOptions::'unnamed' mergeForwardValue<clang::FrontendOptions::'unnamed', clang::FrontendOptions::'unnamed'>(clang::FrontendOptions::'unnamed', clang::FrontendOptions::'unnamed')
Line
Count
Source
393
137k
static T mergeForwardValue(T KeyPath, U Value) {
394
137k
  return static_cast<T>(Value);
395
137k
}
CompilerInvocation.cpp:llvm::EABI mergeForwardValue<llvm::EABI, llvm::EABI>(llvm::EABI, llvm::EABI)
Line
Count
Source
393
137k
static T mergeForwardValue(T KeyPath, U Value) {
394
137k
  return static_cast<T>(Value);
395
137k
}
CompilerInvocation.cpp:unsigned long long mergeForwardValue<unsigned long long, int>(unsigned long long, int)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned long long mergeForwardValue<unsigned long long, unsigned long long>(unsigned long long, unsigned long long)
Line
Count
Source
393
22
static T mergeForwardValue(T KeyPath, U Value) {
394
22
  return static_cast<T>(Value);
395
22
}
CompilerInvocation.cpp:clang::ObjCXXARCStandardLibraryKind mergeForwardValue<clang::ObjCXXARCStandardLibraryKind, clang::ObjCXXARCStandardLibraryKind>(clang::ObjCXXARCStandardLibraryKind, clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
393
139k
static T mergeForwardValue(T KeyPath, U Value) {
394
139k
  return static_cast<T>(Value);
395
139k
}
CompilerInvocation.cpp:clang::DisableValidationForModuleKind mergeForwardValue<clang::DisableValidationForModuleKind, clang::DisableValidationForModuleKind>(clang::DisableValidationForModuleKind, clang::DisableValidationForModuleKind)
Line
Count
Source
393
137k
static T mergeForwardValue(T KeyPath, U Value) {
394
137k
  return static_cast<T>(Value);
395
137k
}
CompilerInvocation.cpp:clang::DependencyOutputFormat mergeForwardValue<clang::DependencyOutputFormat, clang::DependencyOutputFormat>(clang::DependencyOutputFormat, clang::DependencyOutputFormat)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, bool>(unsigned int, bool)
Line
Count
Source
393
57.6M
static T mergeForwardValue(T KeyPath, U Value) {
394
57.6M
  return static_cast<T>(Value);
395
57.6M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, unsigned int>(unsigned int, unsigned int)
Line
Count
Source
393
3.52M
static T mergeForwardValue(T KeyPath, U Value) {
394
3.52M
  return static_cast<T>(Value);
395
3.52M
}
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
393
8.52M
static T mergeForwardValue(T KeyPath, U Value) {
394
8.52M
  return static_cast<T>(Value);
395
8.52M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, int>(unsigned int, int)
Line
Count
Source
393
6.01M
static T mergeForwardValue(T KeyPath, U Value) {
394
6.01M
  return static_cast<T>(Value);
395
6.01M
}
CompilerInvocation.cpp:bool mergeForwardValue<bool, bool>(bool, bool)
Line
Count
Source
393
1.78M
static T mergeForwardValue(T KeyPath, U Value) {
394
1.78M
  return static_cast<T>(Value);
395
1.78M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::EmbedBitcodeKind>(unsigned int, clang::CodeGenOptions::EmbedBitcodeKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
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
393
6.65M
static T mergeForwardValue(T KeyPath, U Value) {
394
6.65M
  return static_cast<T>(Value);
395
6.65M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::AsanDetectStackUseAfterReturnMode>(unsigned int, llvm::AsanDetectStackUseAfterReturnMode)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::AsanDtorKind>(unsigned int, llvm::AsanDtorKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::VectorLibrary>(unsigned int, clang::CodeGenOptions::VectorLibrary)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::TLSModel>(unsigned int, clang::CodeGenOptions::TLSModel)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
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
393
547k
static T mergeForwardValue(T KeyPath, U Value) {
394
547k
  return static_cast<T>(Value);
395
547k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::DebuggerKind>(unsigned int, llvm::DebuggerKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::DebugCompressionType>(unsigned int, llvm::DebugCompressionType)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:llvm::Reloc::Model mergeForwardValue<llvm::Reloc::Model, llvm::Reloc::Model>(llvm::Reloc::Model, llvm::Reloc::Model)
Line
Count
Source
393
183k
static T mergeForwardValue(T KeyPath, U Value) {
394
183k
  return static_cast<T>(Value);
395
183k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::FramePointerKind>(unsigned int, clang::CodeGenOptions::FramePointerKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::ProfileInstrKind>(unsigned int, clang::CodeGenOptions::ProfileInstrKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::ObjCDispatchMethodKind>(unsigned int, clang::CodeGenOptions::ObjCDispatchMethodKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::OverloadsShown>(unsigned int, clang::OverloadsShown)
Line
Count
Source
393
179k
static T mergeForwardValue(T KeyPath, U Value) {
394
179k
  return static_cast<T>(Value);
395
179k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::DiagnosticOptions::TextDiagnosticFormat>(unsigned int, clang::DiagnosticOptions::TextDiagnosticFormat)
Line
Count
Source
393
179k
static T mergeForwardValue(T KeyPath, U Value) {
394
179k
  return static_cast<T>(Value);
395
179k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::DiagnosticOptions::'unnamed'>(unsigned int, clang::DiagnosticOptions::'unnamed')
Line
Count
Source
393
1.07M
static T mergeForwardValue(T KeyPath, U Value) {
394
1.07M
  return static_cast<T>(Value);
395
1.07M
}
CompilerInvocation.cpp:clang::LangOptions::CoreFoundationABI mergeForwardValue<clang::LangOptions::CoreFoundationABI, clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI, clang::LangOptions::CoreFoundationABI)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ExceptionHandlingKind>(unsigned int, clang::LangOptions::ExceptionHandlingKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::FPEvalMethodKind>(unsigned int, clang::LangOptions::FPEvalMethodKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::FPExceptionModeKind>(unsigned int, clang::LangOptions::FPExceptionModeKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ExtendArgsKind>(unsigned int, clang::LangOptions::ExtendArgsKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::RoundingMode>(unsigned int, llvm::RoundingMode)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::LaxVectorConversionKind>(unsigned int, clang::LangOptions::LaxVectorConversionKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::PragmaMSPointersToMembersKind>(unsigned int, clang::LangOptions::PragmaMSPointersToMembersKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::TrivialAutoVarInitKind>(unsigned int, clang::LangOptions::TrivialAutoVarInitKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::Visibility>(unsigned int, clang::Visibility)
Line
Count
Source
393
683k
static T mergeForwardValue(T KeyPath, U Value) {
394
683k
  return static_cast<T>(Value);
395
683k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ThreadModelKind>(unsigned int, clang::LangOptions::ThreadModelKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::AltivecSrcCompatKind>(unsigned int, clang::LangOptions::AltivecSrcCompatKind)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::StackProtectorMode>(unsigned int, clang::LangOptions::StackProtectorMode)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::AddrSpaceMapMangling>(unsigned int, clang::LangOptions::AddrSpaceMapMangling)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::DefaultCallingConvention>(unsigned int, clang::LangOptions::DefaultCallingConvention)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::SYCLMajorVersion>(unsigned int, clang::LangOptions::SYCLMajorVersion)
Line
Count
Source
393
136k
static T mergeForwardValue(T KeyPath, U Value) {
394
136k
  return static_cast<T>(Value);
395
136k
}
396
397
2.05M
template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) {
398
2.05M
  return KeyPath | Value;
399
2.05M
}
400
401
84.4M
template <typename T> static T extractForwardValue(T KeyPath) {
402
84.4M
  return KeyPath;
403
84.4M
}
CompilerInvocation.cpp:clang::FrontendOptions::'unnamed' extractForwardValue<clang::FrontendOptions::'unnamed'>(clang::FrontendOptions::'unnamed')
Line
Count
Source
401
136k
template <typename T> static T extractForwardValue(T KeyPath) {
402
136k
  return KeyPath;
403
136k
}
CompilerInvocation.cpp:llvm::EABI extractForwardValue<llvm::EABI>(llvm::EABI)
Line
Count
Source
401
136k
template <typename T> static T extractForwardValue(T KeyPath) {
402
136k
  return KeyPath;
403
136k
}
CompilerInvocation.cpp:unsigned long long extractForwardValue<unsigned long long>(unsigned long long)
Line
Count
Source
401
136k
template <typename T> static T extractForwardValue(T KeyPath) {
402
136k
  return KeyPath;
403
136k
}
CompilerInvocation.cpp:clang::ObjCXXARCStandardLibraryKind extractForwardValue<clang::ObjCXXARCStandardLibraryKind>(clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
401
136k
template <typename T> static T extractForwardValue(T KeyPath) {
402
136k
  return KeyPath;
403
136k
}
CompilerInvocation.cpp:clang::DisableValidationForModuleKind extractForwardValue<clang::DisableValidationForModuleKind>(clang::DisableValidationForModuleKind)
Line
Count
Source
401
136k
template <typename T> static T extractForwardValue(T KeyPath) {
402
136k
  return KeyPath;
403
136k
}
CompilerInvocation.cpp:clang::DependencyOutputFormat extractForwardValue<clang::DependencyOutputFormat>(clang::DependencyOutputFormat)
Line
Count
Source
401
136k
template <typename T> static T extractForwardValue(T KeyPath) {
402
136k
  return KeyPath;
403
136k
}
CompilerInvocation.cpp:unsigned int extractForwardValue<unsigned int>(unsigned int)
Line
Count
Source
401
69.9M
template <typename T> static T extractForwardValue(T KeyPath) {
402
69.9M
  return KeyPath;
403
69.9M
}
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
401
8.33M
template <typename T> static T extractForwardValue(T KeyPath) {
402
8.33M
  return KeyPath;
403
8.33M
}
CompilerInvocation.cpp:bool extractForwardValue<bool>(bool)
Line
Count
Source
401
1.77M
template <typename T> static T extractForwardValue(T KeyPath) {
402
1.77M
  return KeyPath;
403
1.77M
}
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
401
3.27M
template <typename T> static T extractForwardValue(T KeyPath) {
402
3.27M
  return KeyPath;
403
3.27M
}
CompilerInvocation.cpp:llvm::Reloc::Model extractForwardValue<llvm::Reloc::Model>(llvm::Reloc::Model)
Line
Count
Source
401
136k
template <typename T> static T extractForwardValue(T KeyPath) {
402
136k
  return KeyPath;
403
136k
}
CompilerInvocation.cpp:clang::LangOptions::CoreFoundationABI extractForwardValue<clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI)
Line
Count
Source
401
136k
template <typename T> static T extractForwardValue(T KeyPath) {
402
136k
  return KeyPath;
403
136k
}
404
405
template <typename T, typename U, U Value>
406
2.05M
static T extractMaskValue(T KeyPath) {
407
2.05M
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)140
:
T()2.05M
;
408
2.05M
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')1>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)14
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')2>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)18
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')12>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)10
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')3324>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')4>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)10
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')8>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)24
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')4096>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')16>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)6
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')32>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)20
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')64>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)12
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')128>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')256>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')512>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')1024>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()136k
;
408
136k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')2048>(unsigned int)
Line
Count
Source
406
136k
static T extractMaskValue(T KeyPath) {
407
136k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)8
:
T()136k
;
408
136k
}
409
410
#define PARSE_OPTION_WITH_MARSHALLING(                                         \
411
    ARGS, DIAGS, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,       \
412
    IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)             \
413
104M
  if ((FLAGS)&options::CC1Option) {                                            \
414
87.9M
    KEYPATH = MERGER(KEYPATH, 
DEFAULT_VALUE1.15M
); \
415
96.6M
    if (IMPLIED_CHECK)                                                         \
416
87.9M
      
KEYPATH = MERGER(KEYPATH, 77.3k
IMPLIED_VALUE0
); \
417
89.3M
    if (SHOULD_PARSE)                                                          \
418
87.9M
      
if (auto 85.1M
MaybeValue85.1M
= NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
419
85.1M
        KEYPATH =                                                              \
420
5.25M
            MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue));      \
421
87.9M
  }
422
423
// Capture the extracted value as a lambda argument to avoid potential issues
424
// with lifetime extension of the reference.
425
#define GENERATE_OPTION_WITH_MARSHALLING(                                      \
426
    ARGS, STRING_ALLOCATOR, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH,       \
427
    DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR,      \
428
    TABLE_INDEX)                                                               \
429
103M
  if ((FLAGS)&options::CC1Option) {                                            \
430
86.4M
    [&](const auto &Extracted) {                                               \
431
86.4M
      if (ALWAYS_EMIT ||                                                       \
432
86.4M
          (Extracted !=                                                        \
433
86.2M
           static_cast<decltype(KEYPATH)>((
IMPLIED_CHECK8.64M
) ?
(77.2k
IMPLIED_VALUE0
) \
434
86.2M
                                                          : 
(86.1M
DEFAULT_VALUE1.15M
)))) \
435
86.4M
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2.01M
                     TABLE_INDEX, Extracted);                                  \
437
86.4M
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
546k
           static_cast<decltype(KEYPATH)>(
(136k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)18
\
434
136k
                                                          : 
(DEFAULT_VALUE)136k
))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_27::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_31::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
83
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_33::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
46
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_34::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
32
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_35::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
63.2k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_37::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
63.1k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_38::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_40::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_41::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
160
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_43::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
34
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_45::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_48::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
82
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
38.5k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
28
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
346
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
84
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
84
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
102
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
102
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
48
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
28
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
28
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
38
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_95::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
443
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_96::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
443
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_106::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
14
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
207
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_113::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
122
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
14.5k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
712
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_118::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2.78k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_127::operator()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_131::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_132::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
14
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_134::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_135::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
14
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
28
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_138::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_141::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
28.6k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_145::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
34
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_147::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
40
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_149::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_151::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_153::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_155::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_157::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
18
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_159::operator()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
78
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
18
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_171::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_173::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_175::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_179::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_181::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_182::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
82
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
5
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_185::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
7
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
52
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_189::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
108
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_191::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_193::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_195::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_206::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6.70k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
54
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
248
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_210::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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
16
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_217::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_218::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_219::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
130
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
326
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
16
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_223::operator()<std::__1::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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
50
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6.96k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
53.2k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
34
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_229::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_231::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6.96k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<llvm::Reloc::Model>(llvm::Reloc::Model const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
24.2k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
1.11k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
1.17k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
18
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
1.72k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_242::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
126
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
214
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
53.0k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_254::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
1.69k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
152
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
46.6k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_260::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
38.8k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
530
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
514
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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::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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
208
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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::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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
66
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
30
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_272::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_273::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
26
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
38
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
292
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
30
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
170
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
218
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
266
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
266
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
137
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
137
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_292::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_293::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
22
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
67.9k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
24
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
33
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
48
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_325::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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
28.7k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_326::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_328::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_329::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_330::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
216
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_331::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_332::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_334::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
14
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_335::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
14
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_336::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
18
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_339::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_345::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
428
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
1.08k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
794
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
18
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
234
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
69.3k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_354::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_356::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_441::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_442::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_443::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_444::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_445::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_446::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
42
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_448::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
20
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_450::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_452::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
100
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_459::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_461::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
1.99k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_463::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
22
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
132
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
187k
                                                          : 
(136k
DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
46
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_469::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
187k
                                                          : 
(136k
DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
46
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
116
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_472::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_474::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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_477::operator()<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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
24
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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()<bool>(bool const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
42
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_479::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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()<clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
48
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
10
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_485::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
56.1k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_489::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_492::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_493::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
18
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_495::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
3.01k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
62.1k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_498::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
194
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
2
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_500::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
12
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
166
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_502::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
272k
           static_cast<decltype(KEYPATH)>(
(136k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)8
\
434
136k
                                                          : 
(DEFAULT_VALUE)136k
))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
76
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
545k
           static_cast<decltype(KEYPATH)>(
(136k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)94
\
434
136k
                                                          : 
(DEFAULT_VALUE)136k
))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
16
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
38.5k
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
148
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
8
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_512::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
434
136k
                                                          : (DEFAULT_VALUE)))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_513::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
272k
           static_cast<decltype(KEYPATH)>(
(136k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)110
\
434
136k
                                                          : 
(DEFAULT_VALUE)136k
))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_515::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
272k
           static_cast<decltype(KEYPATH)>(
(136k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)110
\
434
136k
                                                          : 
(DEFAULT_VALUE)136k
))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
0
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_516::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
545k
           static_cast<decltype(KEYPATH)>(
(136k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)88
\
434
136k
                                                          : 
(DEFAULT_VALUE)136k
))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
6
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_518::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
545k
           static_cast<decltype(KEYPATH)>(
(136k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)118
\
434
136k
                                                          : 
(DEFAULT_VALUE)136k
))) \
435
136k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
436
4
                     TABLE_INDEX, Extracted);                                  \
437
136k
    }(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)::$_520::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
430
136k
    [&](const auto &Extracted) {                                               \
431
136k
      if (ALWAYS_EMIT ||                                                       \
432
136k
          (Extracted !=                                                        \
433
136k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\