Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/Support/TypeName.h
Line
Count
Source
1
//===- TypeName.h -----------------------------------------------*- C++ -*-===//
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
#ifndef LLVM_SUPPORT_TYPENAME_H
10
#define LLVM_SUPPORT_TYPENAME_H
11
12
#include "llvm/ADT/StringRef.h"
13
14
namespace llvm {
15
16
/// We provide a function which tries to compute the (demangled) name of a type
17
/// statically.
18
///
19
/// This routine may fail on some platforms or for particularly unusual types.
20
/// Do not use it for anything other than logging and debugging aids. It isn't
21
/// portable or dependendable in any real sense.
22
///
23
/// The returned StringRef will point into a static storage duration string.
24
/// However, it may not be null terminated and may be some strangely aligned
25
/// inner substring of a larger string.
26
template <typename DesiredTypeName>
27
16.6k
inline StringRef getTypeName() {
28
16.6k
#if defined(__clang__) || defined(__GNUC__)
29
16.6k
  StringRef Name = __PRETTY_FUNCTION__;
30
16.6k
31
16.6k
  StringRef Key = "DesiredTypeName = ";
32
16.6k
  Name = Name.substr(Name.find(Key));
33
16.6k
  assert(!Name.empty() && "Unable to find the template parameter!");
34
16.6k
  Name = Name.drop_front(Key.size());
35
16.6k
36
16.6k
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
16.6k
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::Module>()
Line
Count
Source
27
826
inline StringRef getTypeName() {
28
826
#if defined(__clang__) || defined(__GNUC__)
29
826
  StringRef Name = __PRETTY_FUNCTION__;
30
826
31
826
  StringRef Key = "DesiredTypeName = ";
32
826
  Name = Name.substr(Name.find(Key));
33
826
  assert(!Name.empty() && "Unable to find the template parameter!");
34
826
  Name = Name.drop_front(Key.size());
35
826
36
826
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
826
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::Function>()
Line
Count
Source
27
1.45k
inline StringRef getTypeName() {
28
1.45k
#if defined(__clang__) || defined(__GNUC__)
29
1.45k
  StringRef Name = __PRETTY_FUNCTION__;
30
1.45k
31
1.45k
  StringRef Key = "DesiredTypeName = ";
32
1.45k
  Name = Name.substr(Name.find(Key));
33
1.45k
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1.45k
  Name = Name.drop_front(Key.size());
35
1.45k
36
1.45k
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1.45k
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::TimePassesHandler>()
llvm::StringRef llvm::getTypeName<llvm::InnerAnalysisManagerProxy<llvm::AnalysisManager<llvm::Function>, llvm::Module> >()
Line
Count
Source
27
428
inline StringRef getTypeName() {
28
428
#if defined(__clang__) || defined(__GNUC__)
29
428
  StringRef Name = __PRETTY_FUNCTION__;
30
428
31
428
  StringRef Key = "DesiredTypeName = ";
32
428
  Name = Name.substr(Name.find(Key));
33
428
  assert(!Name.empty() && "Unable to find the template parameter!");
34
428
  Name = Name.drop_front(Key.size());
35
428
36
428
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
428
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::AAManager>()
Line
Count
Source
27
262
inline StringRef getTypeName() {
28
262
#if defined(__clang__) || defined(__GNUC__)
29
262
  StringRef Name = __PRETTY_FUNCTION__;
30
262
31
262
  StringRef Key = "DesiredTypeName = ";
32
262
  Name = Name.substr(Name.find(Key));
33
262
  assert(!Name.empty() && "Unable to find the template parameter!");
34
262
  Name = Name.drop_front(Key.size());
35
262
36
262
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
262
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::TargetLibraryAnalysis>()
Line
Count
Source
27
403
inline StringRef getTypeName() {
28
403
#if defined(__clang__) || defined(__GNUC__)
29
403
  StringRef Name = __PRETTY_FUNCTION__;
30
403
31
403
  StringRef Key = "DesiredTypeName = ";
32
403
  Name = Name.substr(Name.find(Key));
33
403
  assert(!Name.empty() && "Unable to find the template parameter!");
34
403
  Name = Name.drop_front(Key.size());
35
403
36
403
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
403
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::GCOVProfilerPass>()
Line
Count
Source
27
2
inline StringRef getTypeName() {
28
2
#if defined(__clang__) || defined(__GNUC__)
29
2
  StringRef Name = __PRETTY_FUNCTION__;
30
2
31
2
  StringRef Key = "DesiredTypeName = ";
32
2
  Name = Name.substr(Name.find(Key));
33
2
  assert(!Name.empty() && "Unable to find the template parameter!");
34
2
  Name = Name.drop_front(Key.size());
35
2
36
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
2
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::InstrProfiling>()
Line
Count
Source
27
12
inline StringRef getTypeName() {
28
12
#if defined(__clang__) || defined(__GNUC__)
29
12
  StringRef Name = __PRETTY_FUNCTION__;
30
12
31
12
  StringRef Key = "DesiredTypeName = ";
32
12
  Name = Name.substr(Name.find(Key));
33
12
  assert(!Name.empty() && "Unable to find the template parameter!");
34
12
  Name = Name.drop_front(Key.size());
35
12
36
12
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
12
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::AlwaysInlinerPass>()
Line
Count
Source
27
4
inline StringRef getTypeName() {
28
4
#if defined(__clang__) || defined(__GNUC__)
29
4
  StringRef Name = __PRETTY_FUNCTION__;
30
4
31
4
  StringRef Key = "DesiredTypeName = ";
32
4
  Name = Name.substr(Name.find(Key));
33
4
  assert(!Name.empty() && "Unable to find the template parameter!");
34
4
  Name = Name.drop_front(Key.size());
35
4
36
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
4
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::BoundsCheckingPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::BoundsCheckingPass> >()
llvm::StringRef llvm::getTypeName<llvm::CanonicalizeAliasesPass>()
Line
Count
Source
27
17
inline StringRef getTypeName() {
28
17
#if defined(__clang__) || defined(__GNUC__)
29
17
  StringRef Name = __PRETTY_FUNCTION__;
30
17
31
17
  StringRef Key = "DesiredTypeName = ";
32
17
  Name = Name.substr(Name.find(Key));
33
17
  assert(!Name.empty() && "Unable to find the template parameter!");
34
17
  Name = Name.drop_front(Key.size());
35
17
36
17
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
17
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::NameAnonGlobalPass>()
Line
Count
Source
27
23
inline StringRef getTypeName() {
28
23
#if defined(__clang__) || defined(__GNUC__)
29
23
  StringRef Name = __PRETTY_FUNCTION__;
30
23
31
23
  StringRef Key = "DesiredTypeName = ";
32
23
  Name = Name.substr(Name.find(Key));
33
23
  assert(!Name.empty() && "Unable to find the template parameter!");
34
23
  Name = Name.drop_front(Key.size());
35
23
36
23
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
23
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::EntryExitInstrumenterPass>()
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::EntryExitInstrumenterPass> >()
Line
Count
Source
27
27
inline StringRef getTypeName() {
28
27
#if defined(__clang__) || defined(__GNUC__)
29
27
  StringRef Name = __PRETTY_FUNCTION__;
30
27
31
27
  StringRef Key = "DesiredTypeName = ";
32
27
  Name = Name.substr(Name.find(Key));
33
27
  assert(!Name.empty() && "Unable to find the template parameter!");
34
27
  Name = Name.drop_front(Key.size());
35
27
36
27
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
27
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::MemorySanitizerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ThreadSanitizerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::ASanGlobalsMetadataAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::AddressSanitizerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ModuleAddressSanitizerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::HWAddressSanitizerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::AddressSanitizerPass> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::MemorySanitizerPass> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::ThreadSanitizerPass> >()
llvm::StringRef llvm::getTypeName<llvm::ThinLTOBitcodeWriterPass>()
Line
Count
Source
27
10
inline StringRef getTypeName() {
28
10
#if defined(__clang__) || defined(__GNUC__)
29
10
  StringRef Name = __PRETTY_FUNCTION__;
30
10
31
10
  StringRef Key = "DesiredTypeName = ";
32
10
  Name = Name.substr(Name.find(Key));
33
10
  assert(!Name.empty() && "Unable to find the template parameter!");
34
10
  Name = Name.drop_front(Key.size());
35
10
36
10
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
10
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::BitcodeWriterPass>()
Line
Count
Source
27
28
inline StringRef getTypeName() {
28
28
#if defined(__clang__) || defined(__GNUC__)
29
28
  StringRef Name = __PRETTY_FUNCTION__;
30
28
31
28
  StringRef Key = "DesiredTypeName = ";
32
28
  Name = Name.substr(Name.find(Key));
33
28
  assert(!Name.empty() && "Unable to find the template parameter!");
34
28
  Name = Name.drop_front(Key.size());
35
28
36
28
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
28
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::ScopAnalysis>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::ScopInfoAnalysis>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::IslAstAnalysis>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::DependenceAnalysis>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::OuterAnalysisManagerProxy<llvm::AnalysisManager<llvm::Function>, polly::Scop, polly::ScopStandardAnalysisResults&> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InnerAnalysisManagerProxy<llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, llvm::Function> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<polly::OwningInnerAnalysisManagerProxy<llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<polly::OwningInnerAnalysisManagerProxy<llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, llvm::Function>, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<polly::ScopAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<polly::ScopAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<polly::ScopInfoAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<polly::ScopInfoAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::CodePreparationPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::ScopAnalysisPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::ScopInfoPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<polly::IslAstAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<polly::IslAstAnalysis, polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<polly::DependenceAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<polly::DependenceAnalysis, polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::JSONExportPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::IslAstPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::DependenceInfoPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::CodeGenerationPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<polly::FunctionToScopPassAdaptor<llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&> > >()
llvm::StringRef llvm::getTypeName<llvm::VerifierPass>()
Line
Count
Source
27
238
inline StringRef getTypeName() {
28
238
#if defined(__clang__) || defined(__GNUC__)
29
238
  StringRef Name = __PRETTY_FUNCTION__;
30
238
31
238
  StringRef Key = "DesiredTypeName = ";
32
238
  Name = Name.substr(Name.find(Key));
33
238
  assert(!Name.empty() && "Unable to find the template parameter!");
34
238
  Name = Name.drop_front(Key.size());
35
238
36
238
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
238
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
178
inline StringRef getTypeName() {
28
178
#if defined(__clang__) || defined(__GNUC__)
29
178
  StringRef Name = __PRETTY_FUNCTION__;
30
178
31
178
  StringRef Key = "DesiredTypeName = ";
32
178
  Name = Name.substr(Name.find(Key));
33
178
  assert(!Name.empty() && "Unable to find the template parameter!");
34
178
  Name = Name.drop_front(Key.size());
35
178
36
178
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
178
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> > > >()
Line
Count
Source
27
402
inline StringRef getTypeName() {
28
402
#if defined(__clang__) || defined(__GNUC__)
29
402
  StringRef Name = __PRETTY_FUNCTION__;
30
402
31
402
  StringRef Key = "DesiredTypeName = ";
32
402
  Name = Name.substr(Name.find(Key));
33
402
  assert(!Name.empty() && "Unable to find the template parameter!");
34
402
  Name = Name.drop_front(Key.size());
35
402
36
402
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
402
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::CFGPrinterPass>()
llvm::StringRef llvm::getTypeName<llvm::CallGraphAnalysis>()
Line
Count
Source
27
187
inline StringRef getTypeName() {
28
187
#if defined(__clang__) || defined(__GNUC__)
29
187
  StringRef Name = __PRETTY_FUNCTION__;
30
187
31
187
  StringRef Key = "DesiredTypeName = ";
32
187
  Name = Name.substr(Name.find(Key));
33
187
  assert(!Name.empty() && "Unable to find the template parameter!");
34
187
  Name = Name.drop_front(Key.size());
35
187
36
187
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
187
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LazyCallGraphAnalysis>()
Line
Count
Source
27
207
inline StringRef getTypeName() {
28
207
#if defined(__clang__) || defined(__GNUC__)
29
207
  StringRef Name = __PRETTY_FUNCTION__;
30
207
31
207
  StringRef Key = "DesiredTypeName = ";
32
207
  Name = Name.substr(Name.find(Key));
33
207
  assert(!Name.empty() && "Unable to find the template parameter!");
34
207
  Name = Name.drop_front(Key.size());
35
207
36
207
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
207
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ModuleSummaryIndexAnalysis>()
Line
Count
Source
27
16
inline StringRef getTypeName() {
28
16
#if defined(__clang__) || defined(__GNUC__)
29
16
  StringRef Name = __PRETTY_FUNCTION__;
30
16
31
16
  StringRef Key = "DesiredTypeName = ";
32
16
  Name = Name.substr(Name.find(Key));
33
16
  assert(!Name.empty() && "Unable to find the template parameter!");
34
16
  Name = Name.drop_front(Key.size());
35
16
36
16
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
16
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ProfileSummaryAnalysis>()
Line
Count
Source
27
99
inline StringRef getTypeName() {
28
99
#if defined(__clang__) || defined(__GNUC__)
29
99
  StringRef Name = __PRETTY_FUNCTION__;
30
99
31
99
  StringRef Key = "DesiredTypeName = ";
32
99
  Name = Name.substr(Name.find(Key));
33
99
  assert(!Name.empty() && "Unable to find the template parameter!");
34
99
  Name = Name.drop_front(Key.size());
35
99
36
99
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
99
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::StackSafetyGlobalAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::VerifierAnalysis>()
Line
Count
Source
27
208
inline StringRef getTypeName() {
28
208
#if defined(__clang__) || defined(__GNUC__)
29
208
  StringRef Name = __PRETTY_FUNCTION__;
30
208
31
208
  StringRef Key = "DesiredTypeName = ";
32
208
  Name = Name.substr(Name.find(Key));
33
208
  assert(!Name.empty() && "Unable to find the template parameter!");
34
208
  Name = Name.drop_front(Key.size());
35
208
36
208
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
208
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PassInstrumentationAnalysis>()
Line
Count
Source
27
833
inline StringRef getTypeName() {
28
833
#if defined(__clang__) || defined(__GNUC__)
29
833
  StringRef Name = __PRETTY_FUNCTION__;
30
833
31
833
  StringRef Key = "DesiredTypeName = ";
32
833
  Name = Name.substr(Name.find(Key));
33
833
  assert(!Name.empty() && "Unable to find the template parameter!");
34
833
  Name = Name.drop_front(Key.size());
35
833
36
833
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
833
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ASanGlobalsMetadataAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::GlobalsAA>()
Line
Count
Source
27
159
inline StringRef getTypeName() {
28
159
#if defined(__clang__) || defined(__GNUC__)
29
159
  StringRef Name = __PRETTY_FUNCTION__;
30
159
31
159
  StringRef Key = "DesiredTypeName = ";
32
159
  Name = Name.substr(Name.find(Key));
33
159
  assert(!Name.empty() && "Unable to find the template parameter!");
34
159
  Name = Name.drop_front(Key.size());
35
159
36
159
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
159
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::FunctionAnalysisManagerCGSCCProxy>()
Line
Count
Source
27
258
inline StringRef getTypeName() {
28
258
#if defined(__clang__) || defined(__GNUC__)
29
258
  StringRef Name = __PRETTY_FUNCTION__;
30
258
31
258
  StringRef Key = "DesiredTypeName = ";
32
258
  Name = Name.substr(Name.find(Key));
33
258
  assert(!Name.empty() && "Unable to find the template parameter!");
34
258
  Name = Name.drop_front(Key.size());
35
258
36
258
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
258
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::AssumptionAnalysis>()
Line
Count
Source
27
258
inline StringRef getTypeName() {
28
258
#if defined(__clang__) || defined(__GNUC__)
29
258
  StringRef Name = __PRETTY_FUNCTION__;
30
258
31
258
  StringRef Key = "DesiredTypeName = ";
32
258
  Name = Name.substr(Name.find(Key));
33
258
  assert(!Name.empty() && "Unable to find the template parameter!");
34
258
  Name = Name.drop_front(Key.size());
35
258
36
258
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
258
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::BlockFrequencyAnalysis>()
Line
Count
Source
27
120
inline StringRef getTypeName() {
28
120
#if defined(__clang__) || defined(__GNUC__)
29
120
  StringRef Name = __PRETTY_FUNCTION__;
30
120
31
120
  StringRef Key = "DesiredTypeName = ";
32
120
  Name = Name.substr(Name.find(Key));
33
120
  assert(!Name.empty() && "Unable to find the template parameter!");
34
120
  Name = Name.drop_front(Key.size());
35
120
36
120
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
120
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::BranchProbabilityAnalysis>()
Line
Count
Source
27
119
inline StringRef getTypeName() {
28
119
#if defined(__clang__) || defined(__GNUC__)
29
119
  StringRef Name = __PRETTY_FUNCTION__;
30
119
31
119
  StringRef Key = "DesiredTypeName = ";
32
119
  Name = Name.substr(Name.find(Key));
33
119
  assert(!Name.empty() && "Unable to find the template parameter!");
34
119
  Name = Name.drop_front(Key.size());
35
119
36
119
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
119
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::DominatorTreeAnalysis>()
Line
Count
Source
27
366
inline StringRef getTypeName() {
28
366
#if defined(__clang__) || defined(__GNUC__)
29
366
  StringRef Name = __PRETTY_FUNCTION__;
30
366
31
366
  StringRef Key = "DesiredTypeName = ";
32
366
  Name = Name.substr(Name.find(Key));
33
366
  assert(!Name.empty() && "Unable to find the template parameter!");
34
366
  Name = Name.drop_front(Key.size());
35
366
36
366
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
366
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PostDominatorTreeAnalysis>()
Line
Count
Source
27
94
inline StringRef getTypeName() {
28
94
#if defined(__clang__) || defined(__GNUC__)
29
94
  StringRef Name = __PRETTY_FUNCTION__;
30
94
31
94
  StringRef Key = "DesiredTypeName = ";
32
94
  Name = Name.substr(Name.find(Key));
33
94
  assert(!Name.empty() && "Unable to find the template parameter!");
34
94
  Name = Name.drop_front(Key.size());
35
94
36
94
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
94
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::DemandedBitsAnalysis>()
Line
Count
Source
27
142
inline StringRef getTypeName() {
28
142
#if defined(__clang__) || defined(__GNUC__)
29
142
  StringRef Name = __PRETTY_FUNCTION__;
30
142
31
142
  StringRef Key = "DesiredTypeName = ";
32
142
  Name = Name.substr(Name.find(Key));
33
142
  assert(!Name.empty() && "Unable to find the template parameter!");
34
142
  Name = Name.drop_front(Key.size());
35
142
36
142
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
142
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::DominanceFrontierAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::LoopAnalysis>()
Line
Count
Source
27
265
inline StringRef getTypeName() {
28
265
#if defined(__clang__) || defined(__GNUC__)
29
265
  StringRef Name = __PRETTY_FUNCTION__;
30
265
31
265
  StringRef Key = "DesiredTypeName = ";
32
265
  Name = Name.substr(Name.find(Key));
33
265
  assert(!Name.empty() && "Unable to find the template parameter!");
34
265
  Name = Name.drop_front(Key.size());
35
265
36
265
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
265
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LazyValueAnalysis>()
Line
Count
Source
27
119
inline StringRef getTypeName() {
28
119
#if defined(__clang__) || defined(__GNUC__)
29
119
  StringRef Name = __PRETTY_FUNCTION__;
30
119
31
119
  StringRef Key = "DesiredTypeName = ";
32
119
  Name = Name.substr(Name.find(Key));
33
119
  assert(!Name.empty() && "Unable to find the template parameter!");
34
119
  Name = Name.drop_front(Key.size());
35
119
36
119
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
119
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::DependenceAnalysis>()
Line
Count
Source
27
4
inline StringRef getTypeName() {
28
4
#if defined(__clang__) || defined(__GNUC__)
29
4
  StringRef Name = __PRETTY_FUNCTION__;
30
4
31
4
  StringRef Key = "DesiredTypeName = ";
32
4
  Name = Name.substr(Name.find(Key));
33
4
  assert(!Name.empty() && "Unable to find the template parameter!");
34
4
  Name = Name.drop_front(Key.size());
35
4
36
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
4
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::MemoryDependenceAnalysis>()
Line
Count
Source
27
122
inline StringRef getTypeName() {
28
122
#if defined(__clang__) || defined(__GNUC__)
29
122
  StringRef Name = __PRETTY_FUNCTION__;
30
122
31
122
  StringRef Key = "DesiredTypeName = ";
32
122
  Name = Name.substr(Name.find(Key));
33
122
  assert(!Name.empty() && "Unable to find the template parameter!");
34
122
  Name = Name.drop_front(Key.size());
35
122
36
122
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
122
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::MemorySSAAnalysis>()
Line
Count
Source
27
101
inline StringRef getTypeName() {
28
101
#if defined(__clang__) || defined(__GNUC__)
29
101
  StringRef Name = __PRETTY_FUNCTION__;
30
101
31
101
  StringRef Key = "DesiredTypeName = ";
32
101
  Name = Name.substr(Name.find(Key));
33
101
  assert(!Name.empty() && "Unable to find the template parameter!");
34
101
  Name = Name.drop_front(Key.size());
35
101
36
101
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
101
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PhiValuesAnalysis>()
Line
Count
Source
27
113
inline StringRef getTypeName() {
28
113
#if defined(__clang__) || defined(__GNUC__)
29
113
  StringRef Name = __PRETTY_FUNCTION__;
30
113
31
113
  StringRef Key = "DesiredTypeName = ";
32
113
  Name = Name.substr(Name.find(Key));
33
113
  assert(!Name.empty() && "Unable to find the template parameter!");
34
113
  Name = Name.drop_front(Key.size());
35
113
36
113
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
113
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RegionInfoAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::OptimizationRemarkEmitterAnalysis>()
Line
Count
Source
27
174
inline StringRef getTypeName() {
28
174
#if defined(__clang__) || defined(__GNUC__)
29
174
  StringRef Name = __PRETTY_FUNCTION__;
30
174
31
174
  StringRef Key = "DesiredTypeName = ";
32
174
  Name = Name.substr(Name.find(Key));
33
174
  assert(!Name.empty() && "Unable to find the template parameter!");
34
174
  Name = Name.drop_front(Key.size());
35
174
36
174
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
174
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ScalarEvolutionAnalysis>()
Line
Count
Source
27
185
inline StringRef getTypeName() {
28
185
#if defined(__clang__) || defined(__GNUC__)
29
185
  StringRef Name = __PRETTY_FUNCTION__;
30
185
31
185
  StringRef Key = "DesiredTypeName = ";
32
185
  Name = Name.substr(Name.find(Key));
33
185
  assert(!Name.empty() && "Unable to find the template parameter!");
34
185
  Name = Name.drop_front(Key.size());
35
185
36
185
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
185
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::StackSafetyAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::TargetIRAnalysis>()
Line
Count
Source
27
231
inline StringRef getTypeName() {
28
231
#if defined(__clang__) || defined(__GNUC__)
29
231
  StringRef Name = __PRETTY_FUNCTION__;
30
231
31
231
  StringRef Key = "DesiredTypeName = ";
32
231
  Name = Name.substr(Name.find(Key));
33
231
  assert(!Name.empty() && "Unable to find the template parameter!");
34
231
  Name = Name.drop_front(Key.size());
35
231
36
231
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
231
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::BasicAA>()
Line
Count
Source
27
96
inline StringRef getTypeName() {
28
96
#if defined(__clang__) || defined(__GNUC__)
29
96
  StringRef Name = __PRETTY_FUNCTION__;
30
96
31
96
  StringRef Key = "DesiredTypeName = ";
32
96
  Name = Name.substr(Name.find(Key));
33
96
  assert(!Name.empty() && "Unable to find the template parameter!");
34
96
  Name = Name.drop_front(Key.size());
35
96
36
96
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
96
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::CFLAndersAA>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::CFLSteensAA>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::SCEVAA>()
llvm::StringRef llvm::getTypeName<llvm::ScopedNoAliasAA>()
Line
Count
Source
27
45
inline StringRef getTypeName() {
28
45
#if defined(__clang__) || defined(__GNUC__)
29
45
  StringRef Name = __PRETTY_FUNCTION__;
30
45
31
45
  StringRef Key = "DesiredTypeName = ";
32
45
  Name = Name.substr(Name.find(Key));
33
45
  assert(!Name.empty() && "Unable to find the template parameter!");
34
45
  Name = Name.drop_front(Key.size());
35
45
36
45
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
45
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::TypeBasedAA>()
Line
Count
Source
27
45
inline StringRef getTypeName() {
28
45
#if defined(__clang__) || defined(__GNUC__)
29
45
  StringRef Name = __PRETTY_FUNCTION__;
30
45
31
45
  StringRef Key = "DesiredTypeName = ";
32
45
  Name = Name.substr(Name.find(Key));
33
45
  assert(!Name.empty() && "Unable to find the template parameter!");
34
45
  Name = Name.drop_front(Key.size());
35
45
36
45
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
45
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopAccessAnalysis>()
Line
Count
Source
27
33
inline StringRef getTypeName() {
28
33
#if defined(__clang__) || defined(__GNUC__)
29
33
  StringRef Name = __PRETTY_FUNCTION__;
30
33
31
33
  StringRef Key = "DesiredTypeName = ";
32
33
  Name = Name.substr(Name.find(Key));
33
33
  assert(!Name.empty() && "Unable to find the template parameter!");
34
33
  Name = Name.drop_front(Key.size());
35
33
36
33
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
33
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::IVUsersAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::SROA>()
Line
Count
Source
27
140
inline StringRef getTypeName() {
28
140
#if defined(__clang__) || defined(__GNUC__)
29
140
  StringRef Name = __PRETTY_FUNCTION__;
30
140
31
140
  StringRef Key = "DesiredTypeName = ";
32
140
  Name = Name.substr(Name.find(Key));
33
140
  assert(!Name.empty() && "Unable to find the template parameter!");
34
140
  Name = Name.drop_front(Key.size());
35
140
36
140
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
140
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::EarlyCSEPass>()
Line
Count
Source
27
134
inline StringRef getTypeName() {
28
134
#if defined(__clang__) || defined(__GNUC__)
29
134
  StringRef Name = __PRETTY_FUNCTION__;
30
134
31
134
  StringRef Key = "DesiredTypeName = ";
32
134
  Name = Name.substr(Name.find(Key));
33
134
  assert(!Name.empty() && "Unable to find the template parameter!");
34
134
  Name = Name.drop_front(Key.size());
35
134
36
134
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
134
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::GVNHoistPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::GVNSinkPass>()
llvm::StringRef llvm::getTypeName<llvm::SimplifyCFGPass>()
Line
Count
Source
27
522
inline StringRef getTypeName() {
28
522
#if defined(__clang__) || defined(__GNUC__)
29
522
  StringRef Name = __PRETTY_FUNCTION__;
30
522
31
522
  StringRef Key = "DesiredTypeName = ";
32
522
  Name = Name.substr(Name.find(Key));
33
522
  assert(!Name.empty() && "Unable to find the template parameter!");
34
522
  Name = Name.drop_front(Key.size());
35
522
36
522
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
522
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::SpeculativeExecutionPass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::JumpThreadingPass>()
Line
Count
Source
27
141
inline StringRef getTypeName() {
28
141
#if defined(__clang__) || defined(__GNUC__)
29
141
  StringRef Name = __PRETTY_FUNCTION__;
30
141
31
141
  StringRef Key = "DesiredTypeName = ";
32
141
  Name = Name.substr(Name.find(Key));
33
141
  assert(!Name.empty() && "Unable to find the template parameter!");
34
141
  Name = Name.drop_front(Key.size());
35
141
36
141
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
141
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::CorrelatedValuePropagationPass>()
Line
Count
Source
27
136
inline StringRef getTypeName() {
28
136
#if defined(__clang__) || defined(__GNUC__)
29
136
  StringRef Name = __PRETTY_FUNCTION__;
30
136
31
136
  StringRef Key = "DesiredTypeName = ";
32
136
  Name = Name.substr(Name.find(Key));
33
136
  assert(!Name.empty() && "Unable to find the template parameter!");
34
136
  Name = Name.drop_front(Key.size());
35
136
36
136
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
136
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::AggressiveInstCombinePass>()
Line
Count
Source
27
21
inline StringRef getTypeName() {
28
21
#if defined(__clang__) || defined(__GNUC__)
29
21
  StringRef Name = __PRETTY_FUNCTION__;
30
21
31
21
  StringRef Key = "DesiredTypeName = ";
32
21
  Name = Name.substr(Name.find(Key));
33
21
  assert(!Name.empty() && "Unable to find the template parameter!");
34
21
  Name = Name.drop_front(Key.size());
35
21
36
21
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
21
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PGOMemOPSizeOpt>()
Line
Count
Source
27
2
inline StringRef getTypeName() {
28
2
#if defined(__clang__) || defined(__GNUC__)
29
2
  StringRef Name = __PRETTY_FUNCTION__;
30
2
31
2
  StringRef Key = "DesiredTypeName = ";
32
2
  Name = Name.substr(Name.find(Key));
33
2
  assert(!Name.empty() && "Unable to find the template parameter!");
34
2
  Name = Name.drop_front(Key.size());
35
2
36
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
2
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::TailCallElimPass>()
Line
Count
Source
27
74
inline StringRef getTypeName() {
28
74
#if defined(__clang__) || defined(__GNUC__)
29
74
  StringRef Name = __PRETTY_FUNCTION__;
30
74
31
74
  StringRef Key = "DesiredTypeName = ";
32
74
  Name = Name.substr(Name.find(Key));
33
74
  assert(!Name.empty() && "Unable to find the template parameter!");
34
74
  Name = Name.drop_front(Key.size());
35
74
36
74
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
74
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ReassociatePass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopInstSimplifyPass>()
Line
Count
Source
27
35
inline StringRef getTypeName() {
28
35
#if defined(__clang__) || defined(__GNUC__)
29
35
  StringRef Name = __PRETTY_FUNCTION__;
30
35
31
35
  StringRef Key = "DesiredTypeName = ";
32
35
  Name = Name.substr(Name.find(Key));
33
35
  assert(!Name.empty() && "Unable to find the template parameter!");
34
35
  Name = Name.drop_front(Key.size());
35
35
36
35
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
35
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopSimplifyCFGPass>()
Line
Count
Source
27
34
inline StringRef getTypeName() {
28
34
#if defined(__clang__) || defined(__GNUC__)
29
34
  StringRef Name = __PRETTY_FUNCTION__;
30
34
31
34
  StringRef Key = "DesiredTypeName = ";
32
34
  Name = Name.substr(Name.find(Key));
33
34
  assert(!Name.empty() && "Unable to find the template parameter!");
34
34
  Name = Name.drop_front(Key.size());
35
34
36
34
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
34
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopRotatePass>()
Line
Count
Source
27
40
inline StringRef getTypeName() {
28
40
#if defined(__clang__) || defined(__GNUC__)
29
40
  StringRef Name = __PRETTY_FUNCTION__;
30
40
31
40
  StringRef Key = "DesiredTypeName = ";
32
40
  Name = Name.substr(Name.find(Key));
33
40
  assert(!Name.empty() && "Unable to find the template parameter!");
34
40
  Name = Name.drop_front(Key.size());
35
40
36
40
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
40
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LICMPass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::SimpleLoopUnswitchPass>()
Line
Count
Source
27
34
inline StringRef getTypeName() {
28
34
#if defined(__clang__) || defined(__GNUC__)
29
34
  StringRef Name = __PRETTY_FUNCTION__;
30
34
31
34
  StringRef Key = "DesiredTypeName = ";
32
34
  Name = Name.substr(Name.find(Key));
33
34
  assert(!Name.empty() && "Unable to find the template parameter!");
34
34
  Name = Name.drop_front(Key.size());
35
34
36
34
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
34
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::IndVarSimplifyPass>()
Line
Count
Source
27
34
inline StringRef getTypeName() {
28
34
#if defined(__clang__) || defined(__GNUC__)
29
34
  StringRef Name = __PRETTY_FUNCTION__;
30
34
31
34
  StringRef Key = "DesiredTypeName = ";
32
34
  Name = Name.substr(Name.find(Key));
33
34
  assert(!Name.empty() && "Unable to find the template parameter!");
34
34
  Name = Name.drop_front(Key.size());
35
34
36
34
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
34
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopIdiomRecognizePass>()
Line
Count
Source
27
34
inline StringRef getTypeName() {
28
34
#if defined(__clang__) || defined(__GNUC__)
29
34
  StringRef Name = __PRETTY_FUNCTION__;
30
34
31
34
  StringRef Key = "DesiredTypeName = ";
32
34
  Name = Name.substr(Name.find(Key));
33
34
  assert(!Name.empty() && "Unable to find the template parameter!");
34
34
  Name = Name.drop_front(Key.size());
35
34
36
34
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
34
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopDeletionPass>()
Line
Count
Source
27
43
inline StringRef getTypeName() {
28
43
#if defined(__clang__) || defined(__GNUC__)
29
43
  StringRef Name = __PRETTY_FUNCTION__;
30
43
31
43
  StringRef Key = "DesiredTypeName = ";
32
43
  Name = Name.substr(Name.find(Key));
33
43
  assert(!Name.empty() && "Unable to find the template parameter!");
34
43
  Name = Name.drop_front(Key.size());
35
43
36
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
43
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopFullUnrollPass>()
Line
Count
Source
27
73
inline StringRef getTypeName() {
28
73
#if defined(__clang__) || defined(__GNUC__)
29
73
  StringRef Name = __PRETTY_FUNCTION__;
30
73
31
73
  StringRef Key = "DesiredTypeName = ";
32
73
  Name = Name.substr(Name.find(Key));
33
73
  assert(!Name.empty() && "Unable to find the template parameter!");
34
73
  Name = Name.drop_front(Key.size());
35
73
36
73
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
73
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::OptimizationRemarkEmitterAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
142
inline StringRef getTypeName() {
28
142
#if defined(__clang__) || defined(__GNUC__)
29
142
  StringRef Name = __PRETTY_FUNCTION__;
30
142
31
142
  StringRef Key = "DesiredTypeName = ";
32
142
  Name = Name.substr(Name.find(Key));
33
142
  assert(!Name.empty() && "Unable to find the template parameter!");
34
142
  Name = Name.drop_front(Key.size());
35
142
36
142
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
142
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PassManager<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&> >()
Line
Count
Source
27
48
inline StringRef getTypeName() {
28
48
#if defined(__clang__) || defined(__GNUC__)
29
48
  StringRef Name = __PRETTY_FUNCTION__;
30
48
31
48
  StringRef Key = "DesiredTypeName = ";
32
48
  Name = Name.substr(Name.find(Key));
33
48
  assert(!Name.empty() && "Unable to find the template parameter!");
34
48
  Name = Name.drop_front(Key.size());
35
48
36
48
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
48
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::FunctionToLoopPassAdaptor<llvm::PassManager<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&> > >()
Line
Count
Source
27
215
inline StringRef getTypeName() {
28
215
#if defined(__clang__) || defined(__GNUC__)
29
215
  StringRef Name = __PRETTY_FUNCTION__;
30
215
31
215
  StringRef Key = "DesiredTypeName = ";
32
215
  Name = Name.substr(Name.find(Key));
33
215
  assert(!Name.empty() && "Unable to find the template parameter!");
34
215
  Name = Name.drop_front(Key.size());
35
215
36
215
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
215
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::MergedLoadStoreMotionPass>()
Line
Count
Source
27
62
inline StringRef getTypeName() {
28
62
#if defined(__clang__) || defined(__GNUC__)
29
62
  StringRef Name = __PRETTY_FUNCTION__;
30
62
31
62
  StringRef Key = "DesiredTypeName = ";
32
62
  Name = Name.substr(Name.find(Key));
33
62
  assert(!Name.empty() && "Unable to find the template parameter!");
34
62
  Name = Name.drop_front(Key.size());
35
62
36
62
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
62
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::NewGVNPass>()
llvm::StringRef llvm::getTypeName<llvm::GVN>()
Line
Count
Source
27
66
inline StringRef getTypeName() {
28
66
#if defined(__clang__) || defined(__GNUC__)
29
66
  StringRef Name = __PRETTY_FUNCTION__;
30
66
31
66
  StringRef Key = "DesiredTypeName = ";
32
66
  Name = Name.substr(Name.find(Key));
33
66
  assert(!Name.empty() && "Unable to find the template parameter!");
34
66
  Name = Name.drop_front(Key.size());
35
66
36
66
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
66
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::MemCpyOptPass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::SCCPPass>()
Line
Count
Source
27
68
inline StringRef getTypeName() {
28
68
#if defined(__clang__) || defined(__GNUC__)
29
68
  StringRef Name = __PRETTY_FUNCTION__;
30
68
31
68
  StringRef Key = "DesiredTypeName = ";
32
68
  Name = Name.substr(Name.find(Key));
33
68
  assert(!Name.empty() && "Unable to find the template parameter!");
34
68
  Name = Name.drop_front(Key.size());
35
68
36
68
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
68
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::BDCEPass>()
Line
Count
Source
27
69
inline StringRef getTypeName() {
28
69
#if defined(__clang__) || defined(__GNUC__)
29
69
  StringRef Name = __PRETTY_FUNCTION__;
30
69
31
69
  StringRef Key = "DesiredTypeName = ";
32
69
  Name = Name.substr(Name.find(Key));
33
69
  assert(!Name.empty() && "Unable to find the template parameter!");
34
69
  Name = Name.drop_front(Key.size());
35
69
36
69
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
69
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::DSEPass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::FunctionToLoopPassAdaptor<llvm::LICMPass> >()
Line
Count
Source
27
126
inline StringRef getTypeName() {
28
126
#if defined(__clang__) || defined(__GNUC__)
29
126
  StringRef Name = __PRETTY_FUNCTION__;
30
126
31
126
  StringRef Key = "DesiredTypeName = ";
32
126
  Name = Name.substr(Name.find(Key));
33
126
  assert(!Name.empty() && "Unable to find the template parameter!");
34
126
  Name = Name.drop_front(Key.size());
35
126
36
126
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
126
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ADCEPass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ControlHeightReductionPass>()
llvm::StringRef llvm::getTypeName<llvm::InlinerPass>()
Line
Count
Source
27
94
inline StringRef getTypeName() {
28
94
#if defined(__clang__) || defined(__GNUC__)
29
94
  StringRef Name = __PRETTY_FUNCTION__;
30
94
31
94
  StringRef Key = "DesiredTypeName = ";
32
94
  Name = Name.substr(Name.find(Key));
33
94
  assert(!Name.empty() && "Unable to find the template parameter!");
34
94
  Name = Name.drop_front(Key.size());
35
94
36
94
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
94
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::CGSCCToFunctionPassAdaptor<llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> > > >()
Line
Count
Source
27
132
inline StringRef getTypeName() {
28
132
#if defined(__clang__) || defined(__GNUC__)
29
132
  StringRef Name = __PRETTY_FUNCTION__;
30
132
31
132
  StringRef Key = "DesiredTypeName = ";
32
132
  Name = Name.substr(Name.find(Key));
33
132
  assert(!Name.empty() && "Unable to find the template parameter!");
34
132
  Name = Name.drop_front(Key.size());
35
132
36
132
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
132
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> >()
Line
Count
Source
27
32
inline StringRef getTypeName() {
28
32
#if defined(__clang__) || defined(__GNUC__)
29
32
  StringRef Name = __PRETTY_FUNCTION__;
30
32
31
32
  StringRef Key = "DesiredTypeName = ";
32
32
  Name = Name.substr(Name.find(Key));
33
32
  assert(!Name.empty() && "Unable to find the template parameter!");
34
32
  Name = Name.drop_front(Key.size());
35
32
36
32
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
32
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToPostOrderCGSCCPassAdaptor<llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> > >()
Line
Count
Source
27
76
inline StringRef getTypeName() {
28
76
#if defined(__clang__) || defined(__GNUC__)
29
76
  StringRef Name = __PRETTY_FUNCTION__;
30
76
31
76
  StringRef Key = "DesiredTypeName = ";
32
76
  Name = Name.substr(Name.find(Key));
33
76
  assert(!Name.empty() && "Unable to find the template parameter!");
34
76
  Name = Name.drop_front(Key.size());
35
76
36
76
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
76
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::GlobalDCEPass>()
Line
Count
Source
27
202
inline StringRef getTypeName() {
28
202
#if defined(__clang__) || defined(__GNUC__)
29
202
  StringRef Name = __PRETTY_FUNCTION__;
30
202
31
202
  StringRef Key = "DesiredTypeName = ";
32
202
  Name = Name.substr(Name.find(Key));
33
202
  assert(!Name.empty() && "Unable to find the template parameter!");
34
202
  Name = Name.drop_front(Key.size());
35
202
36
202
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
202
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PGOInstrumentationGen>()
Line
Count
Source
27
9
inline StringRef getTypeName() {
28
9
#if defined(__clang__) || defined(__GNUC__)
29
9
  StringRef Name = __PRETTY_FUNCTION__;
30
9
31
9
  StringRef Key = "DesiredTypeName = ";
32
9
  Name = Name.substr(Name.find(Key));
33
9
  assert(!Name.empty() && "Unable to find the template parameter!");
34
9
  Name = Name.drop_front(Key.size());
35
9
36
9
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
9
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::FunctionToLoopPassAdaptor<llvm::LoopRotatePass> >()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PGOInstrumentationUse>()
Line
Count
Source
27
22
inline StringRef getTypeName() {
28
22
#if defined(__clang__) || defined(__GNUC__)
29
22
  StringRef Name = __PRETTY_FUNCTION__;
30
22
31
22
  StringRef Key = "DesiredTypeName = ";
32
22
  Name = Name.substr(Name.find(Key));
33
22
  assert(!Name.empty() && "Unable to find the template parameter!");
34
22
  Name = Name.drop_front(Key.size());
35
22
36
22
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
22
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::ProfileSummaryAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
27
109
inline StringRef getTypeName() {
28
109
#if defined(__clang__) || defined(__GNUC__)
29
109
  StringRef Name = __PRETTY_FUNCTION__;
30
109
31
109
  StringRef Key = "DesiredTypeName = ";
32
109
  Name = Name.substr(Name.find(Key));
33
109
  assert(!Name.empty() && "Unable to find the template parameter!");
34
109
  Name = Name.drop_front(Key.size());
35
109
36
109
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
109
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PGOIndirectCallPromotion>()
Line
Count
Source
27
50
inline StringRef getTypeName() {
28
50
#if defined(__clang__) || defined(__GNUC__)
29
50
  StringRef Name = __PRETTY_FUNCTION__;
30
50
31
50
  StringRef Key = "DesiredTypeName = ";
32
50
  Name = Name.substr(Name.find(Key));
33
50
  assert(!Name.empty() && "Unable to find the template parameter!");
34
50
  Name = Name.drop_front(Key.size());
35
50
36
50
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
50
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::InferFunctionAttrsPass>()
Line
Count
Source
27
96
inline StringRef getTypeName() {
28
96
#if defined(__clang__) || defined(__GNUC__)
29
96
  StringRef Name = __PRETTY_FUNCTION__;
30
96
31
96
  StringRef Key = "DesiredTypeName = ";
32
96
  Name = Name.substr(Name.find(Key));
33
96
  assert(!Name.empty() && "Unable to find the template parameter!");
34
96
  Name = Name.drop_front(Key.size());
35
96
36
96
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
96
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LowerExpectIntrinsicPass>()
Line
Count
Source
27
65
inline StringRef getTypeName() {
28
65
#if defined(__clang__) || defined(__GNUC__)
29
65
  StringRef Name = __PRETTY_FUNCTION__;
30
65
31
65
  StringRef Key = "DesiredTypeName = ";
32
65
  Name = Name.substr(Name.find(Key));
33
65
  assert(!Name.empty() && "Unable to find the template parameter!");
34
65
  Name = Name.drop_front(Key.size());
35
65
36
65
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
65
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::CallSiteSplittingPass>()
Line
Count
Source
27
25
inline StringRef getTypeName() {
28
25
#if defined(__clang__) || defined(__GNUC__)
29
25
  StringRef Name = __PRETTY_FUNCTION__;
30
25
31
25
  StringRef Key = "DesiredTypeName = ";
32
25
  Name = Name.substr(Name.find(Key));
33
25
  assert(!Name.empty() && "Unable to find the template parameter!");
34
25
  Name = Name.drop_front(Key.size());
35
25
36
25
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
25
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::SampleProfileLoaderPass>()
Line
Count
Source
27
4
inline StringRef getTypeName() {
28
4
#if defined(__clang__) || defined(__GNUC__)
29
4
  StringRef Name = __PRETTY_FUNCTION__;
30
4
31
4
  StringRef Key = "DesiredTypeName = ";
32
4
  Name = Name.substr(Name.find(Key));
33
4
  assert(!Name.empty() && "Unable to find the template parameter!");
34
4
  Name = Name.drop_front(Key.size());
35
4
36
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
4
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::IPSCCPPass>()
Line
Count
Source
27
96
inline StringRef getTypeName() {
28
96
#if defined(__clang__) || defined(__GNUC__)
29
96
  StringRef Name = __PRETTY_FUNCTION__;
30
96
31
96
  StringRef Key = "DesiredTypeName = ";
32
96
  Name = Name.substr(Name.find(Key));
33
96
  assert(!Name.empty() && "Unable to find the template parameter!");
34
96
  Name = Name.drop_front(Key.size());
35
96
36
96
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
96
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::CalledValuePropagationPass>()
Line
Count
Source
27
95
inline StringRef getTypeName() {
28
95
#if defined(__clang__) || defined(__GNUC__)
29
95
  StringRef Name = __PRETTY_FUNCTION__;
30
95
31
95
  StringRef Key = "DesiredTypeName = ";
32
95
  Name = Name.substr(Name.find(Key));
33
95
  assert(!Name.empty() && "Unable to find the template parameter!");
34
95
  Name = Name.drop_front(Key.size());
35
95
36
95
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
95
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::GlobalOptPass>()
Line
Count
Source
27
190
inline StringRef getTypeName() {
28
190
#if defined(__clang__) || defined(__GNUC__)
29
190
  StringRef Name = __PRETTY_FUNCTION__;
30
190
31
190
  StringRef Key = "DesiredTypeName = ";
32
190
  Name = Name.substr(Name.find(Key));
33
190
  assert(!Name.empty() && "Unable to find the template parameter!");
34
190
  Name = Name.drop_front(Key.size());
35
190
36
190
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
190
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PromotePass>()
Line
Count
Source
27
14
inline StringRef getTypeName() {
28
14
#if defined(__clang__) || defined(__GNUC__)
29
14
  StringRef Name = __PRETTY_FUNCTION__;
30
14
31
14
  StringRef Key = "DesiredTypeName = ";
32
14
  Name = Name.substr(Name.find(Key));
33
14
  assert(!Name.empty() && "Unable to find the template parameter!");
34
14
  Name = Name.drop_front(Key.size());
35
14
36
14
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
14
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::PromotePass> >()
Line
Count
Source
27
95
inline StringRef getTypeName() {
28
95
#if defined(__clang__) || defined(__GNUC__)
29
95
  StringRef Name = __PRETTY_FUNCTION__;
30
95
31
95
  StringRef Key = "DesiredTypeName = ";
32
95
  Name = Name.substr(Name.find(Key));
33
95
  assert(!Name.empty() && "Unable to find the template parameter!");
34
95
  Name = Name.drop_front(Key.size());
35
95
36
95
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
95
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::DeadArgumentEliminationPass>()
Line
Count
Source
27
95
inline StringRef getTypeName() {
28
95
#if defined(__clang__) || defined(__GNUC__)
29
95
  StringRef Name = __PRETTY_FUNCTION__;
30
95
31
95
  StringRef Key = "DesiredTypeName = ";
32
95
  Name = Name.substr(Name.find(Key));
33
95
  assert(!Name.empty() && "Unable to find the template parameter!");
34
95
  Name = Name.drop_front(Key.size());
35
95
36
95
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
95
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PGOInstrumentationGenCreateVar>()
Line
Count
Source
27
8
inline StringRef getTypeName() {
28
8
#if defined(__clang__) || defined(__GNUC__)
29
8
  StringRef Name = __PRETTY_FUNCTION__;
30
8
31
8
  StringRef Key = "DesiredTypeName = ";
32
8
  Name = Name.substr(Name.find(Key));
33
8
  assert(!Name.empty() && "Unable to find the template parameter!");
34
8
  Name = Name.drop_front(Key.size());
35
8
36
8
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
8
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::SyntheticCountsPropagation>()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::GlobalsAA, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
27
153
inline StringRef getTypeName() {
28
153
#if defined(__clang__) || defined(__GNUC__)
29
153
  StringRef Name = __PRETTY_FUNCTION__;
30
153
31
153
  StringRef Key = "DesiredTypeName = ";
32
153
  Name = Name.substr(Name.find(Key));
33
153
  assert(!Name.empty() && "Unable to find the template parameter!");
34
153
  Name = Name.drop_front(Key.size());
35
153
36
153
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
153
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PostOrderFunctionAttrsPass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ArgumentPromotionPass>()
Line
Count
Source
27
19
inline StringRef getTypeName() {
28
19
#if defined(__clang__) || defined(__GNUC__)
29
19
  StringRef Name = __PRETTY_FUNCTION__;
30
19
31
19
  StringRef Key = "DesiredTypeName = ";
32
19
  Name = Name.substr(Name.find(Key));
33
19
  assert(!Name.empty() && "Unable to find the template parameter!");
34
19
  Name = Name.drop_front(Key.size());
35
19
36
19
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
19
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::DevirtSCCRepeatedPass<llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> > >()
Line
Count
Source
27
12
inline StringRef getTypeName() {
28
12
#if defined(__clang__) || defined(__GNUC__)
29
12
  StringRef Name = __PRETTY_FUNCTION__;
30
12
31
12
  StringRef Key = "DesiredTypeName = ";
32
12
  Name = Name.substr(Name.find(Key));
33
12
  assert(!Name.empty() && "Unable to find the template parameter!");
34
12
  Name = Name.drop_front(Key.size());
35
12
36
12
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
12
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToPostOrderCGSCCPassAdaptor<llvm::DevirtSCCRepeatedPass<llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> > > >()
Line
Count
Source
27
83
inline StringRef getTypeName() {
28
83
#if defined(__clang__) || defined(__GNUC__)
29
83
  StringRef Name = __PRETTY_FUNCTION__;
30
83
31
83
  StringRef Key = "DesiredTypeName = ";
32
83
  Name = Name.substr(Name.find(Key));
33
83
  assert(!Name.empty() && "Unable to find the template parameter!");
34
83
  Name = Name.drop_front(Key.size());
35
83
36
83
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
83
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PartialInlinerPass>()
llvm::StringRef llvm::getTypeName<llvm::EliminateAvailableExternallyPass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InstrOrderFilePass>()
llvm::StringRef llvm::getTypeName<llvm::ReversePostOrderFunctionAttrsPass>()
Line
Count
Source
27
80
inline StringRef getTypeName() {
28
80
#if defined(__clang__) || defined(__GNUC__)
29
80
  StringRef Name = __PRETTY_FUNCTION__;
30
80
31
80
  StringRef Key = "DesiredTypeName = ";
32
80
  Name = Name.substr(Name.find(Key));
33
80
  assert(!Name.empty() && "Unable to find the template parameter!");
34
80
  Name = Name.drop_front(Key.size());
35
80
36
80
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
80
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::Float2IntPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopDistributePass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopVectorizePass>()
Line
Count
Source
27
61
inline StringRef getTypeName() {
28
61
#if defined(__clang__) || defined(__GNUC__)
29
61
  StringRef Name = __PRETTY_FUNCTION__;
30
61
31
61
  StringRef Key = "DesiredTypeName = ";
32
61
  Name = Name.substr(Name.find(Key));
33
61
  assert(!Name.empty() && "Unable to find the template parameter!");
34
61
  Name = Name.drop_front(Key.size());
35
61
36
61
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
61
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopLoadEliminationPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::SLPVectorizerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LoopUnrollAndJamPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::FunctionToLoopPassAdaptor<llvm::LoopUnrollAndJamPass> >()
llvm::StringRef llvm::getTypeName<llvm::LoopUnrollPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::WarnMissedTransformationsPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::AlignmentFromAssumptionsPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::HotColdSplittingPass>()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LoopSinkPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::InstSimplifyPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::DivRemPairsPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::SpeculateAroundPHIsPass>()
Line
Count
Source
27
59
inline StringRef getTypeName() {
28
59
#if defined(__clang__) || defined(__GNUC__)
29
59
  StringRef Name = __PRETTY_FUNCTION__;
30
59
31
59
  StringRef Key = "DesiredTypeName = ";
32
59
  Name = Name.substr(Name.find(Key));
33
59
  assert(!Name.empty() && "Unable to find the template parameter!");
34
59
  Name = Name.drop_front(Key.size());
35
59
36
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
59
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::CGProfilePass>()
Line
Count
Source
27
67
inline StringRef getTypeName() {
28
67
#if defined(__clang__) || defined(__GNUC__)
29
67
  StringRef Name = __PRETTY_FUNCTION__;
30
67
31
67
  StringRef Key = "DesiredTypeName = ";
32
67
  Name = Name.substr(Name.find(Key));
33
67
  assert(!Name.empty() && "Unable to find the template parameter!");
34
67
  Name = Name.drop_front(Key.size());
35
67
36
67
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
67
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ConstantMergePass>()
Line
Count
Source
27
79
inline StringRef getTypeName() {
28
79
#if defined(__clang__) || defined(__GNUC__)
29
79
  StringRef Name = __PRETTY_FUNCTION__;
30
79
31
79
  StringRef Key = "DesiredTypeName = ";
32
79
  Name = Name.substr(Name.find(Key));
33
79
  assert(!Name.empty() && "Unable to find the template parameter!");
34
79
  Name = Name.drop_front(Key.size());
35
79
36
79
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
79
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ForceFunctionAttrsPass>()
Line
Count
Source
27
96
inline StringRef getTypeName() {
28
96
#if defined(__clang__) || defined(__GNUC__)
29
96
  StringRef Name = __PRETTY_FUNCTION__;
30
96
31
96
  StringRef Key = "DesiredTypeName = ";
32
96
  Name = Name.substr(Name.find(Key));
33
96
  assert(!Name.empty() && "Unable to find the template parameter!");
34
96
  Name = Name.drop_front(Key.size());
35
96
36
96
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
96
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::AddDiscriminatorsPass>()
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::AddDiscriminatorsPass> >()
Line
Count
Source
27
5
inline StringRef getTypeName() {
28
5
#if defined(__clang__) || defined(__GNUC__)
29
5
  StringRef Name = __PRETTY_FUNCTION__;
30
5
31
5
  StringRef Key = "DesiredTypeName = ";
32
5
  Name = Name.substr(Name.find(Key));
33
5
  assert(!Name.empty() && "Unable to find the template parameter!");
34
5
  Name = Name.drop_front(Key.size());
35
5
36
5
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
5
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
27
211
inline StringRef getTypeName() {
28
211
#if defined(__clang__) || defined(__GNUC__)
29
211
  StringRef Name = __PRETTY_FUNCTION__;
30
211
31
211
  StringRef Key = "DesiredTypeName = ";
32
211
  Name = Name.substr(Name.find(Key));
33
211
  assert(!Name.empty() && "Unable to find the template parameter!");
34
211
  Name = Name.drop_front(Key.size());
35
211
36
211
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
211
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::WholeProgramDevirtPass>()
Line
Count
Source
27
22
inline StringRef getTypeName() {
28
22
#if defined(__clang__) || defined(__GNUC__)
29
22
  StringRef Name = __PRETTY_FUNCTION__;
30
22
31
22
  StringRef Key = "DesiredTypeName = ";
32
22
  Name = Name.substr(Name.find(Key));
33
22
  assert(!Name.empty() && "Unable to find the template parameter!");
34
22
  Name = Name.drop_front(Key.size());
35
22
36
22
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
22
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::LowerTypeTestsPass>()
Line
Count
Source
27
22
inline StringRef getTypeName() {
28
22
#if defined(__clang__) || defined(__GNUC__)
29
22
  StringRef Name = __PRETTY_FUNCTION__;
30
22
31
22
  StringRef Key = "DesiredTypeName = ";
32
22
  Name = Name.substr(Name.find(Key));
33
22
  assert(!Name.empty() && "Unable to find the template parameter!");
34
22
  Name = Name.drop_front(Key.size());
35
22
36
22
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
22
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToPostOrderCGSCCPassAdaptor<llvm::PostOrderFunctionAttrsPass> >()
Line
Count
Source
27
25
inline StringRef getTypeName() {
28
25
#if defined(__clang__) || defined(__GNUC__)
29
25
  StringRef Name = __PRETTY_FUNCTION__;
30
25
31
25
  StringRef Key = "DesiredTypeName = ";
32
25
  Name = Name.substr(Name.find(Key));
33
25
  assert(!Name.empty() && "Unable to find the template parameter!");
34
25
  Name = Name.drop_front(Key.size());
35
25
36
25
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
25
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::GlobalSplitPass>()
Line
Count
Source
27
13
inline StringRef getTypeName() {
28
13
#if defined(__clang__) || defined(__GNUC__)
29
13
  StringRef Name = __PRETTY_FUNCTION__;
30
13
31
13
  StringRef Key = "DesiredTypeName = ";
32
13
  Name = Name.substr(Name.find(Key));
33
13
  assert(!Name.empty() && "Unable to find the template parameter!");
34
13
  Name = Name.drop_front(Key.size());
35
13
36
13
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
13
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToPostOrderCGSCCPassAdaptor<llvm::InlinerPass> >()
Line
Count
Source
27
12
inline StringRef getTypeName() {
28
12
#if defined(__clang__) || defined(__GNUC__)
29
12
  StringRef Name = __PRETTY_FUNCTION__;
30
12
31
12
  StringRef Key = "DesiredTypeName = ";
32
12
  Name = Name.substr(Name.find(Key));
33
12
  assert(!Name.empty() && "Unable to find the template parameter!");
34
12
  Name = Name.drop_front(Key.size());
35
12
36
12
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
12
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::CrossDSOCFIPass>()
Line
Count
Source
27
12
inline StringRef getTypeName() {
28
12
#if defined(__clang__) || defined(__GNUC__)
29
12
  StringRef Name = __PRETTY_FUNCTION__;
30
12
31
12
  StringRef Key = "DesiredTypeName = ";
32
12
  Name = Name.substr(Name.find(Key));
33
12
  assert(!Name.empty() && "Unable to find the template parameter!");
34
12
  Name = Name.drop_front(Key.size());
35
12
36
12
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
12
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::SimplifyCFGPass> >()
Line
Count
Source
27
12
inline StringRef getTypeName() {
28
12
#if defined(__clang__) || defined(__GNUC__)
29
12
  StringRef Name = __PRETTY_FUNCTION__;
30
12
31
12
  StringRef Key = "DesiredTypeName = ";
32
12
  Name = Name.substr(Name.find(Key));
33
12
  assert(!Name.empty() && "Unable to find the template parameter!");
34
12
  Name = Name.drop_front(Key.size());
35
12
36
12
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
12
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::RepeatedPass<llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module> > > >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::CallGraphAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::CallGraphAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::LazyCallGraphAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::LazyCallGraphAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::ModuleSummaryIndexAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::ModuleSummaryIndexAnalysis> >()
PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<(anonymous namespace)::NoOpModuleAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
27
15
inline StringRef getTypeName() {
28
15
#if defined(__clang__) || defined(__GNUC__)
29
15
  StringRef Name = __PRETTY_FUNCTION__;
30
15
31
15
  StringRef Key = "DesiredTypeName = ";
32
15
  Name = Name.substr(Name.find(Key));
33
15
  assert(!Name.empty() && "Unable to find the template parameter!");
34
15
  Name = Name.drop_front(Key.size());
35
15
36
15
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
15
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<(anonymous namespace)::NoOpModuleAnalysis> >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::ProfileSummaryAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::StackSafetyGlobalAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::StackSafetyGlobalAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::TargetLibraryAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
27
2
inline StringRef getTypeName() {
28
2
#if defined(__clang__) || defined(__GNUC__)
29
2
  StringRef Name = __PRETTY_FUNCTION__;
30
2
31
2
  StringRef Key = "DesiredTypeName = ";
32
2
  Name = Name.substr(Name.find(Key));
33
2
  assert(!Name.empty() && "Unable to find the template parameter!");
34
2
  Name = Name.drop_front(Key.size());
35
2
36
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
2
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::TargetLibraryAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::VerifierAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::VerifierAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::PassInstrumentationAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::PassInstrumentationAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::ASanGlobalsMetadataAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::GlobalsAA> >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::AttributorPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::FunctionImportPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InternalizePass>()
llvm::StringRef llvm::getTypeName<llvm::InvalidateAllAnalysesPass>()
Line
Count
Source
27
4
inline StringRef getTypeName() {
28
4
#if defined(__clang__) || defined(__GNUC__)
29
4
  StringRef Name = __PRETTY_FUNCTION__;
30
4
31
4
  StringRef Key = "DesiredTypeName = ";
32
4
  Name = Name.substr(Name.find(Key));
33
4
  assert(!Name.empty() && "Unable to find the template parameter!");
34
4
  Name = Name.drop_front(Key.size());
35
4
36
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
4
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PreISelIntrinsicLoweringPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ProfileSummaryPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::CallGraphPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LazyCallGraphPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LazyCallGraphDOTPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::StackSafetyGlobalPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RewriteStatepointsForGC>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RewriteSymbolPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::StripDeadPrototypesPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PoisonCheckingPass>()
llvm::StringRef llvm::getTypeName<llvm::RepeatedPass<llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> > >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<(anonymous namespace)::NoOpCGSCCAnalysis, llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> >()
Line
Count
Source
27
9
inline StringRef getTypeName() {
28
9
#if defined(__clang__) || defined(__GNUC__)
29
9
  StringRef Name = __PRETTY_FUNCTION__;
30
9
31
9
  StringRef Key = "DesiredTypeName = ";
32
9
  Name = Name.substr(Name.find(Key));
33
9
  assert(!Name.empty() && "Unable to find the template parameter!");
34
9
  Name = Name.drop_front(Key.size());
35
9
36
9
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
9
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<(anonymous namespace)::NoOpCGSCCAnalysis> >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::FunctionAnalysisManagerCGSCCProxy, llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::FunctionAnalysisManagerCGSCCProxy> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::PassInstrumentationAnalysis, llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> >()
llvm::StringRef llvm::getTypeName<llvm::RepeatedPass<llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> > > >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::AAManager, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
9
inline StringRef getTypeName() {
28
9
#if defined(__clang__) || defined(__GNUC__)
29
9
  StringRef Name = __PRETTY_FUNCTION__;
30
9
31
9
  StringRef Key = "DesiredTypeName = ";
32
9
  Name = Name.substr(Name.find(Key));
33
9
  assert(!Name.empty() && "Unable to find the template parameter!");
34
9
  Name = Name.drop_front(Key.size());
35
9
36
9
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
9
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::AAManager> >()
Line
Count
Source
27
3
inline StringRef getTypeName() {
28
3
#if defined(__clang__) || defined(__GNUC__)
29
3
  StringRef Name = __PRETTY_FUNCTION__;
30
3
31
3
  StringRef Key = "DesiredTypeName = ";
32
3
  Name = Name.substr(Name.find(Key));
33
3
  assert(!Name.empty() && "Unable to find the template parameter!");
34
3
  Name = Name.drop_front(Key.size());
35
3
36
3
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
3
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::AssumptionAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::AssumptionAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::BlockFrequencyAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::BlockFrequencyAnalysis> >()
Line
Count
Source
27
2
inline StringRef getTypeName() {
28
2
#if defined(__clang__) || defined(__GNUC__)
29
2
  StringRef Name = __PRETTY_FUNCTION__;
30
2
31
2
  StringRef Key = "DesiredTypeName = ";
32
2
  Name = Name.substr(Name.find(Key));
33
2
  assert(!Name.empty() && "Unable to find the template parameter!");
34
2
  Name = Name.drop_front(Key.size());
35
2
36
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
2
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::BranchProbabilityAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::BranchProbabilityAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::DominatorTreeAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
8
inline StringRef getTypeName() {
28
8
#if defined(__clang__) || defined(__GNUC__)
29
8
  StringRef Name = __PRETTY_FUNCTION__;
30
8
31
8
  StringRef Key = "DesiredTypeName = ";
32
8
  Name = Name.substr(Name.find(Key));
33
8
  assert(!Name.empty() && "Unable to find the template parameter!");
34
8
  Name = Name.drop_front(Key.size());
35
8
36
8
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
8
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::DominatorTreeAnalysis> >()
Line
Count
Source
27
7
inline StringRef getTypeName() {
28
7
#if defined(__clang__) || defined(__GNUC__)
29
7
  StringRef Name = __PRETTY_FUNCTION__;
30
7
31
7
  StringRef Key = "DesiredTypeName = ";
32
7
  Name = Name.substr(Name.find(Key));
33
7
  assert(!Name.empty() && "Unable to find the template parameter!");
34
7
  Name = Name.drop_front(Key.size());
35
7
36
7
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
7
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::PostDominatorTreeAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
4
inline StringRef getTypeName() {
28
4
#if defined(__clang__) || defined(__GNUC__)
29
4
  StringRef Name = __PRETTY_FUNCTION__;
30
4
31
4
  StringRef Key = "DesiredTypeName = ";
32
4
  Name = Name.substr(Name.find(Key));
33
4
  assert(!Name.empty() && "Unable to find the template parameter!");
34
4
  Name = Name.drop_front(Key.size());
35
4
36
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
4
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::PostDominatorTreeAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::DemandedBitsAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::DemandedBitsAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::DominanceFrontierAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::DominanceFrontierAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::LoopAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::LoopAnalysis> >()
Line
Count
Source
27
6
inline StringRef getTypeName() {
28
6
#if defined(__clang__) || defined(__GNUC__)
29
6
  StringRef Name = __PRETTY_FUNCTION__;
30
6
31
6
  StringRef Key = "DesiredTypeName = ";
32
6
  Name = Name.substr(Name.find(Key));
33
6
  assert(!Name.empty() && "Unable to find the template parameter!");
34
6
  Name = Name.drop_front(Key.size());
35
6
36
6
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
6
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::LazyValueAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
4
inline StringRef getTypeName() {
28
4
#if defined(__clang__) || defined(__GNUC__)
29
4
  StringRef Name = __PRETTY_FUNCTION__;
30
4
31
4
  StringRef Key = "DesiredTypeName = ";
32
4
  Name = Name.substr(Name.find(Key));
33
4
  assert(!Name.empty() && "Unable to find the template parameter!");
34
4
  Name = Name.drop_front(Key.size());
35
4
36
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
4
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::LazyValueAnalysis> >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::DependenceAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::DependenceAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::MemoryDependenceAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
5
inline StringRef getTypeName() {
28
5
#if defined(__clang__) || defined(__GNUC__)
29
5
  StringRef Name = __PRETTY_FUNCTION__;
30
5
31
5
  StringRef Key = "DesiredTypeName = ";
32
5
  Name = Name.substr(Name.find(Key));
33
5
  assert(!Name.empty() && "Unable to find the template parameter!");
34
5
  Name = Name.drop_front(Key.size());
35
5
36
5
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
5
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::MemoryDependenceAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::MemorySSAAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
2
inline StringRef getTypeName() {
28
2
#if defined(__clang__) || defined(__GNUC__)
29
2
  StringRef Name = __PRETTY_FUNCTION__;
30
2
31
2
  StringRef Key = "DesiredTypeName = ";
32
2
  Name = Name.substr(Name.find(Key));
33
2
  assert(!Name.empty() && "Unable to find the template parameter!");
34
2
  Name = Name.drop_front(Key.size());
35
2
36
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
2
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::MemorySSAAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::PhiValuesAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::PhiValuesAnalysis> >()
Line
Count
Source
27
1
inline StringRef getTypeName() {
28
1
#if defined(__clang__) || defined(__GNUC__)
29
1
  StringRef Name = __PRETTY_FUNCTION__;
30
1
31
1
  StringRef Key = "DesiredTypeName = ";
32
1
  Name = Name.substr(Name.find(Key));
33
1
  assert(!Name.empty() && "Unable to find the template parameter!");
34
1
  Name = Name.drop_front(Key.size());
35
1
36
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
1
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48
      Name = Name.drop_front(Prefix.size());
49
      break;
50
    }
51
52
  auto AnglePos = Name.rfind('>');
53
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
54
  return Name.substr(0, AnglePos);
55
#else
56
  // No known technique for statically extracting a type name on this compiler.
57
  // We return a string that is unlikely to look like any type in LLVM.
58
  return "UNKNOWN_TYPE";
59
#endif
60
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::RegionInfoAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::RegionInfoAnalysis> >()
PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<(anonymous namespace)::NoOpFunctionAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
27
11
inline StringRef getTypeName() {
28
11
#if defined(__clang__) || defined(__GNUC__)
29
11
  StringRef Name = __PRETTY_FUNCTION__;
30
11
31
11
  StringRef Key = "DesiredTypeName = ";
32
11
  Name = Name.substr(Name.find(Key));
33
11
  assert(!Name.empty() && "Unable to find the template parameter!");
34
11
  Name = Name.drop_front(Key.size());
35
11
36
11
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
37
11
  return Name.drop_back(1);
38
#elif defined(_MSC_VER)
39
  StringRef Name = __FUNCSIG__;
40
41
  StringRef Key = "getTypeName<";
42
  Name = Name.substr(Name.find(Key));
43
  assert(!Name.empty() && "Unable to find the function name!");
44
  Name = Name.drop_front(Key.size());
45
46
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
47
    if (Name.startswith(Prefix)) {
48