Allow both MSVC and Itanium mangling schemes.

[chaoren]

Summary

LLDB on Windows should now be able to demangle Linux/Android symbols.

Also updated CxaDemangle.cpp to be compatible with MSVC.

Depends on D9949, D9954, D10048.

[zturner]

source/Core/CxaDemangle.inc

1–17 ↗

(On Diff #26538)

Unless we have a specific reason not to (which nobody has spoken up about yet), I would prefer for this to be a standalone .cpp file which compiles to an object file, instead of a .inc file. I can't think of any reason not to do this, but +greg and ed maste in case there is something about their platforms which would necessitate it being an inline file.

source/Core/Mangled.cpp

16–20

Is there a reason why we didn't need these defines before but we need them now?

In any case, llvm has LLVM_NOEXCEPT, LLVM_CONSTEXPR, and LLVM_ALIGNAS, which all just do the right thing depending on the platform. Seems like we should use those instead.

50–57

This function is going to get a "Not all control paths return a value" warning. Can you fix that?

[chaoren]

source/Core/CxaDemangle.inc

1–17 ↗

(On Diff #26538)

I think it's for the same reason that we're putting everything here in an anonymous namespace. To prevent collision with a system defined cxa_demangle. I guess we could also solve that problem by putting everything under lldb_private.

4849 ↗

(On Diff #26538)

Do you know the rebind, construct, and destroy are required for allocators in the STL standard, or it's just a MSVC quirk? If it's the former I think we should try to upstream it to libcxxabi, and avoid changing it here.

source/Core/Mangled.cpp

16–20

What do you mean by "before"? The builtin demangler wasn't enabled for MSVC. I'll try to upstream the LLVM_* change to libcxxabi, so we don't have to change them in our copy.

[zturner]

I mean I see
+#define noexcept
+#define constexpr
+#define snprintf _snprintf
+#define alignas(X) __declspec(align(X))

but I dont' see corresponding -'s from anywhere else in the diff. So it
looks like this is new code, not moved from somewhere else. Unless I'm
just missing something. But now that I think about it, it looks like it's
just because all this was previously compiled out on Windows, and now it's
being compiled on Windows.

Since we've inlined a copy of the code already anyway, personally I don't
see anything wrong with making small changes like this just to get it to
compile on all platforms. I mean I wouldn't think it wise to change some
of the actual logic of the demangling, but just adding decorators on
functions to get it to compile would be ok I would think? Others may
disagree though :)

[chaoren]

Yeah, the the entire thing didn't compile on Windows before. Virgile Bello
tried to add these in r205769 but was reverted by emaste in r205776 since
it broke FreeBSD. I put these here because I think it's nicer to have
minimal changes to the cxa_demangler copy.

[zturner]

Well the thing is that in VS 2015 some of those features will start
working, like constexpr. It would be nice to have those C++ features start
working automatically once the LLVM macros are changed to reflect the new
compiler versions.

[clayborg]

We should make a .cpp + .h file instead of a .inc file.

[chaoren]

Addressed review comments.

[emaste]

In D10040#178973, @zturner wrote:

Well the thing is that in VS 2015 some of those features will start
working, like constexpr. It would be nice to have those C++ features start
working automatically once the LLVM macros are changed to reflect the new
compiler versions.

Sounds good to me. It wasn't just FreeBSD broken originally but probably anyone using clang (or any non-MSVC perhaps).
I think I was just the first to encounter the build failure.

source/Core/Mangled.cpp

64

I'm personally not a fan of the implicit bool cast (here and below); do we already use this approach elsewhere?

[chaoren]

• Address review & remove illegal keyword redefinition.

include/lldb/Core/Mangled.h

public:
     
     enum NamePreference
     {
         ePreferMangled,
         ePreferDemangled,
         ePreferDemangledWithoutArguments
     };
 
+    enum ManglingScheme
+    {
+        eManglingSchemeNone = 0,
+        eManglingSchemeMSVC,
+        eManglingSchemeItanium
+    };
+
     //----------------------------------------------------------------------
     /// Default constructor.
     ///
     /// Initialize with both mangled and demangled names empty.
     //----------------------------------------------------------------------
     Mangled ();
 
     //----------------------------------------------------------------------

source/Core/CxaDemangle.cpp

 //----------------------------------------------------------------------
 // Inlined copy of:
 // http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_demangle.cpp
 // revision 238263.
 //
 // Changes include:
 // - Renamed the "__cxxabiv1" namespace to "lldb_private"
 // - Stripped GCC attributes()
 // - Removed extern "C" from the cxa_demangle function
 // - Added "#undef _LIBCPP_EXTERN_TEMPLATE" to avoid warning
+// - Implemented missing rebind, construct, destroy in malloc_alloc
+// - Replaced noexcept, constexpr, alignas with their LLVM_* equivalents
+// - Included win32.h for snprintf implementation for MSVC
+// - Removed constexpr member initialization for MSVC
+// - Changed argument to alignas() to a literal for MSVC
 //----------------------------------------------------------------------
 
-#undef _LIBCPP_EXTERN_TEMPLATE // Avoid warning below
+#if defined(_MSC_VER)
+#include "lldb/Host/windows/win32.h" // snprintf
+#endif
+#include "llvm/Support/Compiler.h"   // LLVM_{NOEXCEPT, CONSTEXPR, ALIGNAS}
+#undef _LIBCPP_EXTERN_TEMPLATE       // Avoid warning below
 
 //===-------------------------- cxa_demangle.cpp --------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //

 template <class Float>
 struct float_data;
 
 template <>
 struct float_data<float>
 {
     static const size_t mangled_size = 8;
     static const size_t max_demangled_size = 24;
-    static constexpr const char* spec = "%af";
+    static const char* spec;
 };
 
-constexpr const char* float_data<float>::spec;
+const char* float_data<float>::spec = "%af";
 
 template <>
 struct float_data<double>
 {
     static const size_t mangled_size = 16;
     static const size_t max_demangled_size = 32;
-    static constexpr const char* spec = "%a";
+    static const char* spec;
 };
 
-constexpr const char* float_data<double>::spec;
+const char* float_data<double>::spec = "%a";
 
 template <>
 struct float_data<long double>
 {
 #if defined(__arm__)
     static const size_t mangled_size = 16;
 #else
     static const size_t mangled_size = 20;  // May need to be adjusted to 16 or 24 on other platforms
 #endif
     static const size_t max_demangled_size = 40;
-    static constexpr const char* spec = "%LaL";
+    static const char* spec;
 };
 
-constexpr const char* float_data<long double>::spec;
+const char* float_data<long double>::spec = "%LaL";
 
 template <class Float, class C>
 const char*
 parse_floating_number(const char* first, const char* last, C& db)
 {
     const size_t N = float_data<Float>::mangled_size;
     if (static_cast<std::size_t>(last - first) > N)
     {
demangle(const char* first, const char* last, C& db, int& status)
     if (status == success && db.names.empty())
         status = invalid_mangled_name;
 }
 
 template <std::size_t N>
 class arena
 {
     static const std::size_t alignment = 16;
-    alignas(alignment) char buf_[N];
+    LLVM_ALIGNAS(16) char buf_[N];
     char* ptr_;
 
     std::size_t 
-    align_up(std::size_t n) noexcept
+    align_up(std::size_t n) LLVM_NOEXCEPT
         {return (n + (alignment-1)) & ~(alignment-1);}
 
     bool
-    pointer_in_buffer(char* p) noexcept
+    pointer_in_buffer(char* p) LLVM_NOEXCEPT
         {return buf_ <= p && p <= buf_ + N;}
 
 public:
-    arena() noexcept : ptr_(buf_) {}
+    arena() LLVM_NOEXCEPT : ptr_(buf_) {}
     ~arena() {ptr_ = nullptr;}
     arena(const arena&) = delete;
     arena& operator=(const arena&) = delete;
 
     char* allocate(std::size_t n);
-    void deallocate(char* p, std::size_t n) noexcept;
+    void deallocate(char* p, std::size_t n) LLVM_NOEXCEPT;
 
-    static constexpr std::size_t size() {return N;}
+    static LLVM_CONSTEXPR std::size_t size() {return N;}
     std::size_t used() const {return static_cast<std::size_t>(ptr_ - buf_);}
     void reset() {ptr_ = buf_;}
 };
 
 template <std::size_t N>
 char*
 arena<N>::allocate(std::size_t n)
 {
     n = align_up(n);
     if (static_cast<std::size_t>(buf_ + N - ptr_) >= n)
     {
         char* r = ptr_;
         ptr_ += n;
         return r;
     }
     return static_cast<char*>(std::malloc(n));
 }
 
 template <std::size_t N>
 void
-arena<N>::deallocate(char* p, std::size_t n) noexcept
+arena<N>::deallocate(char* p, std::size_t n) LLVM_NOEXCEPT
 {
     if (pointer_in_buffer(p))
     {
         n = align_up(n);
         if (p + n == ptr_)
             ptr_ = p;
     }
     else
         std::free(p);
 }
 
 template <class T, std::size_t N>
 class short_alloc
 {
     arena<N>& a_;
 public:
     typedef T value_type;
 
 public:
     template <class _Up> struct rebind {typedef short_alloc<_Up, N> other;};
 
-    short_alloc(arena<N>& a) noexcept : a_(a) {}
+    short_alloc(arena<N>& a) LLVM_NOEXCEPT : a_(a) {}
     template <class U>
-        short_alloc(const short_alloc<U, N>& a) noexcept
+        short_alloc(const short_alloc<U, N>& a) LLVM_NOEXCEPT
             : a_(a.a_) {}
     short_alloc(const short_alloc&) = default;
     short_alloc& operator=(const short_alloc&) = delete;
 
     T* allocate(std::size_t n)
     {
         return reinterpret_cast<T*>(a_.allocate(n*sizeof(T)));
     }
-    void deallocate(T* p, std::size_t n) noexcept
+    void deallocate(T* p, std::size_t n) LLVM_NOEXCEPT
     {
         a_.deallocate(reinterpret_cast<char*>(p), n*sizeof(T));
     }
 
     template <class T1, std::size_t N1, class U, std::size_t M>
     friend
     bool
-    operator==(const short_alloc<T1, N1>& x, const short_alloc<U, M>& y) noexcept;
+    operator==(const short_alloc<T1, N1>& x, const short_alloc<U, M>& y) LLVM_NOEXCEPT;
 
     template <class U, std::size_t M> friend class short_alloc;
 };
 
 template <class T, std::size_t N, class U, std::size_t M>
 inline
 bool
-operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
+operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) LLVM_NOEXCEPT
 {
     return N == M && &x.a_ == &y.a_;
 }
 
 template <class T, std::size_t N, class U, std::size_t M>
 inline
 bool
-operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
+operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) LLVM_NOEXCEPT
 {
     return !(x == y);
 }
 
 template <class T>
 class malloc_alloc
 {
 public:
     typedef T value_type;
 
     malloc_alloc() = default;
-    template <class U> malloc_alloc(const malloc_alloc<U>&) noexcept {}
+    template <class U> malloc_alloc(const malloc_alloc<U>&) LLVM_NOEXCEPT {}
 
     T* allocate(std::size_t n)
     {
         return static_cast<T*>(std::malloc(n*sizeof(T)));
     }
-    void deallocate(T* p, std::size_t) noexcept
+    void deallocate(T* p, std::size_t) LLVM_NOEXCEPT
     {
         std::free(p);
     }
+    template<class Other>
+    struct rebind
+    {
+        typedef malloc_alloc<Other> other;
+    };
+    void construct(T *p)
+    {
+        ::new (p) T();
+    }
+    void construct(T *p, const T& t)
+    {
+        ::new (p) T(t);
+    }
+    void destroy(T *p)
+    {
+        p->~T();
+    }
 };
 
 template <class T, class U>
 inline
 bool
-operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) noexcept
+operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) LLVM_NOEXCEPT
 {
     return true;
 }
 
 template <class T, class U>
 inline
 bool
