Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Frontend/CompilerInvocation.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- CompilerInvocation.cpp ---------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
9
#include "clang/Frontend/CompilerInvocation.h"
10
#include "TestModuleFileExtension.h"
11
#include "clang/Basic/Builtins.h"
12
#include "clang/Basic/CharInfo.h"
13
#include "clang/Basic/CodeGenOptions.h"
14
#include "clang/Basic/CommentOptions.h"
15
#include "clang/Basic/DebugInfoOptions.h"
16
#include "clang/Basic/Diagnostic.h"
17
#include "clang/Basic/DiagnosticDriver.h"
18
#include "clang/Basic/DiagnosticOptions.h"
19
#include "clang/Basic/FileSystemOptions.h"
20
#include "clang/Basic/LLVM.h"
21
#include "clang/Basic/LangOptions.h"
22
#include "clang/Basic/LangStandard.h"
23
#include "clang/Basic/ObjCRuntime.h"
24
#include "clang/Basic/Sanitizers.h"
25
#include "clang/Basic/SourceLocation.h"
26
#include "clang/Basic/TargetOptions.h"
27
#include "clang/Basic/Version.h"
28
#include "clang/Basic/Visibility.h"
29
#include "clang/Basic/XRayInstr.h"
30
#include "clang/Config/config.h"
31
#include "clang/Driver/Driver.h"
32
#include "clang/Driver/DriverDiagnostic.h"
33
#include "clang/Driver/Options.h"
34
#include "clang/Frontend/CommandLineSourceLoc.h"
35
#include "clang/Frontend/DependencyOutputOptions.h"
36
#include "clang/Frontend/FrontendDiagnostic.h"
37
#include "clang/Frontend/FrontendOptions.h"
38
#include "clang/Frontend/FrontendPluginRegistry.h"
39
#include "clang/Frontend/MigratorOptions.h"
40
#include "clang/Frontend/PreprocessorOutputOptions.h"
41
#include "clang/Frontend/TextDiagnosticBuffer.h"
42
#include "clang/Frontend/Utils.h"
43
#include "clang/Lex/HeaderSearchOptions.h"
44
#include "clang/Lex/PreprocessorOptions.h"
45
#include "clang/Sema/CodeCompleteOptions.h"
46
#include "clang/Serialization/ASTBitCodes.h"
47
#include "clang/Serialization/ModuleFileExtension.h"
48
#include "clang/StaticAnalyzer/Core/AnalyzerOptions.h"
49
#include "llvm/ADT/APInt.h"
50
#include "llvm/ADT/ArrayRef.h"
51
#include "llvm/ADT/CachedHashString.h"
52
#include "llvm/ADT/DenseSet.h"
53
#include "llvm/ADT/FloatingPointMode.h"
54
#include "llvm/ADT/Hashing.h"
55
#include "llvm/ADT/None.h"
56
#include "llvm/ADT/Optional.h"
57
#include "llvm/ADT/STLExtras.h"
58
#include "llvm/ADT/SmallString.h"
59
#include "llvm/ADT/SmallVector.h"
60
#include "llvm/ADT/StringRef.h"
61
#include "llvm/ADT/StringSwitch.h"
62
#include "llvm/ADT/Triple.h"
63
#include "llvm/ADT/Twine.h"
64
#include "llvm/Config/llvm-config.h"
65
#include "llvm/IR/DebugInfoMetadata.h"
66
#include "llvm/Linker/Linker.h"
67
#include "llvm/MC/MCTargetOptions.h"
68
#include "llvm/Option/Arg.h"
69
#include "llvm/Option/ArgList.h"
70
#include "llvm/Option/OptSpecifier.h"
71
#include "llvm/Option/OptTable.h"
72
#include "llvm/Option/Option.h"
73
#include "llvm/ProfileData/InstrProfReader.h"
74
#include "llvm/Remarks/HotnessThresholdParser.h"
75
#include "llvm/Support/CodeGen.h"
76
#include "llvm/Support/Compiler.h"
77
#include "llvm/Support/Error.h"
78
#include "llvm/Support/ErrorHandling.h"
79
#include "llvm/Support/ErrorOr.h"
80
#include "llvm/Support/FileSystem.h"
81
#include "llvm/Support/HashBuilder.h"
82
#include "llvm/Support/Host.h"
83
#include "llvm/Support/MathExtras.h"
84
#include "llvm/Support/MemoryBuffer.h"
85
#include "llvm/Support/Path.h"
86
#include "llvm/Support/Process.h"
87
#include "llvm/Support/Regex.h"
88
#include "llvm/Support/VersionTuple.h"
89
#include "llvm/Support/VirtualFileSystem.h"
90
#include "llvm/Support/raw_ostream.h"
91
#include "llvm/Target/TargetOptions.h"
92
#include <algorithm>
93
#include <atomic>
94
#include <cassert>
95
#include <cstddef>
96
#include <cstring>
97
#include <fstream>
98
#include <memory>
99
#include <string>
100
#include <tuple>
101
#include <type_traits>
102
#include <utility>
103
#include <vector>
104
105
using namespace clang;
106
using namespace driver;
107
using namespace options;
108
using namespace llvm::opt;
109
110
//===----------------------------------------------------------------------===//
111
// Helpers.
112
//===----------------------------------------------------------------------===//
113
114
// Parse misexpect tolerance argument value.
115
// Valid option values are integers in the range [0, 100)
116
71.8k
inline Expected<Optional<uint64_t>> parseToleranceOption(StringRef Arg) {
117
71.8k
  int64_t Val;
118
71.8k
  if (Arg.getAsInteger(10, Val))
119
0
    return llvm::createStringError(llvm::inconvertibleErrorCode(),
120
0
                                   "Not an integer: %s", Arg.data());
121
71.8k
  return Val;
122
71.8k
}
123
124
//===----------------------------------------------------------------------===//
125
// Initialization.
126
//===----------------------------------------------------------------------===//
127
128
CompilerInvocationRefBase::CompilerInvocationRefBase()
129
    : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
