Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Support/TypeName.h
Line
Count
Source
1
//===- TypeName.h -----------------------------------------------*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
10
#ifndef LLVM_SUPPORT_TYPENAME_H
11
#define LLVM_SUPPORT_TYPENAME_H
12
13
#include "llvm/ADT/StringRef.h"
14
15
namespace llvm {
16
17
/// We provide a function which tries to compute the (demangled) name of a type
18
/// statically.
19
///
20
/// This routine may fail on some platforms or for particularly unusual types.
21
/// Do not use it for anything other than logging and debugging aids. It isn't
22
/// portable or dependendable in any real sense.
23
///
24
/// The returned StringRef will point into a static storage duration string.
25
/// However, it may not be null terminated and may be some strangely aligned
26
/// inner substring of a larger string.
27
template <typename DesiredTypeName>
28
7.29k
inline StringRef getTypeName() {
29
7.29k
#if defined(__clang__) || defined(__GNUC__)
30
7.29k
  StringRef Name = __PRETTY_FUNCTION__;
31
7.29k
32
7.29k
  StringRef Key = "DesiredTypeName = ";
33
7.29k
  Name = Name.substr(Name.find(Key));
34
7.29k
  assert(!Name.empty() && "Unable to find the template parameter!");
35
7.29k
  Name = Name.drop_front(Key.size());
36
7.29k
37
7.29k
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
7.29k
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::AAManager>()
Line
Count
Source
28
146
inline StringRef getTypeName() {
29
146
#if defined(__clang__) || defined(__GNUC__)
30
146
  StringRef Name = __PRETTY_FUNCTION__;
31
146
32
146
  StringRef Key = "DesiredTypeName = ";
33
146
  Name = Name.substr(Name.find(Key));
34
146
  assert(!Name.empty() && "Unable to find the template parameter!");
35
146
  Name = Name.drop_front(Key.size());
36
146
37
146
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
146
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::VerifierPass>()
Line
Count
Source
28
108
inline StringRef getTypeName() {
29
108
#if defined(__clang__) || defined(__GNUC__)
30
108
  StringRef Name = __PRETTY_FUNCTION__;
31
108
32
108
  StringRef Key = "DesiredTypeName = ";
33
108
  Name = Name.substr(Name.find(Key));
34
108
  assert(!Name.empty() && "Unable to find the template parameter!");
35
108
  Name = Name.drop_front(Key.size());
36
108
37
108
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
108
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::BitcodeWriterPass>()
Line
Count
Source
28
12
inline StringRef getTypeName() {
29
12
#if defined(__clang__) || defined(__GNUC__)
30
12
  StringRef Name = __PRETTY_FUNCTION__;
31
12
32
12
  StringRef Key = "DesiredTypeName = ";
33
12
  Name = Name.substr(Name.find(Key));
34
12
  assert(!Name.empty() && "Unable to find the template parameter!");
35
12
  Name = Name.drop_front(Key.size());
36
12
37
12
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
12
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ThinLTOBitcodeWriterPass>()
Line
Count
Source
28
8
inline StringRef getTypeName() {
29
8
#if defined(__clang__) || defined(__GNUC__)
30
8
  StringRef Name = __PRETTY_FUNCTION__;
31
8
32
8
  StringRef Key = "DesiredTypeName = ";
33
8
  Name = Name.substr(Name.find(Key));
34
8
  assert(!Name.empty() && "Unable to find the template parameter!");
35
8
  Name = Name.drop_front(Key.size());
36
8
37
8
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
8
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::Module>()
Line
Count
Source
28
536
inline StringRef getTypeName() {
29
536
#if defined(__clang__) || defined(__GNUC__)
30
536
  StringRef Name = __PRETTY_FUNCTION__;
31
536
32
536
  StringRef Key = "DesiredTypeName = ";
33
536
  Name = Name.substr(Name.find(Key));
34
536
  assert(!Name.empty() && "Unable to find the template parameter!");
35
536
  Name = Name.drop_front(Key.size());
36
536
37
536
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
536
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::Function>()
Line
Count
Source
28
716
inline StringRef getTypeName() {
29
716
#if defined(__clang__) || defined(__GNUC__)
30
716
  StringRef Name = __PRETTY_FUNCTION__;
31
716
32
716
  StringRef Key = "DesiredTypeName = ";
33
716
  Name = Name.substr(Name.find(Key));
34
716
  assert(!Name.empty() && "Unable to find the template parameter!");
35
716
  Name = Name.drop_front(Key.size());
36
716
37
716
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
716
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InnerAnalysisManagerProxy<llvm::AnalysisManager<llvm::Function>, llvm::Module> >()
Line
Count
Source
28
158
inline StringRef getTypeName() {
29
158
#if defined(__clang__) || defined(__GNUC__)
30
158
  StringRef Name = __PRETTY_FUNCTION__;
31
158
32
158
  StringRef Key = "DesiredTypeName = ";
33
158
  Name = Name.substr(Name.find(Key));
34
158
  assert(!Name.empty() && "Unable to find the template parameter!");
35
158
  Name = Name.drop_front(Key.size());
36
158
37
158
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
158
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::CallGraphAnalysis>()
Line
Count
Source
28
53
inline StringRef getTypeName() {
29
53
#if defined(__clang__) || defined(__GNUC__)
30
53
  StringRef Name = __PRETTY_FUNCTION__;
31
53
32
53
  StringRef Key = "DesiredTypeName = ";
33
53
  Name = Name.substr(Name.find(Key));
34
53
  assert(!Name.empty() && "Unable to find the template parameter!");
35
53
  Name = Name.drop_front(Key.size());
36
53
37
53
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
53
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LazyCallGraphAnalysis>()
Line
Count
Source
28
76
inline StringRef getTypeName() {
29
76
#if defined(__clang__) || defined(__GNUC__)
30
76
  StringRef Name = __PRETTY_FUNCTION__;
31
76
32
76
  StringRef Key = "DesiredTypeName = ";
33
76
  Name = Name.substr(Name.find(Key));
34
76
  assert(!Name.empty() && "Unable to find the template parameter!");
35
76
  Name = Name.drop_front(Key.size());
36
76
37
76
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
76
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ModuleSummaryIndexAnalysis>()
Line
Count
Source
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ProfileSummaryAnalysis>()
Line
Count
Source
28
38
inline StringRef getTypeName() {
29
38
#if defined(__clang__) || defined(__GNUC__)
30
38
  StringRef Name = __PRETTY_FUNCTION__;
31
38
32
38
  StringRef Key = "DesiredTypeName = ";
33
38
  Name = Name.substr(Name.find(Key));
34
38
  assert(!Name.empty() && "Unable to find the template parameter!");
35
38
  Name = Name.drop_front(Key.size());
36
38
37
38
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
38
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::TargetLibraryAnalysis>()
Line
Count
Source
28
197
inline StringRef getTypeName() {
29
197
#if defined(__clang__) || defined(__GNUC__)
30
197
  StringRef Name = __PRETTY_FUNCTION__;
31
197
32
197
  StringRef Key = "DesiredTypeName = ";
33
197
  Name = Name.substr(Name.find(Key));
34
197
  assert(!Name.empty() && "Unable to find the template parameter!");
35
197
  Name = Name.drop_front(Key.size());
36
197
37
197
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
197
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::VerifierAnalysis>()
Line
Count
Source
28
99
inline StringRef getTypeName() {
29
99
#if defined(__clang__) || defined(__GNUC__)
30
99
  StringRef Name = __PRETTY_FUNCTION__;
31
99
32
99
  StringRef Key = "DesiredTypeName = ";
33
99
  Name = Name.substr(Name.find(Key));
34
99
  assert(!Name.empty() && "Unable to find the template parameter!");
35
99
  Name = Name.drop_front(Key.size());
36
99
37
99
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
99
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::GlobalsAA>()
Line
Count
Source
28
45
inline StringRef getTypeName() {
29
45
#if defined(__clang__) || defined(__GNUC__)
30
45
  StringRef Name = __PRETTY_FUNCTION__;
31
45
32
45
  StringRef Key = "DesiredTypeName = ";
33
45
  Name = Name.substr(Name.find(Key));
34
45
  assert(!Name.empty() && "Unable to find the template parameter!");
35
45
  Name = Name.drop_front(Key.size());
36
45
37
45
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
45
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::FunctionAnalysisManagerCGSCCProxy>()
Line
Count
Source
28
109
inline StringRef getTypeName() {
29
109
#if defined(__clang__) || defined(__GNUC__)
30
109
  StringRef Name = __PRETTY_FUNCTION__;
31
109
32
109
  StringRef Key = "DesiredTypeName = ";
33
109
  Name = Name.substr(Name.find(Key));
34
109
  assert(!Name.empty() && "Unable to find the template parameter!");
35
109
  Name = Name.drop_front(Key.size());
36
109
37
109
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
109
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::AssumptionAnalysis>()
Line
Count
Source
28
128
inline StringRef getTypeName() {
29
128
#if defined(__clang__) || defined(__GNUC__)
30
128
  StringRef Name = __PRETTY_FUNCTION__;
31
128
32
128
  StringRef Key = "DesiredTypeName = ";
33
128
  Name = Name.substr(Name.find(Key));
34
128
  assert(!Name.empty() && "Unable to find the template parameter!");
35
128
  Name = Name.drop_front(Key.size());
36
128
37
128
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
128
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::BlockFrequencyAnalysis>()
Line
Count
Source
28
60
inline StringRef getTypeName() {
29
60
#if defined(__clang__) || defined(__GNUC__)
30
60
  StringRef Name = __PRETTY_FUNCTION__;
31
60
32
60
  StringRef Key = "DesiredTypeName = ";
33
60
  Name = Name.substr(Name.find(Key));
34
60
  assert(!Name.empty() && "Unable to find the template parameter!");
35
60
  Name = Name.drop_front(Key.size());
36
60
37
60
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
60
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::BranchProbabilityAnalysis>()
Line
Count
Source
28
59
inline StringRef getTypeName() {
29
59
#if defined(__clang__) || defined(__GNUC__)
30
59
  StringRef Name = __PRETTY_FUNCTION__;
31
59
32
59
  StringRef Key = "DesiredTypeName = ";
33
59
  Name = Name.substr(Name.find(Key));
34
59
  assert(!Name.empty() && "Unable to find the template parameter!");
35
59
  Name = Name.drop_front(Key.size());
36
59
37
59
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
59
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::DominatorTreeAnalysis>()
Line
Count
Source
28
190
inline StringRef getTypeName() {
29
190
#if defined(__clang__) || defined(__GNUC__)
30
190
  StringRef Name = __PRETTY_FUNCTION__;
31
190
32
190
  StringRef Key = "DesiredTypeName = ";
33
190
  Name = Name.substr(Name.find(Key));
34
190
  assert(!Name.empty() && "Unable to find the template parameter!");
35
190
  Name = Name.drop_front(Key.size());
36
190
37
190
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
190
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::PostDominatorTreeAnalysis>()
Line
Count
Source
28
41
inline StringRef getTypeName() {
29
41
#if defined(__clang__) || defined(__GNUC__)
30
41
  StringRef Name = __PRETTY_FUNCTION__;
31
41
32
41
  StringRef Key = "DesiredTypeName = ";
33
41
  Name = Name.substr(Name.find(Key));
34
41
  assert(!Name.empty() && "Unable to find the template parameter!");
35
41
  Name = Name.drop_front(Key.size());
36
41
37
41
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
41
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::DemandedBitsAnalysis>()
Line
Count
Source
28
54
inline StringRef getTypeName() {
29
54
#if defined(__clang__) || defined(__GNUC__)
30
54
  StringRef Name = __PRETTY_FUNCTION__;
31
54
32
54
  StringRef Key = "DesiredTypeName = ";
33
54
  Name = Name.substr(Name.find(Key));
34
54
  assert(!Name.empty() && "Unable to find the template parameter!");
35
54
  Name = Name.drop_front(Key.size());
36
54
37
54
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
54
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::DominanceFrontierAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::LoopAnalysis>()
Line
Count
Source
28
151
inline StringRef getTypeName() {
29
151
#if defined(__clang__) || defined(__GNUC__)
30
151
  StringRef Name = __PRETTY_FUNCTION__;
31
151
32
151
  StringRef Key = "DesiredTypeName = ";
33
151
  Name = Name.substr(Name.find(Key));
34
151
  assert(!Name.empty() && "Unable to find the template parameter!");
35
151
  Name = Name.drop_front(Key.size());
36
151
37
151
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
151
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LazyValueAnalysis>()
Line
Count
Source
28
61
inline StringRef getTypeName() {
29
61
#if defined(__clang__) || defined(__GNUC__)
30
61
  StringRef Name = __PRETTY_FUNCTION__;
31
61
32
61
  StringRef Key = "DesiredTypeName = ";
33
61
  Name = Name.substr(Name.find(Key));
34
61
  assert(!Name.empty() && "Unable to find the template parameter!");
35
61
  Name = Name.drop_front(Key.size());
36
61
37
61
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
61
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::DependenceAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::MemoryDependenceAnalysis>()
Line
Count
Source
28
64
inline StringRef getTypeName() {
29
64
#if defined(__clang__) || defined(__GNUC__)
30
64
  StringRef Name = __PRETTY_FUNCTION__;
31
64
32
64
  StringRef Key = "DesiredTypeName = ";
33
64
  Name = Name.substr(Name.find(Key));
34
64
  assert(!Name.empty() && "Unable to find the template parameter!");
35
64
  Name = Name.drop_front(Key.size());
36
64
37
64
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
64
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::MemorySSAAnalysis>()
Line
Count
Source
28
42
inline StringRef getTypeName() {
29
42
#if defined(__clang__) || defined(__GNUC__)
30
42
  StringRef Name = __PRETTY_FUNCTION__;
31
42
32
42
  StringRef Key = "DesiredTypeName = ";
33
42
  Name = Name.substr(Name.find(Key));
34
42
  assert(!Name.empty() && "Unable to find the template parameter!");
35
42
  Name = Name.drop_front(Key.size());
36
42
37
42
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
42
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RegionInfoAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::OptimizationRemarkEmitterAnalysis>()
Line
Count
Source
28
78
inline StringRef getTypeName() {
29
78
#if defined(__clang__) || defined(__GNUC__)
30
78
  StringRef Name = __PRETTY_FUNCTION__;
31
78
32
78
  StringRef Key = "DesiredTypeName = ";
33
78
  Name = Name.substr(Name.find(Key));
34
78
  assert(!Name.empty() && "Unable to find the template parameter!");
35
78
  Name = Name.drop_front(Key.size());
36
78
37
78
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
78
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ScalarEvolutionAnalysis>()
Line
Count
Source
28
119
inline StringRef getTypeName() {
29
119
#if defined(__clang__) || defined(__GNUC__)
30
119
  StringRef Name = __PRETTY_FUNCTION__;
31
119
32
119
  StringRef Key = "DesiredTypeName = ";
33
119
  Name = Name.substr(Name.find(Key));
34
119
  assert(!Name.empty() && "Unable to find the template parameter!");
35
119
  Name = Name.drop_front(Key.size());
36
119
37
119
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
119
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::TargetIRAnalysis>()
Line
Count
Source
28
106
inline StringRef getTypeName() {
29
106
#if defined(__clang__) || defined(__GNUC__)
30
106
  StringRef Name = __PRETTY_FUNCTION__;
31
106
32
106
  StringRef Key = "DesiredTypeName = ";
33
106
  Name = Name.substr(Name.find(Key));
34
106
  assert(!Name.empty() && "Unable to find the template parameter!");
35
106
  Name = Name.drop_front(Key.size());
36
106
37
106
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
106
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::BasicAA>()
Line
Count
Source
28
22
inline StringRef getTypeName() {
29
22
#if defined(__clang__) || defined(__GNUC__)
30
22
  StringRef Name = __PRETTY_FUNCTION__;
31
22
32
22
  StringRef Key = "DesiredTypeName = ";
33
22
  Name = Name.substr(Name.find(Key));
34
22
  assert(!Name.empty() && "Unable to find the template parameter!");
35
22
  Name = Name.drop_front(Key.size());
36
22
37
22
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
22
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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
28
3
inline StringRef getTypeName() {
29
3
#if defined(__clang__) || defined(__GNUC__)
30
3
  StringRef Name = __PRETTY_FUNCTION__;
31
3
32
3
  StringRef Key = "DesiredTypeName = ";
33
3
  Name = Name.substr(Name.find(Key));
34
3
  assert(!Name.empty() && "Unable to find the template parameter!");
35
3
  Name = Name.drop_front(Key.size());
36
3
37
3
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
3
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::TypeBasedAA>()
Line
Count
Source
28
3
inline StringRef getTypeName() {
29
3
#if defined(__clang__) || defined(__GNUC__)
30
3
  StringRef Name = __PRETTY_FUNCTION__;
31
3
32
3
  StringRef Key = "DesiredTypeName = ";
33
3
  Name = Name.substr(Name.find(Key));
34
3
  assert(!Name.empty() && "Unable to find the template parameter!");
35
3
  Name = Name.drop_front(Key.size());
36
3
37
3
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
3
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopAccessAnalysis>()
Line
Count
Source
28
24
inline StringRef getTypeName() {
29
24
#if defined(__clang__) || defined(__GNUC__)
30
24
  StringRef Name = __PRETTY_FUNCTION__;
31
24
32
24
  StringRef Key = "DesiredTypeName = ";
33
24
  Name = Name.substr(Name.find(Key));
34
24
  assert(!Name.empty() && "Unable to find the template parameter!");
35
24
  Name = Name.drop_front(Key.size());
36
24
37
24
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
24
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::IVUsersAnalysis>()
llvm::StringRef llvm::getTypeName<llvm::SROA>()
Line
Count
Source
28
89
inline StringRef getTypeName() {
29
89
#if defined(__clang__) || defined(__GNUC__)
30
89
  StringRef Name = __PRETTY_FUNCTION__;
31
89
32
89
  StringRef Key = "DesiredTypeName = ";
33
89
  Name = Name.substr(Name.find(Key));
34
89
  assert(!Name.empty() && "Unable to find the template parameter!");
35
89
  Name = Name.drop_front(Key.size());
36
89
37
89
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
89
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::EarlyCSEPass>()
Line
Count
Source
28
83
inline StringRef getTypeName() {
29
83
#if defined(__clang__) || defined(__GNUC__)
30
83
  StringRef Name = __PRETTY_FUNCTION__;
31
83
32
83
  StringRef Key = "DesiredTypeName = ";
33
83
  Name = Name.substr(Name.find(Key));
34
83
  assert(!Name.empty() && "Unable to find the template parameter!");
35
83
  Name = Name.drop_front(Key.size());
36
83
37
83
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
83
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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
28
312
inline StringRef getTypeName() {
29
312
#if defined(__clang__) || defined(__GNUC__)
30
312
  StringRef Name = __PRETTY_FUNCTION__;
31
312
32
312
  StringRef Key = "DesiredTypeName = ";
33
312
  Name = Name.substr(Name.find(Key));
34
312
  assert(!Name.empty() && "Unable to find the template parameter!");
35
312
  Name = Name.drop_front(Key.size());
36
312
37
312
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
312
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::SpeculativeExecutionPass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::JumpThreadingPass>()
Line
Count
Source
28
92
inline StringRef getTypeName() {
29
92
#if defined(__clang__) || defined(__GNUC__)
30
92
  StringRef Name = __PRETTY_FUNCTION__;
31
92
32
92
  StringRef Key = "DesiredTypeName = ";
33
92
  Name = Name.substr(Name.find(Key));
34
92
  assert(!Name.empty() && "Unable to find the template parameter!");
35
92
  Name = Name.drop_front(Key.size());
36
92
37
92
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
92
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::CorrelatedValuePropagationPass>()
Line
Count
Source
28
88
inline StringRef getTypeName() {
29
88
#if defined(__clang__) || defined(__GNUC__)
30
88
  StringRef Name = __PRETTY_FUNCTION__;
31
88
32
88
  StringRef Key = "DesiredTypeName = ";
33
88
  Name = Name.substr(Name.find(Key));
34
88
  assert(!Name.empty() && "Unable to find the template parameter!");
35
88
  Name = Name.drop_front(Key.size());
36
88
37
88
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
88
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::TailCallElimPass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ReassociatePass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopRotatePass>()
Line
Count
Source
28
24
inline StringRef getTypeName() {
29
24
#if defined(__clang__) || defined(__GNUC__)
30
24
  StringRef Name = __PRETTY_FUNCTION__;
31
24
32
24
  StringRef Key = "DesiredTypeName = ";
33
24
  Name = Name.substr(Name.find(Key));
34
24
  assert(!Name.empty() && "Unable to find the template parameter!");
35
24
  Name = Name.drop_front(Key.size());
36
24
37
24
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
24
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LICMPass>()
Line
Count
Source
28
27
inline StringRef getTypeName() {
29
27
#if defined(__clang__) || defined(__GNUC__)
30
27
  StringRef Name = __PRETTY_FUNCTION__;
31
27
32
27
  StringRef Key = "DesiredTypeName = ";
33
27
  Name = Name.substr(Name.find(Key));
34
27
  assert(!Name.empty() && "Unable to find the template parameter!");
35
27
  Name = Name.drop_front(Key.size());
36
27
37
27
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
27
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::SimpleLoopUnswitchPass>()
Line
Count
Source
28
24
inline StringRef getTypeName() {
29
24
#if defined(__clang__) || defined(__GNUC__)
30
24
  StringRef Name = __PRETTY_FUNCTION__;
31
24
32
24
  StringRef Key = "DesiredTypeName = ";
33
24
  Name = Name.substr(Name.find(Key));
34
24
  assert(!Name.empty() && "Unable to find the template parameter!");
35
24
  Name = Name.drop_front(Key.size());
36
24
37
24
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
24
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::IndVarSimplifyPass>()
Line
Count
Source
28
24
inline StringRef getTypeName() {
29
24
#if defined(__clang__) || defined(__GNUC__)
30
24
  StringRef Name = __PRETTY_FUNCTION__;
31
24
32
24
  StringRef Key = "DesiredTypeName = ";
33
24
  Name = Name.substr(Name.find(Key));
34
24
  assert(!Name.empty() && "Unable to find the template parameter!");
35
24
  Name = Name.drop_front(Key.size());
36
24
37
24
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
24
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopIdiomRecognizePass>()
Line
Count
Source
28
24
inline StringRef getTypeName() {
29
24
#if defined(__clang__) || defined(__GNUC__)
30
24
  StringRef Name = __PRETTY_FUNCTION__;
31
24
32
24
  StringRef Key = "DesiredTypeName = ";
33
24
  Name = Name.substr(Name.find(Key));
34
24
  assert(!Name.empty() && "Unable to find the template parameter!");
35
24
  Name = Name.drop_front(Key.size());
36
24
37
24
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
24
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopDeletionPass>()
Line
Count
Source
28
28
inline StringRef getTypeName() {
29
28
#if defined(__clang__) || defined(__GNUC__)
30
28
  StringRef Name = __PRETTY_FUNCTION__;
31
28
32
28
  StringRef Key = "DesiredTypeName = ";
33
28
  Name = Name.substr(Name.find(Key));
34
28
  assert(!Name.empty() && "Unable to find the template parameter!");
35
28
  Name = Name.drop_front(Key.size());
36
28
37
28
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
28
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopFullUnrollPass>()
Line
Count
Source
28
57
inline StringRef getTypeName() {
29
57
#if defined(__clang__) || defined(__GNUC__)
30
57
  StringRef Name = __PRETTY_FUNCTION__;
31
57
32
57
  StringRef Key = "DesiredTypeName = ";
33
57
  Name = Name.substr(Name.find(Key));
34
57
  assert(!Name.empty() && "Unable to find the template parameter!");
35
57
  Name = Name.drop_front(Key.size());
36
57
37
57
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
57
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::OptimizationRemarkEmitterAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
28
83
inline StringRef getTypeName() {
29
83
#if defined(__clang__) || defined(__GNUC__)
30
83
  StringRef Name = __PRETTY_FUNCTION__;
31
83
32
83
  StringRef Key = "DesiredTypeName = ";
33
83
  Name = Name.substr(Name.find(Key));
34
83
  assert(!Name.empty() && "Unable to find the template parameter!");
35
83
  Name = Name.drop_front(Key.size());
36
83
37
83
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
83
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::FunctionToLoopPassAdaptor<llvm::PassManager<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&> > >()
Line
Count
Source
28
137
inline StringRef getTypeName() {
29
137
#if defined(__clang__) || defined(__GNUC__)
30
137
  StringRef Name = __PRETTY_FUNCTION__;
31
137
32
137
  StringRef Key = "DesiredTypeName = ";
33
137
  Name = Name.substr(Name.find(Key));
34
137
  assert(!Name.empty() && "Unable to find the template parameter!");
35
137
  Name = Name.drop_front(Key.size());
36
137
37
137
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
137
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::MergedLoadStoreMotionPass>()
Line
Count
Source
28
38
inline StringRef getTypeName() {
29
38
#if defined(__clang__) || defined(__GNUC__)
30
38
  StringRef Name = __PRETTY_FUNCTION__;
31
38
32
38
  StringRef Key = "DesiredTypeName = ";
33
38
  Name = Name.substr(Name.find(Key));
34
38
  assert(!Name.empty() && "Unable to find the template parameter!");
35
38
  Name = Name.drop_front(Key.size());
36
38
37
38
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
38
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::NewGVNPass>()
llvm::StringRef llvm::getTypeName<llvm::GVN>()
Line
Count
Source
28
42
inline StringRef getTypeName() {
29
42
#if defined(__clang__) || defined(__GNUC__)
30
42
  StringRef Name = __PRETTY_FUNCTION__;
31
42
32
42
  StringRef Key = "DesiredTypeName = ";
33
42
  Name = Name.substr(Name.find(Key));
34
42
  assert(!Name.empty() && "Unable to find the template parameter!");
35
42
  Name = Name.drop_front(Key.size());
36
42
37
42
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
42
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::MemCpyOptPass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::SCCPPass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::BDCEPass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::DSEPass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::FunctionToLoopPassAdaptor<llvm::LICMPass> >()
Line
Count
Source
28
73
inline StringRef getTypeName() {
29
73
#if defined(__clang__) || defined(__GNUC__)
30
73
  StringRef Name = __PRETTY_FUNCTION__;
31
73
32
73
  StringRef Key = "DesiredTypeName = ";
33
73
  Name = Name.substr(Name.find(Key));
34
73
  assert(!Name.empty() && "Unable to find the template parameter!");
35
73
  Name = Name.drop_front(Key.size());
36
73
37
73
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
73
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ADCEPass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InlinerPass>()
Line
Count
Source
28
55
inline StringRef getTypeName() {
29
55
#if defined(__clang__) || defined(__GNUC__)
30
55
  StringRef Name = __PRETTY_FUNCTION__;
31
55
32
55
  StringRef Key = "DesiredTypeName = ";
33
55
  Name = Name.substr(Name.find(Key));
34
55
  assert(!Name.empty() && "Unable to find the template parameter!");
35
55
  Name = Name.drop_front(Key.size());
36
55
37
55
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
55
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::CGSCCToFunctionPassAdaptor<llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> > > >()
Line
Count
Source
28
107
inline StringRef getTypeName() {
29
107
#if defined(__clang__) || defined(__GNUC__)
30
107
  StringRef Name = __PRETTY_FUNCTION__;
31
107
32
107
  StringRef Key = "DesiredTypeName = ";
33
107
  Name = Name.substr(Name.find(Key));
34
107
  assert(!Name.empty() && "Unable to find the template parameter!");
35
107
  Name = Name.drop_front(Key.size());
36
107
37
107
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
107
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::GlobalDCEPass>()
Line
Count
Source
28
49
inline StringRef getTypeName() {
29
49
#if defined(__clang__) || defined(__GNUC__)
30
49
  StringRef Name = __PRETTY_FUNCTION__;
31
49
32
49
  StringRef Key = "DesiredTypeName = ";
33
49
  Name = Name.substr(Name.find(Key));
34
49
  assert(!Name.empty() && "Unable to find the template parameter!");
35
49
  Name = Name.drop_front(Key.size());
36
49
37
49
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
49
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::PGOInstrumentationGen>()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::FunctionToLoopPassAdaptor<llvm::LoopRotatePass> >()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> > > >()
Line
Count
Source
28
199
inline StringRef getTypeName() {
29
199
#if defined(__clang__) || defined(__GNUC__)
30
199
  StringRef Name = __PRETTY_FUNCTION__;
31
199
32
199
  StringRef Key = "DesiredTypeName = ";
33
199
  Name = Name.substr(Name.find(Key));
34
199
  assert(!Name.empty() && "Unable to find the template parameter!");
35
199
  Name = Name.drop_front(Key.size());
36
199
37
199
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
199
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InstrProfiling>()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::PGOInstrumentationUse>()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InferFunctionAttrsPass>()
Line
Count
Source
28
47
inline StringRef getTypeName() {
29
47
#if defined(__clang__) || defined(__GNUC__)
30
47
  StringRef Name = __PRETTY_FUNCTION__;
31
47
32
47
  StringRef Key = "DesiredTypeName = ";
33
47
  Name = Name.substr(Name.find(Key));
34
47
  assert(!Name.empty() && "Unable to find the template parameter!");
35
47
  Name = Name.drop_front(Key.size());
36
47
37
47
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
47
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LowerExpectIntrinsicPass>()
Line
Count
Source
28
40
inline StringRef getTypeName() {
29
40
#if defined(__clang__) || defined(__GNUC__)
30
40
  StringRef Name = __PRETTY_FUNCTION__;
31
40
32
40
  StringRef Key = "DesiredTypeName = ";
33
40
  Name = Name.substr(Name.find(Key));
34
40
  assert(!Name.empty() && "Unable to find the template parameter!");
35
40
  Name = Name.drop_front(Key.size());
36
40
37
40
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
40
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::SampleProfileLoaderPass>()
Line
Count
Source
28
3
inline StringRef getTypeName() {
29
3
#if defined(__clang__) || defined(__GNUC__)
30
3
  StringRef Name = __PRETTY_FUNCTION__;
31
3
32
3
  StringRef Key = "DesiredTypeName = ";
33
3
  Name = Name.substr(Name.find(Key));
34
3
  assert(!Name.empty() && "Unable to find the template parameter!");
35
3
  Name = Name.drop_front(Key.size());
36
3
37
3
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
3
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::PGOIndirectCallPromotion>()
Line
Count
Source
28
16
inline StringRef getTypeName() {
29
16
#if defined(__clang__) || defined(__GNUC__)
30
16
  StringRef Name = __PRETTY_FUNCTION__;
31
16
32
16
  StringRef Key = "DesiredTypeName = ";
33
16
  Name = Name.substr(Name.find(Key));
34
16
  assert(!Name.empty() && "Unable to find the template parameter!");
35
16
  Name = Name.drop_front(Key.size());
36
16
37
16
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
16
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::IPSCCPPass>()
Line
Count
Source
28
46
inline StringRef getTypeName() {
29
46
#if defined(__clang__) || defined(__GNUC__)
30
46
  StringRef Name = __PRETTY_FUNCTION__;
31
46
32
46
  StringRef Key = "DesiredTypeName = ";
33
46
  Name = Name.substr(Name.find(Key));
34
46
  assert(!Name.empty() && "Unable to find the template parameter!");
35
46
  Name = Name.drop_front(Key.size());
36
46
37
46
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
46
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::GlobalOptPass>()
Line
Count
Source
28
92
inline StringRef getTypeName() {
29
92
#if defined(__clang__) || defined(__GNUC__)
30
92
  StringRef Name = __PRETTY_FUNCTION__;
31
92
32
92
  StringRef Key = "DesiredTypeName = ";
33
92
  Name = Name.substr(Name.find(Key));
34
92
  assert(!Name.empty() && "Unable to find the template parameter!");
35
92
  Name = Name.drop_front(Key.size());
36
92
37
92
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
92
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::PromotePass> >()
Line
Count
Source
28
46
inline StringRef getTypeName() {
29
46
#if defined(__clang__) || defined(__GNUC__)
30
46
  StringRef Name = __PRETTY_FUNCTION__;
31
46
32
46
  StringRef Key = "DesiredTypeName = ";
33
46
  Name = Name.substr(Name.find(Key));
34
46
  assert(!Name.empty() && "Unable to find the template parameter!");
35
46
  Name = Name.drop_front(Key.size());
36
46
37
46
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
46
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::DeadArgumentEliminationPass>()
Line
Count
Source
28
46
inline StringRef getTypeName() {
29
46
#if defined(__clang__) || defined(__GNUC__)
30
46
  StringRef Name = __PRETTY_FUNCTION__;
31
46
32
46
  StringRef Key = "DesiredTypeName = ";
33
46
  Name = Name.substr(Name.find(Key));
34
46
  assert(!Name.empty() && "Unable to find the template parameter!");
35
46
  Name = Name.drop_front(Key.size());
36
46
37
46
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
46
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::GlobalsAA, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
28
71
inline StringRef getTypeName() {
29
71
#if defined(__clang__) || defined(__GNUC__)
30
71
  StringRef Name = __PRETTY_FUNCTION__;
31
71
32
71
  StringRef Key = "DesiredTypeName = ";
33
71
  Name = Name.substr(Name.find(Key));
34
71
  assert(!Name.empty() && "Unable to find the template parameter!");
35
71
  Name = Name.drop_front(Key.size());
36
71
37
71
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
71
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::ProfileSummaryAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
28
40
inline StringRef getTypeName() {
29
40
#if defined(__clang__) || defined(__GNUC__)
30
40
  StringRef Name = __PRETTY_FUNCTION__;
31
40
32
40
  StringRef Key = "DesiredTypeName = ";
33
40
  Name = Name.substr(Name.find(Key));
34
40
  assert(!Name.empty() && "Unable to find the template parameter!");
35
40
  Name = Name.drop_front(Key.size());
36
40
37
40
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
40
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::PostOrderFunctionAttrsPass>()
Line
Count
Source
28
43
inline StringRef getTypeName() {
29
43
#if defined(__clang__) || defined(__GNUC__)
30
43
  StringRef Name = __PRETTY_FUNCTION__;
31
43
32
43
  StringRef Key = "DesiredTypeName = ";
33
43
  Name = Name.substr(Name.find(Key));
34
43
  assert(!Name.empty() && "Unable to find the template parameter!");
35
43
  Name = Name.drop_front(Key.size());
36
43
37
43
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
43
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ArgumentPromotionPass>()
Line
Count
Source
28
11
inline StringRef getTypeName() {
29
11
#if defined(__clang__) || defined(__GNUC__)
30
11
  StringRef Name = __PRETTY_FUNCTION__;
31
11
32
11
  StringRef Key = "DesiredTypeName = ";
33
11
  Name = Name.substr(Name.find(Key));
34
11
  assert(!Name.empty() && "Unable to find the template parameter!");
35
11
  Name = Name.drop_front(Key.size());
36
11
37
11
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
11
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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
28
40
inline StringRef getTypeName() {
29
40
#if defined(__clang__) || defined(__GNUC__)
30
40
  StringRef Name = __PRETTY_FUNCTION__;
31
40
32
40
  StringRef Key = "DesiredTypeName = ";
33
40
  Name = Name.substr(Name.find(Key));
34
40
  assert(!Name.empty() && "Unable to find the template parameter!");
35
40
  Name = Name.drop_front(Key.size());
36
40
37
40
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
40
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PartialInlinerPass>()
llvm::StringRef llvm::getTypeName<llvm::EliminateAvailableExternallyPass>()
Line
Count
Source
28
34
inline StringRef getTypeName() {
29
34
#if defined(__clang__) || defined(__GNUC__)
30
34
  StringRef Name = __PRETTY_FUNCTION__;
31
34
32
34
  StringRef Key = "DesiredTypeName = ";
33
34
  Name = Name.substr(Name.find(Key));
34
34
  assert(!Name.empty() && "Unable to find the template parameter!");
35
34
  Name = Name.drop_front(Key.size());
36
34
37
34
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
34
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ReversePostOrderFunctionAttrsPass>()
Line
Count
Source
28
35
inline StringRef getTypeName() {
29
35
#if defined(__clang__) || defined(__GNUC__)
30
35
  StringRef Name = __PRETTY_FUNCTION__;
31
35
32
35
  StringRef Key = "DesiredTypeName = ";
33
35
  Name = Name.substr(Name.find(Key));
34
35
  assert(!Name.empty() && "Unable to find the template parameter!");
35
35
  Name = Name.drop_front(Key.size());
36
35
37
35
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
35
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::Float2IntPass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopDistributePass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopVectorizePass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopLoadEliminationPass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::SLPVectorizerPass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopUnrollPass>()
Line
Count
Source
28
31
inline StringRef getTypeName() {
29
31
#if defined(__clang__) || defined(__GNUC__)
30
31
  StringRef Name = __PRETTY_FUNCTION__;
31
31
32
31
  StringRef Key = "DesiredTypeName = ";
33
31
  Name = Name.substr(Name.find(Key));
34
31
  assert(!Name.empty() && "Unable to find the template parameter!");
35
31
  Name = Name.drop_front(Key.size());
36
31
37
31
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
31
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::AlignmentFromAssumptionsPass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopSinkPass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InstSimplifierPass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::DivRemPairsPass>()
Line
Count
Source
28
30
inline StringRef getTypeName() {
29
30
#if defined(__clang__) || defined(__GNUC__)
30
30
  StringRef Name = __PRETTY_FUNCTION__;
31
30
32
30
  StringRef Key = "DesiredTypeName = ";
33
30
  Name = Name.substr(Name.find(Key));
34
30
  assert(!Name.empty() && "Unable to find the template parameter!");
35
30
  Name = Name.drop_front(Key.size());
36
30
37
30
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
30
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ConstantMergePass>()
Line
Count
Source
28
34
inline StringRef getTypeName() {
29
34
#if defined(__clang__) || defined(__GNUC__)
30
34
  StringRef Name = __PRETTY_FUNCTION__;
31
34
32
34
  StringRef Key = "DesiredTypeName = ";
33
34
  Name = Name.substr(Name.find(Key));
34
34
  assert(!Name.empty() && "Unable to find the template parameter!");
35
34
  Name = Name.drop_front(Key.size());
36
34
37
34
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
34
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ForceFunctionAttrsPass>()
Line
Count
Source
28
47
inline StringRef getTypeName() {
29
47
#if defined(__clang__) || defined(__GNUC__)
30
47
  StringRef Name = __PRETTY_FUNCTION__;
31
47
32
47
  StringRef Key = "DesiredTypeName = ";
33
47
  Name = Name.substr(Name.find(Key));
34
47
  assert(!Name.empty() && "Unable to find the template parameter!");
35
47
  Name = Name.drop_front(Key.size());
36
47
37
47
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
47
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::AddDiscriminatorsPass> >()
Line
Count
Source
28
4
inline StringRef getTypeName() {
29
4
#if defined(__clang__) || defined(__GNUC__)
30
4
  StringRef Name = __PRETTY_FUNCTION__;
31
4
32
4
  StringRef Key = "DesiredTypeName = ";
33
4
  Name = Name.substr(Name.find(Key));
34
4
  assert(!Name.empty() && "Unable to find the template parameter!");
35
4
  Name = Name.drop_front(Key.size());
36
4
37
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
4
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
28
109
inline StringRef getTypeName() {
29
109
#if defined(__clang__) || defined(__GNUC__)
30
109
  StringRef Name = __PRETTY_FUNCTION__;
31
109
32
109
  StringRef Key = "DesiredTypeName = ";
33
109
  Name = Name.substr(Name.find(Key));
34
109
  assert(!Name.empty() && "Unable to find the template parameter!");
35
109
  Name = Name.drop_front(Key.size());
36
109
37
109
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
109
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToPostOrderCGSCCPassAdaptor<llvm::PostOrderFunctionAttrsPass> >()
Line
Count
Source
28
13
inline StringRef getTypeName() {
29
13
#if defined(__clang__) || defined(__GNUC__)
30
13
  StringRef Name = __PRETTY_FUNCTION__;
31
13
32
13
  StringRef Key = "DesiredTypeName = ";
33
13
  Name = Name.substr(Name.find(Key));
34
13
  assert(!Name.empty() && "Unable to find the template parameter!");
35
13
  Name = Name.drop_front(Key.size());
36
13
37
13
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
13
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::GlobalSplitPass>()
Line
Count
Source
28
7
inline StringRef getTypeName() {
29
7
#if defined(__clang__) || defined(__GNUC__)
30
7
  StringRef Name = __PRETTY_FUNCTION__;
31
7
32
7
  StringRef Key = "DesiredTypeName = ";
33
7
  Name = Name.substr(Name.find(Key));
34
7
  assert(!Name.empty() && "Unable to find the template parameter!");
35
7
  Name = Name.drop_front(Key.size());
36
7
37
7
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
7
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::WholeProgramDevirtPass>()
Line
Count
Source
28
7
inline StringRef getTypeName() {
29
7
#if defined(__clang__) || defined(__GNUC__)
30
7
  StringRef Name = __PRETTY_FUNCTION__;
31
7
32
7
  StringRef Key = "DesiredTypeName = ";
33
7
  Name = Name.substr(Name.find(Key));
34
7
  assert(!Name.empty() && "Unable to find the template parameter!");
35
7
  Name = Name.drop_front(Key.size());
36
7
37
7
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
7
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToPostOrderCGSCCPassAdaptor<llvm::InlinerPass> >()
Line
Count
Source
28
6
inline StringRef getTypeName() {
29
6
#if defined(__clang__) || defined(__GNUC__)
30
6
  StringRef Name = __PRETTY_FUNCTION__;
31
6
32
6
  StringRef Key = "DesiredTypeName = ";
33
6
  Name = Name.substr(Name.find(Key));
34
6
  assert(!Name.empty() && "Unable to find the template parameter!");
35
6
  Name = Name.drop_front(Key.size());
36
6
37
6
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
6
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::CrossDSOCFIPass>()
Line
Count
Source
28
6
inline StringRef getTypeName() {
29
6
#if defined(__clang__) || defined(__GNUC__)
30
6
  StringRef Name = __PRETTY_FUNCTION__;
31
6
32
6
  StringRef Key = "DesiredTypeName = ";
33
6
  Name = Name.substr(Name.find(Key));
34
6
  assert(!Name.empty() && "Unable to find the template parameter!");
35
6
  Name = Name.drop_front(Key.size());
36
6
37
6
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
6
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::ModuleToFunctionPassAdaptor<llvm::SimplifyCFGPass> >()
Line
Count
Source
28
6
inline StringRef getTypeName() {
29
6
#if defined(__clang__) || defined(__GNUC__)
30
6
  StringRef Name = __PRETTY_FUNCTION__;
31
6
32
6
  StringRef Key = "DesiredTypeName = ";
33
6
  Name = Name.substr(Name.find(Key));
34
6
  assert(!Name.empty() && "Unable to find the template parameter!");
35
6
  Name = Name.drop_front(Key.size());
36
6
37
6
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
6
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::RepeatedPass<llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module> > > >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::CallGraphAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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
28
15
inline StringRef getTypeName() {
29
15
#if defined(__clang__) || defined(__GNUC__)
30
15
  StringRef Name = __PRETTY_FUNCTION__;
31
15
32
15
  StringRef Key = "DesiredTypeName = ";
33
15
  Name = Name.substr(Name.find(Key));
34
15
  assert(!Name.empty() && "Unable to find the template parameter!");
35
15
  Name = Name.drop_front(Key.size());
36
15
37
15
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
15
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<(anonymous namespace)::NoOpModuleAnalysis> >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::ProfileSummaryAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::TargetLibraryAnalysis, llvm::Module, llvm::AnalysisManager<llvm::Module> > >()
Line
Count
Source
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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> >()
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::GlobalsAA> >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::AlwaysInlinerPass>()
Line
Count
Source
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::FunctionImportPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::GCOVProfilerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InternalizePass>()
llvm::StringRef llvm::getTypeName<llvm::InvalidateAllAnalysesPass>()
Line
Count
Source
28
4
inline StringRef getTypeName() {
29
4
#if defined(__clang__) || defined(__GNUC__)
30
4
  StringRef Name = __PRETTY_FUNCTION__;
31
4
32
4
  StringRef Key = "DesiredTypeName = ";
33
4
  Name = Name.substr(Name.find(Key));
34
4
  assert(!Name.empty() && "Unable to find the template parameter!");
35
4
  Name = Name.drop_front(Key.size());
36
4
37
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
4
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LowerTypeTestsPass>()
llvm::StringRef llvm::getTypeName<llvm::NameAnonGlobalPass>()
Line
Count
Source
28
12
inline StringRef getTypeName() {
29
12
#if defined(__clang__) || defined(__GNUC__)
30
12
  StringRef Name = __PRETTY_FUNCTION__;
31
12
32
12
  StringRef Key = "DesiredTypeName = ";
33
12
  Name = Name.substr(Name.find(Key));
34
12
  assert(!Name.empty() && "Unable to find the template parameter!");
35
12
  Name = Name.drop_front(Key.size());
36
12
37
12
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
12
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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::RewriteSymbolPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::StripDeadPrototypesPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> >()
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
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::DevirtSCCRepeatedPass<llvm::PassManager<llvm::LazyCallGraph::SCC, llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::LazyCallGraph&, llvm::CGSCCUpdateResult&> > >()
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
28
9
inline StringRef getTypeName() {
29
9
#if defined(__clang__) || defined(__GNUC__)
30
9
  StringRef Name = __PRETTY_FUNCTION__;
31
9
32
9
  StringRef Key = "DesiredTypeName = ";
33
9
  Name = Name.substr(Name.find(Key));
34
9
  assert(!Name.empty() && "Unable to find the template parameter!");
35
9
  Name = Name.drop_front(Key.size());
36
9
37
9
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
9
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<(anonymous namespace)::NoOpCGSCCAnalysis> >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
llvm::StringRef llvm::getTypeName<llvm::RepeatedPass<llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function> > > >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::AAManager, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
28
8
inline StringRef getTypeName() {
29
8
#if defined(__clang__) || defined(__GNUC__)
30
8
  StringRef Name = __PRETTY_FUNCTION__;
31
8
32
8
  StringRef Key = "DesiredTypeName = ";
33
8
  Name = Name.substr(Name.find(Key));
34
8
  assert(!Name.empty() && "Unable to find the template parameter!");
35
8
  Name = Name.drop_front(Key.size());
36
8
37
8
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
8
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::AAManager> >()
Line
Count
Source
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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
28
4
inline StringRef getTypeName() {
29
4
#if defined(__clang__) || defined(__GNUC__)
30
4
  StringRef Name = __PRETTY_FUNCTION__;
31
4
32
4
  StringRef Key = "DesiredTypeName = ";
33
4
  Name = Name.substr(Name.find(Key));
34
4
  assert(!Name.empty() && "Unable to find the template parameter!");
35
4
  Name = Name.drop_front(Key.size());
36
4
37
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
4
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::DominatorTreeAnalysis> >()
Line
Count
Source
28
6
inline StringRef getTypeName() {
29
6
#if defined(__clang__) || defined(__GNUC__)
30
6
  StringRef Name = __PRETTY_FUNCTION__;
31
6
32
6
  StringRef Key = "DesiredTypeName = ";
33
6
  Name = Name.substr(Name.find(Key));
34
6
  assert(!Name.empty() && "Unable to find the template parameter!");
35
6
  Name = Name.drop_front(Key.size());
36
6
37
6
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
6
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::PostDominatorTreeAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
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
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::LoopAnalysis> >()
Line
Count
Source
28
6
inline StringRef getTypeName() {
29
6
#if defined(__clang__) || defined(__GNUC__)
30
6
  StringRef Name = __PRETTY_FUNCTION__;
31
6
32
6
  StringRef Key = "DesiredTypeName = ";
33
6
  Name = Name.substr(Name.find(Key));
34
6
  assert(!Name.empty() && "Unable to find the template parameter!");
35
6
  Name = Name.drop_front(Key.size());
36
6
37
6
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
6
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::LazyValueAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
28
4
inline StringRef getTypeName() {
29
4
#if defined(__clang__) || defined(__GNUC__)
30
4
  StringRef Name = __PRETTY_FUNCTION__;
31
4
32
4
  StringRef Key = "DesiredTypeName = ";
33
4
  Name = Name.substr(Name.find(Key));
34
4
  assert(!Name.empty() && "Unable to find the template parameter!");
35
4
  Name = Name.drop_front(Key.size());
36
4
37
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
4
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::LazyValueAnalysis> >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::DependenceAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
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
28
5
inline StringRef getTypeName() {
29
5
#if defined(__clang__) || defined(__GNUC__)
30
5
  StringRef Name = __PRETTY_FUNCTION__;
31
5
32
5
  StringRef Key = "DesiredTypeName = ";
33
5
  Name = Name.substr(Name.find(Key));
34
5
  assert(!Name.empty() && "Unable to find the template parameter!");
35
5
  Name = Name.drop_front(Key.size());
36
5
37
5
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
5
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::MemoryDependenceAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::MemorySSAAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::MemorySSAAnalysis> >()
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
28
11
inline StringRef getTypeName() {
29
11
#if defined(__clang__) || defined(__GNUC__)
30
11
  StringRef Name = __PRETTY_FUNCTION__;
31
11
32
11
  StringRef Key = "DesiredTypeName = ";
33
11
  Name = Name.substr(Name.find(Key));
34
11
  assert(!Name.empty() && "Unable to find the template parameter!");
35
11
  Name = Name.drop_front(Key.size());
36
11
37
11
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
11
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<(anonymous namespace)::NoOpFunctionAnalysis> >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::OptimizationRemarkEmitterAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::ScalarEvolutionAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::ScalarEvolutionAnalysis> >()
Line
Count
Source
28
8
inline StringRef getTypeName() {
29
8
#if defined(__clang__) || defined(__GNUC__)
30
8
  StringRef Name = __PRETTY_FUNCTION__;
31
8
32
8
  StringRef Key = "DesiredTypeName = ";
33
8
  Name = Name.substr(Name.find(Key));
34
8
  assert(!Name.empty() && "Unable to find the template parameter!");
35
8
  Name = Name.drop_front(Key.size());
36
8
37
8
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
8
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::TargetLibraryAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::TargetIRAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::TargetIRAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::VerifierAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::BasicAA, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::BasicAA> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::CFLAndersAA, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::CFLAndersAA> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::CFLSteensAA, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::CFLSteensAA> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::SCEVAA, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::SCEVAA> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::ScopedNoAliasAA, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::ScopedNoAliasAA> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::TypeBasedAA, llvm::Function, llvm::AnalysisManager<llvm::Function> > >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::TypeBasedAA> >()
llvm::StringRef llvm::getTypeName<llvm::AAEvaluator>()
Line
Count
Source
28
4
inline StringRef getTypeName() {
29
4
#if defined(__clang__) || defined(__GNUC__)
30
4
  StringRef Name = __PRETTY_FUNCTION__;
31
4
32
4
  StringRef Key = "DesiredTypeName = ";
33
4
  Name = Name.substr(Name.find(Key));
34
4
  assert(!Name.empty() && "Unable to find the template parameter!");
35
4
  Name = Name.drop_front(Key.size());
36
4
37
4
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
4
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::AddDiscriminatorsPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::BreakCriticalEdgesPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::ConstantHoistingPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::DCEPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::CFGPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::CFGOnlyPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LowerAtomicPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LowerGuardIntrinsicPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::GuardWideningPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LoopSimplifyPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LowerInvokePass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PromotePass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::NaryReassociatePass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PartiallyInlineLibCallsPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LCSSAPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LoopDataPrefetchPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PGOMemOPSizeOpt>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::AssumptionPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::BlockFrequencyPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::BranchProbabilityPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::DominatorTreePrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PostDominatorTreePrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::DemandedBitsPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::DominanceFrontierPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LoopPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::MemorySSAPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RegionInfoPrinterPass>()
llvm::StringRef llvm::getTypeName<llvm::ScalarEvolutionPrinterPass>()
Line
Count
Source
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::SinkingPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::UnreachableBlockElimPass>()
llvm::StringRef llvm::getTypeName<llvm::DominatorTreeVerifierPass>()
Line
Count
Source
28
16
inline StringRef getTypeName() {
29
16
#if defined(__clang__) || defined(__GNUC__)
30
16
  StringRef Name = __PRETTY_FUNCTION__;
31
16
32
16
  StringRef Key = "DesiredTypeName = ";
33
16
  Name = Name.substr(Name.find(Key));
34
16
  assert(!Name.empty() && "Unable to find the template parameter!");
35
16
  Name = Name.drop_front(Key.size());
36
16
37
16
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
16
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::LoopVerifierPass>()
Line
Count
Source
28
5
inline StringRef getTypeName() {
29
5
#if defined(__clang__) || defined(__GNUC__)
30
5
  StringRef Name = __PRETTY_FUNCTION__;
31
5
32
5
  StringRef Key = "DesiredTypeName = ";
33
5
  Name = Name.substr(Name.find(Key));
34
5
  assert(!Name.empty() && "Unable to find the template parameter!");
35
5
  Name = Name.drop_front(Key.size());
36
5
37
5
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
5
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::MemorySSAVerifierPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RegionInfoVerifierPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::CFGViewerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::CFGOnlyViewerPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PassManager<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&> >()
llvm::StringRef llvm::getTypeName<llvm::RepeatedPass<llvm::PassManager<llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&> > >()
Line
Count
Source
28
1
inline StringRef getTypeName() {
29
1
#if defined(__clang__) || defined(__GNUC__)
30
1
  StringRef Name = __PRETTY_FUNCTION__;
31
1
32
1
  StringRef Key = "DesiredTypeName = ";
33
1
  Name = Name.substr(Name.find(Key));
34
1
  assert(!Name.empty() && "Unable to find the template parameter!");
35
1
  Name = Name.drop_front(Key.size());
36
1
37
1
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
1
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<(anonymous namespace)::NoOpLoopAnalysis, llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&> >()
Unexecuted instantiation: PassBuilder.cpp:llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<(anonymous namespace)::NoOpLoopAnalysis> >()
llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::LoopAccessAnalysis, llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&> >()
Line
Count
Source
28
3
inline StringRef getTypeName() {
29
3
#if defined(__clang__) || defined(__GNUC__)
30
3
  StringRef Name = __PRETTY_FUNCTION__;
31
3
32
3
  StringRef Key = "DesiredTypeName = ";
33
3
  Name = Name.substr(Name.find(Key));
34
3
  assert(!Name.empty() && "Unable to find the template parameter!");
35
3
  Name = Name.drop_front(Key.size());
36
3
37
3
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
3
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::LoopAccessAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::RequireAnalysisPass<llvm::IVUsersAnalysis, llvm::Loop, llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::LoopStandardAnalysisResults&, llvm::LPMUpdater&> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::InvalidateAnalysisPass<llvm::IVUsersAnalysis> >()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LoopInstSimplifyPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::PrintLoopPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LoopSimplifyCFGPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LoopStrengthReducePass>()
llvm::StringRef llvm::getTypeName<llvm::LoopAccessInfoPrinterPass>()
Line
Count
Source
28
2
inline StringRef getTypeName() {
29
2
#if defined(__clang__) || defined(__GNUC__)
30
2
  StringRef Name = __PRETTY_FUNCTION__;
31
2
32
2
  StringRef Key = "DesiredTypeName = ";
33
2
  Name = Name.substr(Name.find(Key));
34
2
  assert(!Name.empty() && "Unable to find the template parameter!");
35
2
  Name = Name.drop_front(Key.size());
36
2
37
2
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
2
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::IVUsersPrinterPass>()
Unexecuted instantiation: llvm::StringRef llvm::getTypeName<llvm::LoopPredicationPass>()
llvm::StringRef llvm::getTypeName<llvm::InnerAnalysisManagerProxy<llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::Module> >()
Line
Count
Source
28
76
inline StringRef getTypeName() {
29
76
#if defined(__clang__) || defined(__GNUC__)
30
76
  StringRef Name = __PRETTY_FUNCTION__;
31
76
32
76
  StringRef Key = "DesiredTypeName = ";
33
76
  Name = Name.substr(Name.find(Key));
34
76
  assert(!Name.empty() && "Unable to find the template parameter!");
35
76
  Name = Name.drop_front(Key.size());
36
76
37
76
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
76
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::OuterAnalysisManagerProxy<llvm::AnalysisManager<llvm::Module>, llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&> >()
Line
Count
Source
28
96
inline StringRef getTypeName() {
29
96
#if defined(__clang__) || defined(__GNUC__)
30
96
  StringRef Name = __PRETTY_FUNCTION__;
31
96
32
96
  StringRef Key = "DesiredTypeName = ";
33
96
  Name = Name.substr(Name.find(Key));
34
96
  assert(!Name.empty() && "Unable to find the template parameter!");
35
96
  Name = Name.drop_front(Key.size());
36
96
37
96
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
96
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::OuterAnalysisManagerProxy<llvm::AnalysisManager<llvm::LazyCallGraph::SCC, llvm::LazyCallGraph&>, llvm::Function> >()
Line
Count
Source
28
12
inline StringRef getTypeName() {
29
12
#if defined(__clang__) || defined(__GNUC__)
30
12
  StringRef Name = __PRETTY_FUNCTION__;
31
12
32
12
  StringRef Key = "DesiredTypeName = ";
33
12
  Name = Name.substr(Name.find(Key));
34
12
  assert(!Name.empty() && "Unable to find the template parameter!");
35
12
  Name = Name.drop_front(Key.size());
36
12
37
12
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
12
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::OuterAnalysisManagerProxy<llvm::AnalysisManager<llvm::Module>, llvm::Function> >()
Line
Count
Source
28
58
inline StringRef getTypeName() {
29
58
#if defined(__clang__) || defined(__GNUC__)
30
58
  StringRef Name = __PRETTY_FUNCTION__;
31
58
32
58
  StringRef Key = "DesiredTypeName = ";
33
58
  Name = Name.substr(Name.find(Key));
34
58
  assert(!Name.empty() && "Unable to find the template parameter!");
35
58
  Name = Name.drop_front(Key.size());
36
58
37
58
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
58
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::InnerAnalysisManagerProxy<llvm::AnalysisManager<llvm::Loop, llvm::LoopStandardAnalysisResults&>, llvm::Function> >()
Line
Count
Source
28
115
inline StringRef getTypeName() {
29
115
#if defined(__clang__) || defined(__GNUC__)
30
115
  StringRef Name = __PRETTY_FUNCTION__;
31
115
32
115
  StringRef Key = "DesiredTypeName = ";
33
115
  Name = Name.substr(Name.find(Key));
34
115
  assert(!Name.empty() && "Unable to find the template parameter!");
35
115
  Name = Name.drop_front(Key.size());
36
115
37
115
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
115
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
llvm::StringRef llvm::getTypeName<llvm::OuterAnalysisManagerProxy<llvm::AnalysisManager<llvm::Function>, llvm::Loop, llvm::LoopStandardAnalysisResults&> >()
Line
Count
Source
28
57
inline StringRef getTypeName() {
29
57
#if defined(__clang__) || defined(__GNUC__)
30
57
  StringRef Name = __PRETTY_FUNCTION__;
31
57
32
57
  StringRef Key = "DesiredTypeName = ";
33
57
  Name = Name.substr(Name.find(Key));
34
57
  assert(!Name.empty() && "Unable to find the template parameter!");
35
57
  Name = Name.drop_front(Key.size());
36
57
37
57
  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
38
57
  return Name.drop_back(1);
39
#elif defined(_MSC_VER)
40
  StringRef Name = __FUNCSIG__;
41
42
  StringRef Key = "getTypeName<";
43
  Name = Name.substr(Name.find(Key));
44
  assert(!Name.empty() && "Unable to find the function name!");
45
  Name = Name.drop_front(Key.size());
46
47
  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
48
    if (Name.startswith(Prefix)) {
49
      Name = Name.drop_front(Prefix.size());
50
      break;
51
    }
52
53
  auto AnglePos = Name.rfind('>');
54
  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
55
  return Name.substr(0, AnglePos);
56
#else
57
  // No known technique for statically extracting a type name on this compiler.
58
  // We return a string that is unlikely to look like any type in LLVM.
59
  return "UNKNOWN_TYPE";
60
#endif
61
}
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&> > >()
62
63
}
64
65
#endif