-operator!=(const malloc_alloc<T>& x, const malloc_alloc<U>& y) noexcept
+operator!=(const malloc_alloc<T>& x, const malloc_alloc<U>& y) LLVM_NOEXCEPT
 {
     return !(x == y);
 }
 
 const size_t bs = 4 * 1024;
 template <class T> using Alloc = short_alloc<T, bs>;
 template <class T> using Vector = std::vector<T, Alloc<T>>;
 

source/Core/Mangled.cpp

 //===-- Mangled.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 // FreeBSD9-STABLE requires this to know about size_t in cxxabi.h
 #include <cstddef>
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
 #include <Dbghelp.h>
+#define LLDB_USE_BUILTIN_DEMANGLER
 #elif defined (__FreeBSD__)
 #define LLDB_USE_BUILTIN_DEMANGLER
 #else
 #include <cxxabi.h>
 #endif
 
 #ifdef LLDB_USE_BUILTIN_DEMANGLER
 
 // Provide a fast-path demangler implemented in FastDemangle.cpp until it can
 // replace the existing C++ demangler with a complete implementation
 #include "lldb/Core/FastDemangle.h"
 #include "lldb/Core/CxaDemangle.h"

 #include "lldb/Target/CPPLanguageRuntime.h"
 #include <ctype.h>
 #include <string.h>
 #include <stdlib.h>
 
 
 using namespace lldb_private;
 
