[libc][NOT FOR COMMIT] building LLVM-libc on 32 bit arm with gcc

[michaelrj]

Summary

This patch is only for demonstration purposes and is not intended to be
landed. It contains the changes needed to allow LLVM-libc to be built
with prebuilt GCC for ARM.

To build LLVM-libc with this configuration, use the following command:

cmake ../llvm -G Ninja -DLLVM_ENABLE_PROJECTS="libc"
-DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=arm-none-eabi-gcc
-DCMAKE_CXX_COMPILER=arm-none-eabi-g++ -DLLVM_LIBC_FULL_BUILD=OFF
-DLLVM_LIBC_ENABLE_LINTING=OFF -DLLVM_LIBC_INCLUDE_SCUDO=OFF
-DCMAKE_C_FLAGS="-specs=nosys.specs"
-DCMAKE_CXX_FLAGS="-specs=nosys.specs -Wno-psabi"
-DLLVM_DEFAULT_TARGET_TRIPLE=arm-unknown-linux-eabi
-DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=arm
-DLLVM_INCLUDE_BENCHMARKS=OFF

[gchatelet]

libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

10

Which gcc version is this?

libc/src/__support/CPP/TypeTraits.h

53

#ifdef __SIZEOF_INT128__
     || IsSameV<__uint128_t, TypeNoCV> || IsSameV<__int128_t, TypeNoCV>
#endif // __uint128_t

libc/src/string/memory_utils/utils.h

21

It's... complicated

https://github.com/abseil/abseil-cpp/blob/master/absl/base/optimization.h#L83-L93

libc/test/src/string/CMakeLists.txt

272

Could you copy/paste the error message?

[michaelrj]

address comments

libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

10

arm-none-eabi-gcc (GNU Arm Embedded Toolchain 10-2020-q4-major) 10.2.1 20201103 (release)

libc/test/src/string/CMakeLists.txt

272

These were commented out from when I had the memory functions removed from the entrypoints list. The error was:

CMake Error at ~/llvm-project/libc/test/src/string/CMakeLists.txt:265 (target_link_libraries):
  Cannot specify link libraries for target
  "libc.test.src.string.libc.src.string.bcmp_opt_host_test" which is not
  built by this project.
Call Stack (most recent call first):
  ~/llvm-project/libc/test/src/string/CMakeLists.txt:272 (add_libc_multi_impl_test)

I've uncommented these lines since the memory functions are building now that there's a definition for CACHELINE_SIZE.

[michaelrj]

add changes that allow building the tests

[peter.smith]

Thanks very much for posting the patch. Just curious to know whether you've tried building with Clang? Is using GCC due to it having a default target of Arm? If I get some time I'll try to see if I can get it work with the https://github.com/ARM-software/LLVM-embedded-toolchain-for-Arm this approximates some of the multilib and specs files with clang config files, although we're hoping to add better support for multilib.

libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

15

For Cortex-m4 strictly speaking you shouldn't need the -mabi=aapcs the GNU embedded toolchain will default to that, the same for -mthumb as Cortex-m4 only supports Thumb.

Although as you say, this is an experimental patch so no harm done at this point.

[peter.smith]

FWIW I was able to get at least the ninja llvmlibc working with the LLVM embedded toolchain with the following hacky bit of cmake

cmake ../../llvm -G Ninja -DLLVM_ENABLE_PROJECTS="libc" \
      -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
      -DCMAKE_BUILD_TYPE=Release \
      -DCMAKE_C_COMPILER=clang \
      -DCMAKE_CXX_COMPILER=clang++ \
      -DLLVM_LIBC_FULL_BUILD=OFF \
      -DCMAKE_C_COMPILER_TARGET=armv7-m-none-eabi \
      -DCMAKE_CXX_COMPILER_TARGET=armv7-m-none-eabi \
      -DCMAKE_C_FLAGS="--config armv7m_soft_nofp_rdimon_baremetal"\
      -DCMAKE_CXX_FLAGS="--config armv7m_soft_nofp_rdimon_baremetal"\
      -DCMAKE_AR=llvm-ar \
      -DLLVM_LIBC_ENABLE_LINTING=OFF -DLLVM_LIBC_INCLUDE_SCUDO=OFF \
      -DLLVM_DEFAULT_TARGET_TRIPLE="armv7-m-none-eabi" \
      -DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=arm \
      -DLLVM_INCLUDE_BENCHMARKS=OFF

