Fix arm build failer with libgcc

[zatrazz]

Summary

Both arm32 armv7/armv8 bots are failing to build due to a linking
issue:

[100%] Built target cxxabi_static
CMakeFiles/cxxabi_shared.dir/cxa_demangle.cpp.o: In function `(anonymous namespace)::itanium_demangle::OutputStream::writeUnsigned(unsigned long long, bool)':
/home/buildslave/buildslave/libcxx-libcxxabi-libunwind-armv7-linux-noexceptions/llvm/projects/libcxxabi/src/demangle/Utility.h:55: undefined reference to `aeabi_uldivmod'
/home/buildslave/buildslave/libcxx-libcxxabi-libunwind-armv7-linux-noexceptions/llvm/projects/libcxxabi/src/demangle/Utility.h:56: undefined reference to `aeabi_uldivmod'
clang-6.0: error: linker command failed with exit code 1 (use -v to see invocation)

It seems after r371273 OutputStream is used more extensively and
is pulling OutputStream::writeUnsigned (which thus requires unsigned
integer module).

The straightfoward fix is to explicit link against libgcc if
compiler-rt is not used.

Fix gdb_pretty_printer_test on python3

First issue is the 'next' iteration method which has changed its
name to '_next_'. The another is the division method, where it
requires to use the floor division so iteration converge.

libcxx/test/pretty_printers/gdb_pretty_printer_test.py

def invoke(self, arg, from_tty):
             value = value_str[value_str.find("= ") + 2:-1]
             gdb.newest_frame().select()
 
             expectation_val = compare_frame.read_var("expectation")
             if "PrettyPrintToRegex" in compare_frame.name():
                 check_literal = expectation_val.string()
                 test_fails = not re.match(check_literal, value)
             else:
-                check_literal_string = expectation_val.string(encoding="utf-8")
-                check_literal = check_literal_string.encode("utf-8")
+                check_literal = expectation_val.string(encoding="utf-8")
                 test_fails = value != check_literal
 
             if test_fails:
                 global test_failures
                 print("FAIL: " + test_loc.symtab.filename +
                       ":" + str(test_loc.line))
                 print("GDB printed:")
                 print("   " + value)

libcxx/utils/gdb/libcxx/printers.py

 These should work for objects compiled when _LIBCPP_ABI_UNSTABLE is defined
 and when it is undefined.
 """
 
 from __future__ import print_function
 
 import re
 import gdb
+import sys
+
+if sys.version_info >= (3, 0):
+    py3k = True
+else:
+    py3k = False
 
 # One under-documented feature of the gdb pretty-printer API
 # is that clients can call any other member of the API
 # before they call to_string.
 # Therefore all self.FIELDs must be set in the pretty-printer's
 # __init__ function.
 
 _void_pointer_type = gdb.lookup_type("void").pointer()
class StdTuplePrinter(object):
     """Print a std::tuple."""
 
     class _Children(object):
         """Class to iterate over the tuple's children."""
 
         def __init__(self, val):
             self.val = val
             self.child_iter = iter(self.val["__base_"].type.fields())
+            if not py3k:
+                self.child_iter.next == self.child_iter.__next__
             self.count = 0
 
         def __iter__(self):
             return self
 
-        def next(self):
+        def __next__(self):
             # child_iter raises StopIteration when appropriate.
-            field_name = self.child_iter.next()
+            field_name = self.child_iter.__next__()
             child = self.val["__base_"][field_name]["__value_"]
             self.count += 1
             return ("[%d]" % self.count, child)
 
+        if not py3k:
+            next = __next__
+
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         typename = _remove_generics(_prettify_typename(self.val.type))
         if not self.val.type.fields():
             return "empty %s" % typename
         return "%s containing" % typename
class _VectorBoolIterator(object):
             self.size = size
             self.bits_per_word = bits_per_word
             self.count = 0
             self.offset = 0
 
         def __iter__(self):
             return self
 
-        def next(self):
+        def __next__(self):
             """Retrieve the next element."""
 
             self.count += 1
             if self.count > self.size:
                 raise StopIteration
             entry = self.item.dereference()
             if entry & (1 << self.offset):
                 outbit = 1
             else:
                 outbit = 0
             self.offset += 1
             if self.offset >= self.bits_per_word:
                 self.item += 1
                 self.offset = 0
             return ("[%d]" % self.count, outbit)
 
+        if not py3k:
+            next = __next__
+
     class _VectorIterator(object):
         """Class to iterate over the non-bool vector's children."""
 
         def __init__(self, begin, end):
             self.item = begin
             self.end = end
             self.count = 0
 
         def __iter__(self):
             return self
 
-        def next(self):
+        def __next__(self):
             self.count += 1
             if self.item == self.end:
                 raise StopIteration
             entry = self.item.dereference()
             self.item += 1
             return ("[%d]" % self.count, entry)
 
+        if not py3k:
+            next = __next__
+
     def __init__(self, val):
         """Set val, length, capacity, and iterator for bool and normal vectors."""
         self.val = val
         self.typename = _remove_generics(_prettify_typename(val.type))
         begin = self.val["__begin_"]
         if self.val.type.template_argument(0).code == gdb.TYPE_CODE_BOOL:
             self.typename += "<bool>"
             self.length = self.val["__size_"]
def to_string(self):
         typename = _prettify_typename(self.val.type)
         return "%s" % typename
 
     def _byte_it(self, value):
         index = -1
         while value:
             index += 1
             will_yield = value % 2
-            value /= 2
+            value //= 2
             if will_yield:
                 yield index
 
     def _list_it(self):
         for word_index in range(self.n_words):
             current = self.values[word_index]
             if current:
                 for n in self._byte_it(current):

libcxxabi/cmake/config-ix.cmake

 include(CMakePushCheckState)
 include(CheckLibraryExists)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 include(CheckCSourceCompiles)
 
 check_library_exists(c fopen "" LIBCXXABI_HAS_C_LIB)
 if (NOT LIBCXXABI_USE_COMPILER_RT)
   check_library_exists(gcc_s __gcc_personality_v0 "" LIBCXXABI_HAS_GCC_S_LIB)
+  check_library_exists(gcc __aeabi_uldivmod "" LIBCXXABI_HAS_GCC_LIB)
 endif ()
 
 # libc++abi is built with -nodefaultlibs, so we want all our checks to also
 # use this option, otherwise we may end up with an inconsistency between
 # the flags we think we require during configuration (if the checks are
 # performed without -nodefaultlibs) and the flags that are actually
 # required during compilation (which has the -nodefaultlibs). libc is
 # required for the link to go through. We remove sanitizers from the
 # configuration checks to avoid spurious link errors.
 check_c_compiler_flag(-nodefaultlibs LIBCXXABI_HAS_NODEFAULTLIBS_FLAG)
 if (LIBCXXABI_HAS_NODEFAULTLIBS_FLAG)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -nodefaultlibs")
   if (LIBCXXABI_HAS_C_LIB)
     list(APPEND CMAKE_REQUIRED_LIBRARIES c)
   endif ()
   if (LIBCXXABI_USE_COMPILER_RT)
     list(APPEND CMAKE_REQUIRED_FLAGS -rtlib=compiler-rt)
     find_compiler_rt_library(builtins LIBCXXABI_BUILTINS_LIBRARY)
     list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBCXXABI_BUILTINS_LIBRARY}")
-  elseif (LIBCXXABI_HAS_GCC_S_LIB)
+  else ()
+    if (LIBCXXABI_HAS_GCC_S_LIB)
       list(APPEND CMAKE_REQUIRED_LIBRARIES gcc_s)
     endif ()
+    if (LIBCXXABI_HAS_GCC_LIB)
+      list(APPEND CMAKE_REQUIRED_LIBRARIES gcc)
+    endif ()
+  endif ()
   if (MINGW)
     # Mingw64 requires quite a few "C" runtime libraries in order for basic
     # programs to link successfully with -nodefaultlibs.
     if (LIBCXXABI_USE_COMPILER_RT)
       set(MINGW_RUNTIME ${LIBCXXABI_BUILTINS_LIBRARY})
     else ()
       set(MINGW_RUNTIME gcc_s gcc)
     endif()

libcxxabi/src/CMakeLists.txt

 else()
   add_library_flags_if(LIBCXXABI_HAS_GCC_S_LIB gcc_s)
 endif()
 if (MINGW)
   # MINGW_LIBRARIES is defined in config-ix.cmake
   list(APPEND LIBCXXABI_LIBRARIES ${MINGW_LIBRARIES})
 endif()
 
+if (NOT LIBCXXABI_USE_COMPILER_RT)
+  add_library_flags_if(LIBCXXABI_HAS_GCC_LIB gcc)
+endif ()
+
 # Setup flags.
 add_link_flags_if_supported(-nodefaultlibs)
 
 set(LIBCXXABI_SHARED_LINK_FLAGS)
 
 if ( APPLE )
   if ( CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "10.6" )
     list(APPEND LIBCXXABI_COMPILE_FLAGS "-U__STRICT_ANSI__")