[Support] Add a fancy helper function to get a static name for a type.

[chandlerc]

Summary

This extracts the type name from PRETTY_FUNCTION for compilers that
support it (I've opted Clang, GCC, and ICC into this as I've tested that
they work) and it uses typeid and typeinfo in a pattern that work with
MSVC even without RTTI. The routine falls back gracefully on a stub
"UNKNOWN_TYPE" string with compilers or formats it doesn't understand.

This should be enough for a lot of common cases in LLVM where the real
goal is just to log or print a type name as a debugging aid, and save
a ton of boilerplate in the process.

The design and implementation is based on a bunch of advice and
discussion with Richard Smith and experimenting with most versions of
Clang, GCC, and MSVC 2015. We've also checked that ICC does something
reasonable and I'll watch the build bots for other compilers. It'd be
great if someone could contribute logic for xlC and/or other toolchains.

Comments or suggestions about how to make this better welcome. Hoping to
land this when the bots aren't too busy (which is not tonight with the
llvm.org hiccups) so tossing it out for review.

[mehdi_amini]

I like how non-intrusive it is on the client! Also how you avoid any macro on the client side! Very clever :)
All the ugliness (because of the lack of compile-time introspection in C++) hidden in a single place is nice.
LGTM.

[majnemer]

How hot is this code?
Your typeid trickery will not melt away at compile time, it will get demangled by the runtime...
IIRC, they have some mechanism to cache the demangled names which means that typeid(T).name() also acquires a lock.

If this is moderately hot, I'd suggest using __FUNCSIG__ for MSVC.
Using __FUNCSIG__ in llvm::getTypeName<int>() would give you:
class llvm::StringRef __cdecl llvm::getTypeName<int>(void)
The type's pretty name can be dug out by looking inside __FUNCSIG__ for llvm::getTypeName< and looking backwards for >.

llvm/trunk/include/llvm/Support/TypeName.h

+//===- TypeName.h -----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_TYPENAME_H
+#define LLVM_SUPPORT_TYPENAME_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+
+/// We provide a function which tries to compute the (demangled) name of a type
+/// statically.
+///
+/// This routine may fail on some platforms or for particularly unusual types.
+/// Do not use it for anything other than logging and debugging aids. It isn't
+/// portable or dependendable in any real sense.
+///
+/// The returned StringRef will point into a static storage duration string.
+/// However, it may not be null terminated and may be some strangely aligned
+/// inner substring of a larger string.
+template <typename DesiredTypeName>
+inline StringRef getTypeName() {
+#if defined(__clang__) || defined(__GNUC__) || defined(__INTEL_COMPILER)
+  StringRef Name = __PRETTY_FUNCTION__;
+
+  StringRef Key = "DesiredTypeName = ";
+  Name = Name.substr(Name.find(Key));
+  assert(!Name.empty() && "Unable to find the template parameter!");
+  Name = Name.drop_front(Key.size());
+
+  assert(Name.endswith("]") && "Name doesn't end in the substitution key!");
+  return Name.drop_back(1);
+#elif defined(_MSC_VER)
+  StringRef Name = __FUNCSIG__;
+
+  StringRef Key = "getTypeName<";
+  Name = Name.substr(Name.find(Key));
+  assert(!Name.empty() && "Unable to find the function name!");
+  Name = Name.drop_front(Key.size());
+
+  for (StringRef Prefix : {"class ", "struct ", "union ", "enum "})
+    if (Name.startswith(Prefix)) {
+      Name = Name.drop_front(Prefix.size());
+      break;
+    }
+
+  auto AnglePos = Name.rfind('>');
+  assert(AnglePos != StringRef::npos && "Unable to find the closing '>'!");
+  return Name.substr(0, AnglePos);
+#else
+  // No known technique for statically extracting a type name on this compiler.
+  // We return a string that is unlikely to look like any type in LLVM.
+  return "UNKNOWN_TYPE";
+#endif
+}
+
+}
+
+#endif

llvm/trunk/unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   SpecialCaseListTest.cpp
   StreamingMemoryObject.cpp
   StringPool.cpp
   SwapByteOrderTest.cpp
   ThreadLocalTest.cpp
   ThreadPool.cpp
   TimerTest.cpp
   TimeValueTest.cpp
+  TypeNameTest.cpp
   TrailingObjectsTest.cpp
   UnicodeTest.cpp
   YAMLIOTest.cpp
   YAMLParserTest.cpp
   formatted_raw_ostream_test.cpp
   raw_ostream_test.cpp
   raw_pwrite_stream_test.cpp
   )
 
 # ManagedStatic.cpp uses <pthread>.
 if(LLVM_ENABLE_THREADS AND HAVE_LIBPTHREAD)
   target_link_libraries(SupportTests pthread)
 endif()

llvm/trunk/unittests/Support/TypeNameTest.cpp

+//===- TypeNameTest.cpp ---------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/TypeName.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+namespace N1 {
+struct S1 {};
+class C1 {};
+union U1 {};
+}
+
+TEST(TypeNameTest, Names) {
+  struct S2 {};
+
+  StringRef S1Name = getTypeName<N1::S1>();
+  StringRef C1Name = getTypeName<N1::C1>();
+  StringRef U1Name = getTypeName<N1::U1>();
+  StringRef S2Name = getTypeName<S2>();
+
+#if defined(__clang__) || defined(__GNUC__) || defined(__INTEL_COMPILER) ||    \
+    defined(_MSC_VER)
+  EXPECT_TRUE(S1Name.endswith("::N1::S1")) << S1Name.str();
+  EXPECT_TRUE(C1Name.endswith("::N1::C1")) << C1Name.str();
+  EXPECT_TRUE(U1Name.endswith("::N1::U1")) << U1Name.str();
+#ifdef __clang__
+  EXPECT_TRUE(S2Name.endswith("S2")) << S2Name.str();
+#else
+  EXPECT_TRUE(S2Name.endswith("::S2")) << S2Name.str();
+#endif
+#else
+  EXPECT_EQ("UNKNOWN_TYPE", S1Name);
+  EXPECT_EQ("UNKNOWN_TYPE", C1Name);
+  EXPECT_EQ("UNKNOWN_TYPE", U1Name);
+  EXPECT_EQ("UNKNOWN_TYPE", S2Name);
+#endif
+}
+
+} // end anonymous namespace