[michaelrj]

The reason I started with gcc is that it was suggested to me by an embedded developer as being more complete than the clang toolchain at the moment. That being said, the clang build does appear to work, I tried your cmake command and I can confirm that ninja llvmlibc works, although the tests appear to be having some trouble stemming from their inclusions from libc++. My guess is that I'll need to fiddle with the build options some more to get it to work, but the fact that it builds the core library is very promising. I'll look into it more tomorrow.

libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

15

The reason I picked cortex-m4 as the cpu was because the build wasn't working and I was trying a bunch of different build options to get it to work. For more long term solutions, the target CPU will be configurable.

[michaelrj]

From what I can tell, in their current state our unit tests can't be built with the libc++ you provide. The main code should be fine though, since it doesn't depend on libc++.

The problem is that there are certain parts of libc++ that the tests include and depend on that aren't available. Most noticeably is iostream, which has #include "locale.h", which doesn't work since locales are disabled. The other problem is the memory functions, which have references to posix_memalign, which doesn't appear to be provided by your environment.

If we can solve these problems then being able to build with clang instead of gcc would be very nice, since many of the cmake edits made in this patch are because the LLVM build system doesn't support gcc as well as it does clang.

[gchatelet]

In D124214#3483666, @michaelrj wrote:

The problem is that there are certain parts of libc++ that the tests include and depend on that aren't available. Most noticeably is iostream, which has #include "locale.h", which doesn't work since locales are disabled. The other problem is the memory functions, which have references to posix_memalign, which doesn't appear to be provided by your environment.

I can only see a reference to aligned_alloc in benchmarks/LibcMemoryBenchmark.h:113. Is this the one you're referring to?

[michaelrj]

In D124214#3485184, @gchatelet wrote:

I can only see a reference to aligned_alloc in benchmarks/LibcMemoryBenchmark.h:113. Is this the one you're referring to?

The build error was from libc++. Specifically, libc++ calls posix_memalign when new is called. I noticed this in the functions included with #include <memory> (in utils/testutils/StreamWrapper.cpp, and possibly other test utils), but it probably effects most of libc++. As far as I'm aware your libc memory functions don't call malloc and work fine under the LLVM embedded toolchain, but I understand the confusion. I'll try to be more clear with my phrasing in future.

libc/cmake/modules/LLVMLibCCheckCpuFeatures.cmake

 # ------------------------------------------------------------------------------
 # Cpu features definition and flags
 # ------------------------------------------------------------------------------
 
 # Initialize ALL_CPU_FEATURES as empty list.
 set(ALL_CPU_FEATURES "")
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   set(ALL_CPU_FEATURES SSE2 SSE4_2 AVX2 AVX512F)
-  set(LIBC_COMPILE_OPTIONS_NATIVE -march=native)
+  # set(LIBC_COMPILE_OPTIONS_NATIVE -march=native)
 elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
   set(LIBC_COMPILE_OPTIONS_NATIVE -mcpu=native)
 endif()
 
 # Making sure ALL_CPU_FEATURES is sorted.
 list(SORT ALL_CPU_FEATURES)
 
 # Function to check whether the target CPU supports the provided set of features.
 # Usage:
 # cpu_supports(
 #   <output variable>
 #   <list of cpu features>
 # )

libc/config/linux/arm/entrypoints.txt