130
      DiagnosticOpts(new DiagnosticOptions()),
131
      HeaderSearchOpts(new HeaderSearchOptions()),
132
      PreprocessorOpts(new PreprocessorOptions()),
133
193k
      AnalyzerOpts(new AnalyzerOptions()) {}
134
135
CompilerInvocationRefBase::CompilerInvocationRefBase(
136
    const CompilerInvocationRefBase &X)
137
    : LangOpts(new LangOptions(*X.getLangOpts())),
138
      TargetOpts(new TargetOptions(X.getTargetOpts())),
139
      DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
140
      HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
141
      PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())),
142
12.9k
      AnalyzerOpts(new AnalyzerOptions(*X.getAnalyzerOpts())) {}
143
144
CompilerInvocationRefBase::CompilerInvocationRefBase(
145
399
    CompilerInvocationRefBase &&X) = default;
146
147
CompilerInvocationRefBase &
148
171
CompilerInvocationRefBase::operator=(CompilerInvocationRefBase X) {
149
171
  LangOpts.swap(X.LangOpts);
150
171
  TargetOpts.swap(X.TargetOpts);
151
171
  DiagnosticOpts.swap(X.DiagnosticOpts);
152
171
  HeaderSearchOpts.swap(X.HeaderSearchOpts);
153
171
  PreprocessorOpts.swap(X.PreprocessorOpts);
154
171
  AnalyzerOpts.swap(X.AnalyzerOpts);
155
171
  return *this;
156
171
}
157
158
CompilerInvocationRefBase &
159
0
CompilerInvocationRefBase::operator=(CompilerInvocationRefBase &&X) = default;
160
161
201k
CompilerInvocationRefBase::~CompilerInvocationRefBase() = default;
162
163
//===----------------------------------------------------------------------===//
164
// Normalizers
165
//===----------------------------------------------------------------------===//
166
167
#define SIMPLE_ENUM_VALUE_TABLE
168
#include "clang/Driver/Options.inc"
169
#undef SIMPLE_ENUM_VALUE_TABLE
170
171
static llvm::Optional<bool> normalizeSimpleFlag(OptSpecifier Opt,
172
                                                unsigned TableIndex,
173
                                                const ArgList &Args,
174
32.3M
                                                DiagnosticsEngine &Diags) {
175
32.3M
  if (Args.hasArg(Opt))
176
233k
    return true;
177
32.1M
  return None;
178
32.3M
}
179
180
static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned,
181
                                                  const ArgList &Args,
182
3.55M
                                                  DiagnosticsEngine &) {
183
3.55M
  if (Args.hasArg(Opt))
184
72.6k
    return false;
185
3.47M
  return None;
186
3.55M
}
187
188
/// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but
189
/// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with
190
/// unnecessary template instantiations and just ignore it with a variadic
191
/// argument.
192
static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args,
193
                                  const char *Spelling,
194
                                  CompilerInvocation::StringAllocator,
195
990k
                                  Option::OptionClass, unsigned, /*T*/...) {
196
990k
  Args.push_back(Spelling);
197
990k
}
198
199
0
template <typename T> static constexpr bool is_uint64_t_convertible() {
200
0
  return !std::is_same<T, uint64_t>::value &&
201
0
         llvm::is_integral_or_enum<T>::value;
202
0
}
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<unsigned long long>()
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<clang::DependencyOutputFormat>()
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<clang::FrontendOptions::'unnamed0'>()
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<llvm::RoundingMode>()
Unexecuted instantiation: CompilerInvocation.cpp:bool is_uint64_t_convertible<clang::DisableValidationForModuleKind>()
203
204
template <typename T,
205
          std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false>
206
2.59M
static auto makeFlagToValueNormalizer(T Value) {
207
2.59M
  return [Value](OptSpecifier Opt, unsigned, const ArgList &Args,
208
2.59M
                 DiagnosticsEngine &) -> Optional<T> {
209
2.59M
    if (Args.hasArg(Opt))
210
203
      return Value;
211
2.59M
    return None;
212
2.59M
  };
213
2.59M
}
214
215
template <typename T,
216
          std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false>
