LLVM  6.0.0svn
TypeIndex.cpp
Go to the documentation of this file.
1 //===-- TypeIndex.cpp - CodeView type index ---------------------*- 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 
11 
14 
15 using namespace llvm;
16 using namespace llvm::codeview;
17 
18 namespace {
19 struct SimpleTypeEntry {
22 };
23 
24 /// The names here all end in "*". If the simple type is a pointer type, we
25 /// return the whole name. Otherwise we lop off the last character in our
26 /// StringRef.
27 static const SimpleTypeEntry SimpleTypeNames[] = {
28  {"void*", SimpleTypeKind::Void},
29  {"<not translated>*", SimpleTypeKind::NotTranslated},
30  {"HRESULT*", SimpleTypeKind::HResult},
31  {"signed char*", SimpleTypeKind::SignedCharacter},
32  {"unsigned char*", SimpleTypeKind::UnsignedCharacter},
34  {"wchar_t*", SimpleTypeKind::WideCharacter},
35  {"char16_t*", SimpleTypeKind::Character16},
36  {"char32_t*", SimpleTypeKind::Character32},
37  {"__int8*", SimpleTypeKind::SByte},
38  {"unsigned __int8*", SimpleTypeKind::Byte},
39  {"short*", SimpleTypeKind::Int16Short},
40  {"unsigned short*", SimpleTypeKind::UInt16Short},
41  {"__int16*", SimpleTypeKind::Int16},
42  {"unsigned __int16*", SimpleTypeKind::UInt16},
43  {"long*", SimpleTypeKind::Int32Long},
44  {"unsigned long*", SimpleTypeKind::UInt32Long},
45  {"int*", SimpleTypeKind::Int32},
46  {"unsigned*", SimpleTypeKind::UInt32},
47  {"__int64*", SimpleTypeKind::Int64Quad},
48  {"unsigned __int64*", SimpleTypeKind::UInt64Quad},
49  {"__int64*", SimpleTypeKind::Int64},
50  {"unsigned __int64*", SimpleTypeKind::UInt64},
51  {"__int128*", SimpleTypeKind::Int128},
52  {"unsigned __int128*", SimpleTypeKind::UInt128},
53  {"__half*", SimpleTypeKind::Float16},
54  {"float*", SimpleTypeKind::Float32},
56  {"__float48*", SimpleTypeKind::Float48},
57  {"double*", SimpleTypeKind::Float64},
58  {"long double*", SimpleTypeKind::Float80},
59  {"__float128*", SimpleTypeKind::Float128},
60  {"_Complex float*", SimpleTypeKind::Complex32},
61  {"_Complex double*", SimpleTypeKind::Complex64},
62  {"_Complex long double*", SimpleTypeKind::Complex80},
63  {"_Complex __float128*", SimpleTypeKind::Complex128},
64  {"bool*", SimpleTypeKind::Boolean8},
65  {"__bool16*", SimpleTypeKind::Boolean16},
66  {"__bool32*", SimpleTypeKind::Boolean32},
67  {"__bool64*", SimpleTypeKind::Boolean64},
68 };
69 } // namespace
70 
72  assert(TI.isNoneType() || TI.isSimple());
73 
74  if (TI.isNoneType())
75  return "<no type>";
76 
77  // This is a simple type.
78  for (const auto &SimpleTypeName : SimpleTypeNames) {
79  if (SimpleTypeName.Kind == TI.getSimpleKind()) {
81  return SimpleTypeName.Name.drop_back(1);
82  // Otherwise, this is a pointer type. We gloss over the distinction
83  // between near, far, 64, 32, etc, and just give a pointer type.
84  return SimpleTypeName.Name;
85  }
86  }
87  return "<unknown simple type>";
88 }
89 
91  TypeIndex TI, TypeCollection &Types) {
93  if (!TI.isNoneType()) {
94  if (TI.isSimple())
95  TypeName = TypeIndex::simpleTypeName(TI);
96  else
97  TypeName = Types.getTypeName(TI);
98  }
99 
100  if (!TypeName.empty())
101  Printer.printHex(FieldName, TypeName, TI.getIndex());
102  else
103  Printer.printHex(FieldName, TI.getIndex());
104 }
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
SimpleTypeKind getSimpleKind() const
Definition: TypeIndex.h:125
print alias Alias Set Printer
SimpleTypeMode getSimpleMode() const
Definition: TypeIndex.h:130
bool isNoneType() const
Definition: TypeIndex.h:114
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
A 32-bit type reference.
Definition: TypeIndex.h:96
void printTypeIndex(ScopedPrinter &Printer, StringRef FieldName, TypeIndex TI, TypeCollection &Types)
Definition: TypeIndex.cpp:90
static StringRef simpleTypeName(TypeIndex TI)
Definition: TypeIndex.cpp:71
constexpr char TypeName[]
Key for Kernel::Arg::Metadata::mTypeName.
void printHex(StringRef Label, T Value)
uint32_t getIndex() const
Definition: TypeIndex.h:110
virtual StringRef getTypeName(TypeIndex Index)=0
const unsigned Kind
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49