+static inline Mangled::ManglingScheme
+cstring_mangling_scheme(const char *s)
+{
+    if (s)
+    {
+        if (s[0] == '?')
+            return Mangled::eManglingSchemeMSVC;
+        if (s[0] == '_' && s[1] == 'Z')
+            return Mangled::eManglingSchemeItanium;
+    }
+    return Mangled::eManglingSchemeNone;
+}
+
 static inline bool
-cstring_is_mangled (const char *s)
+cstring_is_mangled(const char *s)
 {
-    if (s)
-#if defined(_MSC_VER)
-        return (s[0] == '?');
-#else
-        return (s[0] == '_' && s[1] == 'Z');
-#endif
-    return false;
+    return cstring_mangling_scheme(s) != Mangled::eManglingSchemeNone;
 }
 
 static const ConstString &
 get_demangled_name_without_arguments (const Mangled *obj)
 {
     // This pair is <mangled name, demangled name without function arguments>
     static std::pair<ConstString, ConstString> g_most_recent_mangled_to_name_sans_args;
 
Mangled::GetDemangledName () const
     if (m_mangled && !m_demangled)
     {
         // We need to generate and cache the demangled name.
         Timer scoped_timer (__PRETTY_FUNCTION__,
                             "Mangled::GetDemangledName (m_mangled = %s)",
                             m_mangled.GetCString());
 
         // Don't bother running anything that isn't mangled
-        const char *mangled_cstr = m_mangled.GetCString();
-        if (cstring_is_mangled(mangled_cstr))
-        {
-            if (!m_mangled.GetMangledCounterpart(m_demangled))
-            {
-                // We didn't already mangle this name, demangle it and if all goes well
-                // add it to our map.
-#ifdef LLDB_USE_BUILTIN_DEMANGLER
-                // Try to use the fast-path demangler first for the
-                // performance win, falling back to the full demangler only
-                // when necessary
-                char *demangled_name = FastDemangle (mangled_cstr,
-                                                     m_mangled.GetLength());
-                if (!demangled_name)
-                    demangled_name = __cxa_demangle (mangled_cstr, NULL, NULL, NULL);
-#elif defined(_MSC_VER)
-                char *demangled_name = (char *)::malloc(1024);
-                ::ZeroMemory(demangled_name, 1024);
-                DWORD result = ::UnDecorateSymbolName(mangled_cstr, demangled_name, 1023,
-                                                      UNDNAME_NO_ACCESS_SPECIFIERS |       // Strip public, private, protected keywords
-                                                          UNDNAME_NO_ALLOCATION_LANGUAGE | // Strip __thiscall, __stdcall, etc keywords
-                                                          UNDNAME_NO_THROW_SIGNATURES |    // Strip throw() specifications
-                                                          UNDNAME_NO_MEMBER_TYPE |         // Strip virtual, static, etc specifiers
-                                                          UNDNAME_NO_MS_KEYWORDS           // Strip all MS extension keywords
-                                                      );
+        const char *mangled_name = m_mangled.GetCString();
+        ManglingScheme mangling_scheme{cstring_mangling_scheme(mangled_name)};
+        if (mangling_scheme != eManglingSchemeNone &&
+            !m_mangled.GetMangledCounterpart(m_demangled))
+            char *demangled_name = nullptr;
+            switch (mangling_scheme)
+            {
+                case eManglingSchemeMSVC:
+                {
+#if defined(_MSC_VER)
+                    const size_t demangled_length = 2048;
+                    demangled_name = static_cast<char *>(::malloc(demangled_length));
+                    ::ZeroMemory(demangled_name, demangled_length);
+                    DWORD result = ::UnDecorateSymbolName(mangled_name, demangled_name, demangled_length,
+                            UNDNAME_NO_ACCESS_SPECIFIERS   | // Strip public, private, protected keywords
+                            UNDNAME_NO_THROW_SIGNATURES    | // Strip throw() specifications
+                            UNDNAME_NO_MEMBER_TYPE         | // Strip virtual, static, etc specifiers
                     if (result == 0)
                     {
-                    free (demangled_name);
+                        free(demangled_name);
                         demangled_name = nullptr;
                     }
+#endif
+                    break;
+                }
+                case eManglingSchemeItanium:
+                {
+#ifdef LLDB_USE_BUILTIN_DEMANGLER
+                    // Try to use the fast-path demangler first for the
+                    // performance win, falling back to the full demangler only
+                    // when necessary
+                    demangled_name = FastDemangle(mangled_name, m_mangled.GetLength());
+                    if (!demangled_name)
+                        demangled_name = __cxa_demangle(mangled_name, NULL, NULL, NULL);
 #else
-                char *demangled_name = abi::__cxa_demangle (mangled_cstr, NULL, NULL, NULL);
+                    demangled_name = abi::__cxa_demangle(mangled_name, NULL, NULL, NULL);
 #endif
-
-                if (demangled_name)
-                {
-                    m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled);
-                    free (demangled_name);
-                }
-            }
-        }
+                    break;
+                }
+                case eManglingSchemeNone:
+                    break;
+            }
+                free(demangled_name);
         if (!m_demangled)
         {
             // Set the demangled string to the empty string to indicate we
             // tried to parse it once and failed.
             m_demangled.SetCString("");
         }
     }