217
2.59M
static auto makeFlagToValueNormalizer(T Value) {
218
2.59M
  return makeFlagToValueNormalizer(uint64_t(Value));
219
2.59M
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<llvm::RoundingMode, false>(llvm::RoundingMode)
Line
Count
Source
217
143k
static auto makeFlagToValueNormalizer(T Value) {
218
143k
  return makeFlagToValueNormalizer(uint64_t(Value));
219
143k
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::FrontendOptions::'unnamed0', false>(clang::FrontendOptions::'unnamed0')
Line
Count
Source
217
2.16M
static auto makeFlagToValueNormalizer(T Value) {
218
2.16M
  return makeFlagToValueNormalizer(uint64_t(Value));
219
2.16M
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::DisableValidationForModuleKind, false>(clang::DisableValidationForModuleKind)
Line
Count
Source
217
144k
static auto makeFlagToValueNormalizer(T Value) {
218
144k
  return makeFlagToValueNormalizer(uint64_t(Value));
219
144k
}
CompilerInvocation.cpp:auto makeFlagToValueNormalizer<clang::DependencyOutputFormat, false>(clang::DependencyOutputFormat)
Line
Count
Source
217
144k
static auto makeFlagToValueNormalizer(T Value) {
218
144k
  return makeFlagToValueNormalizer(uint64_t(Value));
219
144k
}
220
221
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue,
222
29.7M
                                        OptSpecifier OtherOpt) {
223
29.7M
  return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned,
224
29.7M
                                       const ArgList &Args,
225
29.7M
                                       DiagnosticsEngine &) -> Optional<bool> {
226
29.7M
    if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
227
776k
      return A->getOption().matches(Opt) ? 
Value546k
:
OtherValue229k
;
228
776k
    }
229
28.9M
    return None;
230
29.7M
  };
231
29.7M
}
232
233
774k
static auto makeBooleanOptionDenormalizer(bool Value) {
234
774k
  return [Value](SmallVectorImpl<const char *> &Args, const char *Spelling,
235
774k
                 CompilerInvocation::StringAllocator, Option::OptionClass,
236
774k
                 unsigned, bool KeyPath) {
237
774k
    if (KeyPath == Value)
238
545k
      Args.push_back(Spelling);
239
774k
  };
240
774k
}
241
242
static void denormalizeStringImpl(SmallVectorImpl<const char *> &Args,
243
                                  const char *Spelling,
244
                                  CompilerInvocation::StringAllocator SA,
245
                                  Option::OptionClass OptClass, unsigned,
246
3.20M
                                  const Twine &Value) {
247
3.20M
  switch (OptClass) {
248
829k
  case Option::SeparateClass:
249
1.96M
  case Option::JoinedOrSeparateClass:
250
1.96M
  case Option::JoinedAndSeparateClass:
251
1.96M
    Args.push_back(Spelling);
252
1.96M
    Args.push_back(SA(Value));
253
1.96M
    break;
254
1.21M
  case Option::JoinedClass:
255
1.23M
  case Option::CommaJoinedClass:
256
1.23M
    Args.push_back(SA(Twine(Spelling) + Value));
257
1.23M
    break;
258
0
  default:
259
0
    llvm_unreachable("Cannot denormalize an option with option class "
260
3.20M
                     "incompatible with string denormalization.");
261
3.20M
  }
262
3.20M
}
263
264
template <typename T>
265
static void
266
denormalizeString(SmallVectorImpl<const char *> &Args, const char *Spelling,
267
                  CompilerInvocation::StringAllocator SA,
268
3.20M
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
3.20M
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
3.20M
}
CompilerInvocation.cpp:void denormalizeString<llvm::Twine>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, llvm::Twine)
Line
Count
Source
268
1.90M
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
1.90M
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
1.90M
}
CompilerInvocation.cpp:void denormalizeString<unsigned int>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, unsigned int)
Line
Count
Source
268
236k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
236k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
236k
}
CompilerInvocation.cpp:void denormalizeString<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
Line
Count
Source
268
884k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
884k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
884k
}
CompilerInvocation.cpp:void denormalizeString<char const*>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, char const*)
Line
Count
Source
268
173k
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
173k
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
173k
}
CompilerInvocation.cpp:void denormalizeString<int>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, int)
Line
Count
Source
268
20
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
20
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
20
}
CompilerInvocation.cpp:void denormalizeString<unsigned long long>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, unsigned long long)
Line
Count
Source
268
24
                  Option::OptionClass OptClass, unsigned TableIndex, T Value) {
269
24
  denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value));
270
24
}
271
272
static Optional<SimpleEnumValue>
273
207k
findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name) {
274
315k
  for (int I = 0, E = Table.Size; I != E; 
++I108k
)
275
315k
    if (Name == Table.Table[I].Name)
276
207k
      return Table.Table[I];
277
278
22
  return None;
279
207k
}
280
281
static Optional<SimpleEnumValue>
282
173k
findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) {
283
240k
  for (int I = 0, E = Table.Size; I != E; 
++I67.4k
)
284
240k
    if (Value == Table.Table[I].Value)
285
173k
      return Table.Table[I];
286
287
1
  return None;
288
173k
}
289
290
static llvm::Optional<unsigned> normalizeSimpleEnum(OptSpecifier Opt,
291
                                                    unsigned TableIndex,
292
                                                    const ArgList &Args,
293
6.17M
                                                    DiagnosticsEngine &Diags) {
294
6.17M
  assert(TableIndex < SimpleEnumValueTablesSize);
295
0
  const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
296
297
6.17M
  auto *Arg = Args.getLastArg(Opt);
298
6.17M
  if (!Arg)
299
5.97M
    return None;
300
301
207k
  StringRef ArgValue = Arg->getValue();
302
207k
  if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue))
303
207k
    return MaybeEnumVal->Value;
304
305
18.4E
  Diags.Report(diag::err_drv_invalid_value)
306
18.4E
      << Arg->getAsString(Args) << ArgValue;
307
18.4E
  return None;
308
207k
}
309
310
static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args,
311
                                      const char *Spelling,
312
                                      CompilerInvocation::StringAllocator SA,
313
                                      Option::OptionClass OptClass,
