update libcxxabi

13 files changed, 913 insertions, 537 deletions

diff --git a/system/lib/libcxxabi/src/abort_message.cpp b/system/lib/libcxxabi/src/abort_message.cpp
index 7beb86b5..3da4ef67 100644
--- a/system/lib/libcxxabi/src/abort_message.cpp
+++ b/system/lib/libcxxabi/src/abort_message.cpp
@@ -18,16 +18,6 @@
 #   if defined(__has_include) && __has_include(<CrashReporterClient.h>)
 #       define HAVE_CRASHREPORTERCLIENT_H 1
 #       include <CrashReporterClient.h>
-
-        //  If any clients of llvm try to link to libCrashReporterClient.a themselves,
-        //  only one crash info struct will be used.
-        extern "C" {
-        CRASH_REPORTER_CLIENT_HIDDEN 
-        struct crashreporter_annotations_t gCRAnnotations 
-                __attribute__((section("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION))) 
-                = { CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0 };
-        }
-
 #   endif
 #endif
 
diff --git a/system/lib/libcxxabi/src/cxa_demangle.cpp b/system/lib/libcxxabi/src/cxa_demangle.cpp
index 1135c99b..c1e12603 100644
--- a/system/lib/libcxxabi/src/cxa_demangle.cpp
+++ b/system/lib/libcxxabi/src/cxa_demangle.cpp
@@ -17,7 +17,6 @@
 #include <algorithm>
 #include <assert.h>
 
-
 #ifdef DEBUGGING
 
 #include <string>
@@ -42,8 +41,8 @@ public:
     size_t __size_;
     __node* __left_;
     __node* __right_;
-    long double __value_;
     long __cached_size_;
+    long double __value_;
 public:
     __node()
         : __name_(0), __size_(0), __left_(0), __right_(0), __cached_size_(-1)
@@ -64,8 +63,8 @@ public:
     virtual size_t size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = first_size() + second_size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = static_cast<long>(first_size() + second_size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const {return buf;}
     virtual char* second_demangled_name(char* buf) const {return buf;}
@@ -79,7 +78,7 @@ public:
         return get_demangled_name(buf);
     }
 
-    virtual bool ends_with_template(bool parsing = false) const
+    virtual bool ends_with_template(bool /*parsing*/ = false) const
     {
         return false;
     }
@@ -134,9 +133,15 @@ void display(__node* x, int indent = 0)
     {
         for (int i = 0; i < 2*indent; ++i)
             printf(" ");
-        std::string buf(x->size(), '\0');
-        x->get_demangled_name(&buf.front());
-        printf("%s %s, %p\n", typeid(*x).name(), buf.c_str(), x);
+        size_t sz = x->size();
+        char* buf = (char*)calloc(sz+10, 1);
+        x->get_demangled_name(buf);
+        printf("%s [%ld] %s, %p\n", typeid(*x).name(), sz, buf, x);
+        if (strlen(buf) != sz)
+        {
+            printf("strlen(buf) = %ld and size = %ld\n", strlen(buf), sz);
+        }
+        free(buf);
         display(x->__left_, indent+1);
         display(x->__right_, indent+1);
     }
@@ -157,8 +162,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -188,8 +193,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -220,9 +225,9 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __left_->size()
-                                                  + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = n + static_cast<long>(__left_->size()
+                                                  + __right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -260,8 +265,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -291,8 +296,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -322,8 +327,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = n + static_cast<long>(__right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -353,8 +358,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = static_cast<long>(n + __right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -384,8 +389,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = static_cast<long>(n + __right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -415,8 +420,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = static_cast<long>(n + __right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -442,8 +447,8 @@ public:
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = n + __right_->size();
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = static_cast<long>(n + __right_->size());
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -460,7 +465,7 @@ class __source_name
     : public __node
 {
 public:
-    __source_name(const char* __name, unsigned __size)
+    __source_name(const char* __name, size_t __size)
     {
         __name_ = __name;
         __size_ = __size;
@@ -473,9 +478,9 @@ public:
             if (__size_ >= 10 && strncmp(__name_, "_GLOBAL__N", 10) == 0)
                 const_cast<long&>(__cached_size_) = 21;
             else
-                const_cast<long&>(__cached_size_) = __size_;
+                const_cast<long&>(__cached_size_) = static_cast<long>(__size_);
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -553,11 +558,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator&&") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -603,11 +610,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = 3+__left_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator&") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -649,11 +656,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator&") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -700,11 +709,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator&=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -751,11 +762,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -801,11 +814,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__right_)
-                const_cast<long&>(__cached_size_) = __right_->size() + 10;
+                const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 10);
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -846,11 +859,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__right_)
-                const_cast<long&>(__cached_size_) = __right_->size() + 10;
+                const_cast<long&>(__cached_size_) = static_cast<long>(__right_->size() + 10);
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator alignof") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -905,11 +918,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator,") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -955,11 +970,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = 3+__left_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator~") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1015,9 +1030,9 @@ public:
             }
             else
                 off = n +  __right_->size();;
-            const_cast<long&>(__cached_size_) = off;
+            const_cast<long&>(__cached_size_) = static_cast<long>(off);
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1061,13 +1076,14 @@ public:
     {
         __left_ = type;
         __name_ = f;
-        __size_ = l - f;
+        __size_ = static_cast<size_t>(l - f);
     }
     virtual size_t first_size() const
     {
         if (__cached_size_ == -1)
-            const_cast<long&>(__cached_size_) = 2 + __left_->size() + __size_;
-        return __cached_size_;
+            const_cast<long&>(__cached_size_) = static_cast<long>(2 +
+                                                   __left_->size() + __size_);
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1098,11 +1114,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = 3+__left_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator*") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1144,11 +1160,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator/") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1195,11 +1213,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator/=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1246,11 +1266,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator^") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1297,11 +1319,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator^=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1348,11 +1372,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator==") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1399,11 +1425,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator>=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1450,11 +1478,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                        __left_->size() + 9 +
+                                                        __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator>") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1516,11 +1546,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator<=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1567,11 +1599,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator<") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1618,11 +1652,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator<<") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1669,11 +1705,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                        __left_->size() + 9 +
+                                                        __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator<<=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1720,11 +1758,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator-") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1771,11 +1811,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator-=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1822,11 +1864,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator*") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1873,11 +1917,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator*=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1924,11 +1970,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = 4+__left_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(4 + __left_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator--") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -1983,11 +2029,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator!=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2033,11 +2081,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = 3+__left_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator-") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2078,11 +2126,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = 3+__left_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator!") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2124,11 +2172,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator||") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2175,11 +2225,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator|") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2226,11 +2278,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator|=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2277,11 +2331,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 9 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                        __left_->size() + 9 +
+                                                        __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator->*") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2328,11 +2384,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 7 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 7 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator+") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2379,11 +2437,13 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = __left_->size() + 8 + __right_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(
+                                                       __left_->size() + 8 +
+                                                       __right_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator+=") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2430,11 +2490,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = 4+__left_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(4 + __left_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator++") - 1;
         }
-        return __cached_size_;
+        return static_cast<size_t>(__cached_size_);
     }
     virtual char* first_demangled_name(char* buf) const
     {
@@ -2488,11 +2548,11 @@ public:
         if (__cached_size_ == -1)
         {
             if (__left_)
-                const_cast<long&>(__cached_size_) = 3+__left_->size();
+                const_cast<long&>(__cached_size_) = static_cast<long>(3 + __left_->size());
             else
                 const_cast<long&>(__cached_size_) = sizeof("operator+") - 1;