+set(TARGET_LIBC_ENTRYPOINTS
+    # ctype.h entrypoints
+    libc.src.ctype.isalnum
+    libc.src.ctype.isalpha
+    libc.src.ctype.isascii
+    libc.src.ctype.isblank
+    libc.src.ctype.iscntrl
+    libc.src.ctype.isdigit
+    libc.src.ctype.isgraph
+    libc.src.ctype.islower
+    libc.src.ctype.isprint
+    libc.src.ctype.ispunct
+    libc.src.ctype.isspace
+    libc.src.ctype.isupper
+    libc.src.ctype.isxdigit
+    libc.src.ctype.toascii
+    libc.src.ctype.tolower
+    libc.src.ctype.toupper
+
+    # string.h entrypoints
+    libc.src.string.bcmp
+    libc.src.string.bzero
+    libc.src.string.memccpy
+    libc.src.string.memchr
+    libc.src.string.memcmp
+    libc.src.string.memcpy
+    libc.src.string.memmove
+    libc.src.string.mempcpy
+    libc.src.string.memrchr
+    libc.src.string.memset
+    libc.src.string.stpcpy
+    libc.src.string.stpncpy
+    libc.src.string.strcat
+    libc.src.string.strchr
+    libc.src.string.strcmp
+    libc.src.string.strcpy
+    libc.src.string.strcspn
+    libc.src.string.strlen
+    libc.src.string.strncat
+    libc.src.string.strncmp
+    libc.src.string.strncpy
+    libc.src.string.strnlen
+    libc.src.string.strpbrk
+    libc.src.string.strrchr
+    libc.src.string.strspn
+    libc.src.string.strstr
+    libc.src.string.strtok
+    libc.src.string.strtok_r
+
+    # inttypes.h entrypoints
+    libc.src.inttypes.imaxdiv
+
+    # stdlib.h entrypoints
+    libc.src.stdlib.abs
+    libc.src.stdlib.bsearch
+    libc.src.stdlib.div
+    libc.src.stdlib.labs
+    libc.src.stdlib.ldiv
+    libc.src.stdlib.llabs
+    libc.src.stdlib.lldiv
+    libc.src.stdlib.qsort
+)
+
+set(TARGET_LIBM_ENTRYPOINTS
+    # math.h entrypoints
+    libc.src.math.cosf
+    libc.src.math.fabs
+    libc.src.math.fabsf
+    libc.src.math.fabsl
+    libc.src.math.fdim
+    libc.src.math.fdimf
+    libc.src.math.fdiml
+    libc.src.math.fmax
+    libc.src.math.fmaxf
+    libc.src.math.fmaxl
+    libc.src.math.fmin
+    libc.src.math.fminf
+    libc.src.math.fminl
+    libc.src.math.sincosf
+    libc.src.math.sinf
+)
+
+set(TARGET_LLVMLIBC_ENTRYPOINTS
+  ${TARGET_LIBC_ENTRYPOINTS}
+  ${TARGET_LIBM_ENTRYPOINTS}
+)

libc/config/linux/arm/headers.txt

+set(TARGET_PUBLIC_HEADERS
+    libc.include.ctype
+    libc.include.errno
+    libc.include.fenv
+    libc.include.inttypes
+    libc.include.math
+    libc.include.stdlib
+    libc.include.string
+)

libc/src/__support/CPP/TypeTraits.h

 template <typename Type> struct IsIntegral {
   using TypeNoCV = RemoveCVType<Type>;
   static constexpr bool Value =
       IsSameV<char, TypeNoCV> || IsSameV<signed char, TypeNoCV> ||
       IsSameV<unsigned char, TypeNoCV> || IsSameV<short, TypeNoCV> ||
       IsSameV<unsigned short, TypeNoCV> || IsSameV<int, TypeNoCV> ||
       IsSameV<unsigned int, TypeNoCV> || IsSameV<long, TypeNoCV> ||
       IsSameV<unsigned long, TypeNoCV> || IsSameV<long long, TypeNoCV> ||
-      IsSameV<unsigned long long, TypeNoCV> || IsSameV<bool, TypeNoCV> ||
-      IsSameV<__uint128_t, TypeNoCV> || IsSameV<__int128_t, TypeNoCV>;
+      IsSameV<unsigned long long, TypeNoCV> || IsSameV<bool, TypeNoCV>
+      // || IsSameV<__uint128_t, TypeNoCV> || IsSameV<__int128_t, TypeNoCV>
+      ;
 };
 
 template <typename T> struct IsPointerTypeNoCV : public FalseValue {};
 template <typename T> struct IsPointerTypeNoCV<T *> : public TrueValue {};
 template <typename T> struct IsPointerType {
   static constexpr bool Value = IsPointerTypeNoCV<RemoveCVType<T>>::Value;
 };
 