314
173k
                                      unsigned TableIndex, unsigned Value) {
315
173k
  assert(TableIndex < SimpleEnumValueTablesSize);
316
0
  const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
317
173k
  if (auto 
MaybeEnumVal173k
= findValueTableByValue(Table, Value)) {
318
173k
    denormalizeString(Args, Spelling, SA, OptClass, TableIndex,
319
173k
                      MaybeEnumVal->Name);
320
18.4E
  } else {
321
18.4E
    llvm_unreachable("The simple enum value was not correctly defined in "
322
18.4E
                     "the tablegen option description");
323
18.4E
  }
324
173k
}
325
326
template <typename T>
327
static void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args,
328
                                  const char *Spelling,
329
                                  CompilerInvocation::StringAllocator SA,
330
                                  Option::OptionClass OptClass,
331
173k
                                  unsigned TableIndex, T Value) {
332
173k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
173k
                                   static_cast<unsigned>(Value));
334
173k
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<unsigned int>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, unsigned int)
Line
Count
Source
331
148k
                                  unsigned TableIndex, T Value) {
332
148k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
148k
                                   static_cast<unsigned>(Value));
334
148k
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<llvm::Reloc::Model>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, llvm::Reloc::Model)
Line
Count
Source
331
21.6k
                                  unsigned TableIndex, T Value) {
332
21.6k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
21.6k
                                   static_cast<unsigned>(Value));
334
21.6k
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::LangOptions::GPUDefaultStreamKind>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::LangOptions::GPUDefaultStreamKind)
Line
Count
Source
331
6
                                  unsigned TableIndex, T Value) {
332
6
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
6
                                   static_cast<unsigned>(Value));
334
6
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::LangOptions::CoreFoundationABI>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::LangOptions::CoreFoundationABI)
Line
Count
Source
331
48
                                  unsigned TableIndex, T Value) {
332
48
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
48
                                   static_cast<unsigned>(Value));
334
48
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::FrontendOptions::'unnamed'>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::FrontendOptions::'unnamed')
Line
Count
Source
331
50
                                  unsigned TableIndex, T Value) {
332
50
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
50
                                   static_cast<unsigned>(Value));
334
50
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<llvm::EABI>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, llvm::EABI)
Line
Count
Source
331
58
                                  unsigned TableIndex, T Value) {
332
58
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
58
                                   static_cast<unsigned>(Value));
334
58
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::TargetOptions::CodeObjectVersionKind>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::TargetOptions::CodeObjectVersionKind)
Line
Count
Source
331
10
                                  unsigned TableIndex, T Value) {
332
10
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
10
                                   static_cast<unsigned>(Value));
334
10
}
CompilerInvocation.cpp:void denormalizeSimpleEnum<clang::ObjCXXARCStandardLibraryKind>(llvm::SmallVectorImpl<char const*>&, char const*, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::opt::Option::OptionClass, unsigned int, clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
331
2.83k
                                  unsigned TableIndex, T Value) {
332
2.83k
  return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex,
333
2.83k
                                   static_cast<unsigned>(Value));
334
2.83k
}
335
336
static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex,
337
                                             const ArgList &Args,
338
8.83M
                                             DiagnosticsEngine &Diags) {
339
8.83M
  auto *Arg = Args.getLastArg(Opt);
340
8.83M
  if (!Arg)
341
8.23M
    return None;
342
591k
  return std::string(Arg->getValue());
343
8.83M
}
344
345
template <typename IntTy>
346
static Optional<IntTy> normalizeStringIntegral(OptSpecifier Opt, int,
347
                                               const ArgList &Args,
348
8.27M
                                               DiagnosticsEngine &Diags) {
349
8.27M
  auto *Arg = Args.getLastArg(Opt);
350
8.27M
  if (!Arg)
351
8.04M
    return None;
352
236k
  IntTy Res;
353
236k
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354
5
    Diags.Report(diag::err_drv_invalid_int_value)
355
5
        << Arg->getAsString(Args) << Arg->getValue();
356
5
    return None;
357
5
  }
358
236k
  return Res;
359
236k
}
CompilerInvocation.cpp:llvm::Optional<unsigned long long> normalizeStringIntegral<unsigned long long>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
348
144k
                                               DiagnosticsEngine &Diags) {
349
144k
  auto *Arg = Args.getLastArg(Opt);
350
144k
  if (!Arg)
351
144k
    return None;
352
25
  IntTy Res;
353
25
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354
0
    Diags.Report(diag::err_drv_invalid_int_value)
355
0
        << Arg->getAsString(Args) << Arg->getValue();
356
0
    return None;
357
0
  }
358
25
  return Res;
359
25
}
CompilerInvocation.cpp:llvm::Optional<unsigned int> normalizeStringIntegral<unsigned int>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
348
7.84M
                                               DiagnosticsEngine &Diags) {
349
7.84M
  auto *Arg = Args.getLastArg(Opt);
350
7.84M
  if (!Arg)
351
7.60M
    return None;
352
236k
  IntTy Res;
353
236k
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354
5
    Diags.Report(diag::err_drv_invalid_int_value)
355
5
        << Arg->getAsString(Args) << Arg->getValue();
356
5
    return None;
357
5
  }
358
236k
  return Res;
359
236k
}
CompilerInvocation.cpp:llvm::Optional<int> normalizeStringIntegral<int>(llvm::opt::OptSpecifier, int, llvm::opt::ArgList const&, clang::DiagnosticsEngine&)
Line
Count
Source
348
288k
                                               DiagnosticsEngine &Diags) {
349
288k
  auto *Arg = Args.getLastArg(Opt);
350
288k
  if (!Arg)
351
288k
    return None;
352
22
  IntTy Res;
353
22
  if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
354
0
    Diags.Report(diag::err_drv_invalid_int_value)
355
0
        << Arg->getAsString(Args) << Arg->getValue();
356
0
    return None;
357
0
  }
358
22
  return Res;
359
22
}
360
361
static Optional<std::vector<std::string>>
362
normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args,
363
3.64M
                      DiagnosticsEngine &) {
364
3.64M
  return Args.getAllArgValues(Opt);
365
3.64M
}
366
367
static void denormalizeStringVector(SmallVectorImpl<const char *> &Args,
368
                                    const char *Spelling,
369
                                    CompilerInvocation::StringAllocator SA,
370
                                    Option::OptionClass OptClass,
371
                                    unsigned TableIndex,
372
117k
                                    const std::vector<std::string> &Values) {
373
117k
  switch (OptClass) {
374
31.8k
  case Option::CommaJoinedClass: {
375
31.8k
    std::string CommaJoinedValue;
376
31.8k
    if (!Values.empty()) {
377
31.8k
      CommaJoinedValue.append(Values.front());
378
31.8k
      for (const std::string &Value : llvm::drop_begin(Values, 1)) {
379
316
        CommaJoinedValue.append(",");
380
316
        CommaJoinedValue.append(Value);
381
316
      }
382
31.8k
    }
383
31.8k
    denormalizeString(Args, Spelling, SA, Option::OptionClass::JoinedClass,
384
31.8k
                      TableIndex, CommaJoinedValue);
385
31.8k
    break;
386
0
  }
387
592
  case Option::JoinedClass:
388
78.9k
  case Option::SeparateClass:
389
85.8k
  case Option::JoinedOrSeparateClass:
390
85.8k
    for (const std::string &Value : Values)
391
122k
      denormalizeString(Args, Spelling, SA, OptClass, TableIndex, Value);
392
85.8k
    break;
393
0
  default:
394
0
    llvm_unreachable("Cannot denormalize an option with option class "
395
117k
                     "incompatible with string vector denormalization.");
396
117k
  }
397
117k
}
398
399
static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex,
400
                                             const ArgList &Args,