libc/src/__support/FPUtil/FloatProperties.h

template <> struct FloatProperties<double> {
   static constexpr uint32_t EXPONENT_BIAS = 1023;
 
   // If a number x is a NAN, then it is a quiet NAN if:
   //   QuietNaNMask & bits(x) != 0
   // Else, it is a signalling NAN.
   static constexpr BitsType QUIET_NAN_MASK = 0x0008000000000000ULL;
 };
 
+// I don't know if this is true on ARM32, but otherwise it tries to use
+// uint128 and that doesn't work.
+#define LONG_DOUBLE_IS_DOUBLE 1
+
 #if defined(LONG_DOUBLE_IS_DOUBLE)
 // Properties for numbers represented in 64 bits long double on Windows
 // platform.
 template <> struct FloatProperties<long double> {
   typedef uint64_t BitsType;
   static_assert(sizeof(BitsType) == sizeof(double),
                 "Unexpected size of 'double' type.");
 

libc/src/string/memory_utils/utils.h

 #include "src/__support/architectures.h"
 
 // Cache line sizes for ARM: These values are not strictly correct since
 // cache line sizes depend on implementations, not architectures.  There
 // are even implementations with cache line sizes configurable at boot
 // time.
 #if defined(LLVM_LIBC_ARCH_AARCH64) || defined(LLVM_LIBC_ARCH_X86)
 #define LLVM_LIBC_CACHELINE_SIZE 64
+#elif defined(LLVM_LIBC_ARCH_ARM)
+#define LLVM_LIBC_CACHELINE_SIZE 32 // This number is just a guess.
 #else
 #error "Unsupported platform for memory functions."
 #endif
 
 #include <stddef.h> // size_t
 #include <stdint.h> // intptr_t / uintptr_t
 
 namespace __llvm_libc {

libc/test/src/string/CMakeLists.txt

if(can_run)
       get_fq_target_name(${fq_config_name}_test fq_target_name)
       target_link_libraries(${fq_target_name} PRIVATE LibcMemoryHelpers)
     else()
       message(STATUS "Skipping test for '${fq_config_name}' insufficient host cpu features '${required_cpu_features}'")
     endif()
   endforeach()
 endfunction()
 
-add_libc_multi_impl_test(bcmp SRCS bcmp_test.cpp)
-add_libc_multi_impl_test(bzero SRCS bzero_test.cpp)
-add_libc_multi_impl_test(memcmp SRCS memcmp_test.cpp)
-add_libc_multi_impl_test(memcpy SRCS memcpy_test.cpp)
-add_libc_multi_impl_test(memmove SRCS memmove_test.cpp)
-add_libc_multi_impl_test(memset SRCS memset_test.cpp)
+# add_libc_multi_impl_test(bcmp SRCS bcmp_test.cpp)
+# add_libc_multi_impl_test(bzero SRCS bzero_test.cpp)
+# add_libc_multi_impl_test(memcmp SRCS memcmp_test.cpp)
+# add_libc_multi_impl_test(memcpy SRCS memcpy_test.cpp)
+# add_libc_multi_impl_test(memmove SRCS memmove_test.cpp)
+# add_libc_multi_impl_test(memset SRCS memset_test.cpp)

llvm/cmake/config-ix.cmake

 #include <type_traits>
 struct T { int val; };
 static_assert(std::is_trivially_copyable<T>::value, \"ok\");
 int main() { return 0;}
 " HAVE_STD_IS_TRIVIALLY_COPYABLE)
 
 
 # Define LLVM_HAS_ATOMICS if gcc or MSVC atomic builtins are supported.
-include(CheckAtomic)
+# include(CheckAtomic)
 
 if( LLVM_ENABLE_PIC )
   set(ENABLE_PIC 1)
 else()
   set(ENABLE_PIC 0)
   check_cxx_compiler_flag("-fno-pie" SUPPORTS_NO_PIE_FLAG)
   if(SUPPORTS_NO_PIE_FLAG)
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-pie")