401
288k
                                             DiagnosticsEngine &Diags) {
402
288k
  auto *Arg = Args.getLastArg(Opt);
403
288k
  if (!Arg)
404
158k
    return None;
405
129k
  return llvm::Triple::normalize(Arg->getValue());
406
288k
}
407
408
template <typename T, typename U>
409
102M
static T mergeForwardValue(T KeyPath, U Value) {
410
102M
  return static_cast<T>(Value);
411
102M
}
CompilerInvocation.cpp:clang::FrontendOptions::'unnamed' mergeForwardValue<clang::FrontendOptions::'unnamed', clang::FrontendOptions::'unnamed'>(clang::FrontendOptions::'unnamed', clang::FrontendOptions::'unnamed')
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:llvm::EABI mergeForwardValue<llvm::EABI, llvm::EABI>(llvm::EABI, llvm::EABI)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:clang::TargetOptions::CodeObjectVersionKind mergeForwardValue<clang::TargetOptions::CodeObjectVersionKind, clang::TargetOptions::CodeObjectVersionKind>(clang::TargetOptions::CodeObjectVersionKind, clang::TargetOptions::CodeObjectVersionKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned long long mergeForwardValue<unsigned long long, int>(unsigned long long, int)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned long long mergeForwardValue<unsigned long long, unsigned long long>(unsigned long long, unsigned long long)
Line
Count
Source
409
24
static T mergeForwardValue(T KeyPath, U Value) {
410
24
  return static_cast<T>(Value);
411
24
}
CompilerInvocation.cpp:clang::ObjCXXARCStandardLibraryKind mergeForwardValue<clang::ObjCXXARCStandardLibraryKind, clang::ObjCXXARCStandardLibraryKind>(clang::ObjCXXARCStandardLibraryKind, clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
409
146k
static T mergeForwardValue(T KeyPath, U Value) {
410
146k
  return static_cast<T>(Value);
411
146k
}
CompilerInvocation.cpp:clang::DisableValidationForModuleKind mergeForwardValue<clang::DisableValidationForModuleKind, clang::DisableValidationForModuleKind>(clang::DisableValidationForModuleKind, clang::DisableValidationForModuleKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:clang::DependencyOutputFormat mergeForwardValue<clang::DependencyOutputFormat, clang::DependencyOutputFormat>(clang::DependencyOutputFormat, clang::DependencyOutputFormat)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, bool>(unsigned int, bool)
Line
Count
Source
409
63.7M
static T mergeForwardValue(T KeyPath, U Value) {
410
63.7M
  return static_cast<T>(Value);
411
63.7M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, unsigned int>(unsigned int, unsigned int)
Line
Count
Source
409
3.91M
static T mergeForwardValue(T KeyPath, U Value) {
410
3.91M
  return static_cast<T>(Value);
411
3.91M
}
CompilerInvocation.cpp:std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > mergeForwardValue<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
Line
Count
Source
409
9.84M
static T mergeForwardValue(T KeyPath, U Value) {
410
9.84M
  return static_cast<T>(Value);
411
9.84M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, int>(unsigned int, int)
Line
Count
Source
409
7.18M
static T mergeForwardValue(T KeyPath, U Value) {
410
7.18M
  return static_cast<T>(Value);
411
7.18M
}
CompilerInvocation.cpp:bool mergeForwardValue<bool, bool>(bool, bool)
Line
Count
Source
409
1.87M
static T mergeForwardValue(T KeyPath, U Value) {
410
1.87M
  return static_cast<T>(Value);
411
1.87M
}
CompilerInvocation.cpp:std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > mergeForwardValue<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >)
Line
Count
Source
409
7.28M
static T mergeForwardValue(T KeyPath, U Value) {
410
7.28M
  return static_cast<T>(Value);
411
7.28M
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::EmbedBitcodeKind>(unsigned int, clang::CodeGenOptions::EmbedBitcodeKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::SwiftAsyncFramePointerKind>(unsigned int, clang::CodeGenOptions::SwiftAsyncFramePointerKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::AsanDetectStackUseAfterReturnMode>(unsigned int, llvm::AsanDetectStackUseAfterReturnMode)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::AsanDtorKind>(unsigned int, llvm::AsanDtorKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::FunctionReturnThunksKind>(unsigned int, llvm::FunctionReturnThunksKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::VectorLibrary>(unsigned int, clang::CodeGenOptions::VectorLibrary)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::TLSModel>(unsigned int, clang::CodeGenOptions::TLSModel)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > mergeForwardValue<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const*>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, char const*)
Line
Count
Source
409
576k
static T mergeForwardValue(T KeyPath, U Value) {
410
576k
  return static_cast<T>(Value);
411
576k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind>(unsigned int, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::EmitDwarfUnwindType>(unsigned int, llvm::EmitDwarfUnwindType)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::InlineAsmDialectKind>(unsigned int, clang::CodeGenOptions::InlineAsmDialectKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::DebuggerKind>(unsigned int, llvm::DebuggerKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, llvm::DebugCompressionType>(unsigned int, llvm::DebugCompressionType)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:llvm::Reloc::Model mergeForwardValue<llvm::Reloc::Model, llvm::Reloc::Model>(llvm::Reloc::Model, llvm::Reloc::Model)
Line
Count
Source
409
191k
static T mergeForwardValue(T KeyPath, U Value) {
410
191k
  return static_cast<T>(Value);
411
191k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::FramePointerKind>(unsigned int, clang::CodeGenOptions::FramePointerKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::ProfileInstrKind>(unsigned int, clang::CodeGenOptions::ProfileInstrKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::CodeGenOptions::ObjCDispatchMethodKind>(unsigned int, clang::CodeGenOptions::ObjCDispatchMethodKind)
Line
Count
Source
409
144k
static T mergeForwardValue(T KeyPath, U Value) {
410
144k
  return static_cast<T>(Value);
411
144k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::OverloadsShown>(unsigned int, clang::OverloadsShown)
Line
Count
Source
409
189k
static T mergeForwardValue(T KeyPath, U Value) {
410
189k
  return static_cast<T>(Value);
411
189k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::DiagnosticOptions::TextDiagnosticFormat>(unsigned int, clang::DiagnosticOptions::TextDiagnosticFormat)
Line
Count
Source
409
189k
static T mergeForwardValue(T KeyPath, U Value) {
410
189k
  return static_cast<T>(Value);
411
189k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::DiagnosticOptions::'unnamed'>(unsigned int, clang::DiagnosticOptions::'unnamed')
Line
Count
Source
409
1.13M
static T mergeForwardValue(T KeyPath, U Value) {
410
1.13M
  return static_cast<T>(Value);
411
1.13M
}
CompilerInvocation.cpp:clang::LangOptions::GPUDefaultStreamKind mergeForwardValue<clang::LangOptions::GPUDefaultStreamKind, clang::LangOptions::GPUDefaultStreamKind>(clang::LangOptions::GPUDefaultStreamKind, clang::LangOptions::GPUDefaultStreamKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:clang::LangOptions::CoreFoundationABI mergeForwardValue<clang::LangOptions::CoreFoundationABI, clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI, clang::LangOptions::CoreFoundationABI)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ExceptionHandlingKind>(unsigned int, clang::LangOptions::ExceptionHandlingKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::FPEvalMethodKind>(unsigned int, clang::LangOptions::FPEvalMethodKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::FPExceptionModeKind>(unsigned int, clang::LangOptions::FPExceptionModeKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ExtendArgsKind>(unsigned int, clang::LangOptions::ExtendArgsKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::LaxVectorConversionKind>(unsigned int, clang::LangOptions::LaxVectorConversionKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::PragmaMSPointersToMembersKind>(unsigned int, clang::LangOptions::PragmaMSPointersToMembersKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::TrivialAutoVarInitKind>(unsigned int, clang::LangOptions::TrivialAutoVarInitKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::Visibility>(unsigned int, clang::Visibility)
Line
Count
Source
409
718k
static T mergeForwardValue(T KeyPath, U Value) {
410
718k
  return static_cast<T>(Value);
411
718k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::DefaultVisiblityExportMapping>(unsigned int, clang::LangOptions::DefaultVisiblityExportMapping)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::ThreadModelKind>(unsigned int, clang::LangOptions::ThreadModelKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::AltivecSrcCompatKind>(unsigned int, clang::LangOptions::AltivecSrcCompatKind)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::StackProtectorMode>(unsigned int, clang::LangOptions::StackProtectorMode)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::AddrSpaceMapMangling>(unsigned int, clang::LangOptions::AddrSpaceMapMangling)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::DefaultCallingConvention>(unsigned int, clang::LangOptions::DefaultCallingConvention)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
CompilerInvocation.cpp:unsigned int mergeForwardValue<unsigned int, clang::LangOptions::SYCLMajorVersion>(unsigned int, clang::LangOptions::SYCLMajorVersion)
Line
Count
Source
409
143k
static T mergeForwardValue(T KeyPath, U Value) {
410
143k
  return static_cast<T>(Value);
411
143k
}
412
413
2.16M
template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) {
414
2.16M
  return KeyPath | Value;
415
2.16M
}
416
417
94.8M
template <typename T> static T extractForwardValue(T KeyPath) {
418
94.8M
  return KeyPath;
419
94.8M
}
CompilerInvocation.cpp:clang::FrontendOptions::'unnamed' extractForwardValue<clang::FrontendOptions::'unnamed'>(clang::FrontendOptions::'unnamed')
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:llvm::EABI extractForwardValue<llvm::EABI>(llvm::EABI)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:clang::TargetOptions::CodeObjectVersionKind extractForwardValue<clang::TargetOptions::CodeObjectVersionKind>(clang::TargetOptions::CodeObjectVersionKind)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:unsigned long long extractForwardValue<unsigned long long>(unsigned long long)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:clang::ObjCXXARCStandardLibraryKind extractForwardValue<clang::ObjCXXARCStandardLibraryKind>(clang::ObjCXXARCStandardLibraryKind)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:clang::DisableValidationForModuleKind extractForwardValue<clang::DisableValidationForModuleKind>(clang::DisableValidationForModuleKind)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:clang::DependencyOutputFormat extractForwardValue<clang::DependencyOutputFormat>(clang::DependencyOutputFormat)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:unsigned int extractForwardValue<unsigned int>(unsigned int)
Line
Count
Source
417
78.2M
template <typename T> static T extractForwardValue(T KeyPath) {
418
78.2M
  return KeyPath;
419
78.2M
}
CompilerInvocation.cpp:std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > extractForwardValue<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >)
Line
Count
Source
417
9.63M
template <typename T> static T extractForwardValue(T KeyPath) {
418
9.63M
  return KeyPath;
419
9.63M
}
CompilerInvocation.cpp:bool extractForwardValue<bool>(bool)
Line
Count
Source
417
1.86M
template <typename T> static T extractForwardValue(T KeyPath) {
418
1.86M
  return KeyPath;
419
1.86M
}
CompilerInvocation.cpp:std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > extractForwardValue<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > >)
Line
Count
Source
417
3.59M
template <typename T> static T extractForwardValue(T KeyPath) {
418
3.59M
  return KeyPath;
419
3.59M
}
CompilerInvocation.cpp:llvm::Reloc::Model extractForwardValue<llvm::Reloc::Model>(llvm::Reloc::Model)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:clang::LangOptions::GPUDefaultStreamKind extractForwardValue<clang::LangOptions::GPUDefaultStreamKind>(clang::LangOptions::GPUDefaultStreamKind)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
CompilerInvocation.cpp:clang::LangOptions::CoreFoundationABI extractForwardValue<clang::LangOptions::CoreFoundationABI>(clang::LangOptions::CoreFoundationABI)
Line
Count
Source
417
143k
template <typename T> static T extractForwardValue(T KeyPath) {
418
143k
  return KeyPath;
419
143k
}
420
421
template <typename T, typename U, U Value>
422
2.15M
static T extractMaskValue(T KeyPath) {
423
2.15M
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)140
:
T()2.15M
;
424
2.15M
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')1>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)14
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')2>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)18
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')12>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)10
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')3324>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')4>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)10
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')8>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)24
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')4096>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')16>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)6
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')32>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)20
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')64>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)12
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')128>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')256>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')512>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)2
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')1024>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)4
:
T()143k
;
424
143k
}
CompilerInvocation.cpp:unsigned int extractMaskValue<unsigned int, clang::FrontendOptions::'unnamed0', (clang::FrontendOptions::'unnamed0')2048>(unsigned int)
Line
Count
Source
422
143k
static T extractMaskValue(T KeyPath) {
423
143k
  return ((KeyPath & Value) == Value) ? 
static_cast<T>(Value)8
:
T()143k
;
424
143k
}
425
426
#define PARSE_OPTION_WITH_MARSHALLING(                                         \
427
    ARGS, DIAGS, ID, FLAGS, PARAM, SHOULD_PARSE, KEYPATH, DEFAULT_VALUE,       \
428
    IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, MERGER, TABLE_INDEX)             \
429
117M
  if ((FLAGS)&options::CC1Option) {                                            \
430
98.5M
    KEYPATH = MERGER(KEYPATH, 
DEFAULT_VALUE1.21M
); \
431
107M
    if (IMPLIED_CHECK)                                                         \
432
98.5M
      
KEYPATH = MERGER(KEYPATH, 82.6k
IMPLIED_VALUE0
); \
433
99.9M
    if (SHOULD_PARSE)                                                          \
434
98.5M
      
if (auto 95.5M
MaybeValue95.5M
= NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
435
95.5M
        KEYPATH =                                                              \
436
5.89M
            MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue));      \
437
98.5M
  }
438
439
// Capture the extracted value as a lambda argument to avoid potential issues
440
// with lifetime extension of the reference.
441
#define GENERATE_OPTION_WITH_MARSHALLING(                                      \
442
    ARGS, STRING_ALLOCATOR, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH,       \
443
    DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR,      \
444
    TABLE_INDEX)                                                               \
445
115M
  if ((FLAGS)&options::CC1Option) {                                            \
446
96.9M
    [&](const auto &Extracted) {                                               \
447
96.9M
      if (ALWAYS_EMIT ||                                                       \
448
96.9M
          (Extracted !=                                                        \
449
96.8M
           static_cast<decltype(KEYPATH)>((
IMPLIED_CHECK9.08M
) ?
(82.6k
IMPLIED_VALUE0
) \
450
96.8M
                                                          : 
(96.7M
DEFAULT_VALUE1.21M
)))) \
451
96.9M
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2.33M
                     TABLE_INDEX, Extracted);                                  \
453
96.9M
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_22::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_23::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
575k
           static_cast<decltype(KEYPATH)>(
(143k
IMPLIED_CHECK) ?
(IMPLIED_VALUE)18
\
450
143k
                                                          : 
(DEFAULT_VALUE)143k
))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_24::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_25::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_28::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_30::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
67
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_33::operator()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_34::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
44
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_35::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
22
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_37::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
68.2k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
68.0k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_39::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_42::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
162
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_44::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
36
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_46::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_48::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_50::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
58
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_51::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_52::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_53::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_55::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_56::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
40.5k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_58::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_61::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
400
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_64::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_72::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_73::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
70
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_74::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
70
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_75::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
90
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_76::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
90
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_77::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_78::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_79::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_80::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
32
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_81::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
32
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_82::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_83::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_84::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_85::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_86::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_87::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_88::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_89::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
28
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_90::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
28
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_91::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_92::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_93::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_94::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_96::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_99::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
38
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_102::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_104::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_105::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_107::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_109::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_111::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_114::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_116::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_118::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
232
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_121::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
78
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_122::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_123::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
15.4k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
844
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_126::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_128::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2.84k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_130::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_131::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_132::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_133::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_136::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_140::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_143::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_144::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_146::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_147::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_149::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
26
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_150::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_151::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_152::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_153::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_155::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
31.5k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_157::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
56
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_159::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
40
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_161::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_163::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_165::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
56
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_172::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
168
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_174::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
36
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_176::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_177::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_179::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_181::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_183::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_187::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_188::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_191::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_192::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_194::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_196::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
116
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
5
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_199::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
7
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_201::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
110
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_203::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
224
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_205::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_206::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_207::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_208::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_209::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_211::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_212::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_213::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_214::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_216::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_217::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_218::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_220::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_221::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_223::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
7.11k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_224::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
84
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
246
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_229::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_230::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_231::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_232::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_234::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
34
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_237::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
130
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
318
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_240::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
30
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_242::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
7.35k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_243::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
57.4k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
24
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_246::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_247::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_248::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_249::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_250::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
7.34k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_251::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<llvm::Reloc::Model>(llvm::Reloc::Model const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
21.6k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_253::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_254::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.15k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_255::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_256::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
594
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_257::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.90k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
42
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_260::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
42
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_261::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_262::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_263::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_264::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
126
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_268::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
254
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_269::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_271::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
57.2k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_272::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.85k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_273::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_274::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
254
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
70.5k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_277::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
41.1k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_278::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
41.1k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_279::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
400
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_280::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
386
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
253
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_283::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
38
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_284::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_285::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_286::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_287::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_288::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_289::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_290::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_291::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_292::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_293::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_294::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
22
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_297::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_298::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_299::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_300::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
272
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
136
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
260
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_304::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
178
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_305::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
178
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_306::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_308::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
32
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_309::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_310::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_311::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_312::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
72.6k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_313::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
72.6k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_314::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.26k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_315::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.26k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_316::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
23.3k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_317::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
23.3k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_318::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_319::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_320::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
16
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_321::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
22
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_322::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
72.7k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_323::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_324::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_325::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
51
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_326::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_327::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_328::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_329::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
52
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_330::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
145
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateCodeGenArgs(clang::CodeGenOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&, clang::LangOptions const*)::$_331::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
145
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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()<std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > >(std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
31.5k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_350::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_352::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_353::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_354::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
240
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_355::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_356::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_358::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_359::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
14
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_360::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_361::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_362::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
18
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_363::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_364::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_365::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_367::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_369::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
442
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_370::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.28k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_371::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
844
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_372::operator()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
20
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_373::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
279
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_374::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_375::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_376::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_377::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
74.6k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_378::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_379::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
12
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_380::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_381::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_382::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateDiagnosticArgs(clang::DiagnosticOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, bool)::$_383::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_469::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
4
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
10
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_471::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
8
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_473::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
74
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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()<clang::LangOptions::GPUDefaultStreamKind>(clang::LangOptions::GPUDefaultStreamKind const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_476::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
26
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_478::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_480::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_482::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_484::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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()<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
80
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_486::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
6
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_487::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
0
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_489::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
1.99k
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_491::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
22
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_494::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
194
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
195k
                                                          : 
(143k
DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
80
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_497::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
195k
                                                          : 
(143k
DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
80
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(EXTRACTOR(KEYPATH));                                                     \
CompilerInvocation.cpp:auto clang::CompilerInvocation::GenerateLangArgs(clang::LangOptions const&, llvm::SmallVectorImpl<char const*>&, llvm::function_ref<char const* (llvm::Twine const&)>, llvm::Triple const&, clang::InputKind)::$_498::operator()<unsigned int>(unsigned int const&) const
Line
Count
Source
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
114
                     TABLE_INDEX, Extracted);                                  \
453
143k
    }(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
446
143k
    [&](const auto &Extracted) {                                               \
447
143k
      if (ALWAYS_EMIT ||                                                       \
448
143k
          (Extracted !=                                                        \
449
143k
           static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? 
(IMPLIED_VALUE)0
\
450
143k
                                                          : (DEFAULT_VALUE)))) \
451
143k
        DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
452
2
                     TABLE_INDEX, Extracted);