[compiler-rt][builtins] Add several helper functions for AVR

[benshi001]

Summary

__mulqi3: int8 multiplication
__mulhi3: int16 multiplication
_exit   : golobal terminator

[benshi001]

Build libclang_rt.builtins-avr.a for target AVR, which contains math functions, such as mulsi3, divmodsi4, mulsf3, ...

[aykevl]

What about chip families other than avr2 (the default)? Some have a different PC pointer size (1-3 bytes, therefore affecting the ABI), some have different instructions, etc.

[benshi001]

In D123200#3436043, @aykevl wrote:

What about chip families other than avr2 (the default)? Some have a different PC pointer size (1-3 bytes, therefore affecting the ABI), some have different instructions, etc.

There are two options CMAKE_CXX_FLAGS and CMAKE_C_FLAGS can be specified when doing cmake against compiler-rt, we can specify -mmcu=avrX via them.

Since libgcc-avr has unique source code but built/distributed into several different libgcc.a files with different instruction set, I expect compiler-rt would be done in the way.

And of cource this patch just is an initial support, we still need much more patches to make it fully functional.

[MaskRay]

Initial support for a new target has a high standard. It needs to show decent support, otherwise it may just invite fixups which may in the end waste review resources.
Showing that these files buildable is far from enough. You'd need to show that the run-time tests actually work.

[MaskRay]

clang/lib/Basic/Targets/AVR.cpp

380

The clang preprocessor changes are unrelated to compiler-rt and should be contribute separated with tests.

[benshi001]

clang/lib/Basic/Targets/AVR.cpp

380

I have created another patch as you suggested, thanks.

https://reviews.llvm.org/D123567

[benshi001]

In D123200#3444520, @MaskRay wrote:

Initial support for a new target has a high standard. It needs to show decent support, otherwise it may just invite fixups which may in the end waste review resources.
Showing that these files buildable is far from enough. You'd need to show that the run-time tests actually work.

Could you please tell me more about show that the run-time tests actually work ? AVR is 8-bit MCU with any OS, so I just want some math functions in compiler-rt/lib/builtins, to avoid linking to libgcc.a.

I have checked that there are tests at compiler-rt/test/builtins/Unit/arm, and I guess them to be run on a ARM host. So I have to make a new directory compiler-rt/test/builtins/Unit/avr with some test cases, and promiss that they can run on an AVR board? (https://www.arduino.cc/en/hardware#boards-1)

[benshi001]

I added three functions

__mulqi3: int8 multiplication
__mulhi3: int16 multiplication
_exit   : golobal terminator

All of them are contained in libgcc and are necessary.

Some key points,

1. The functions are written in the minimal avrtiny instruction set, so they should be compatible for all devices.

2. We build them to higher/upper AVR ELF files by specifying CMAKE_CXX_FLAGS and CMAKE_C_FLAGS when doing cmake.

3. I have refered to libgcc, but not simply copy. Actually my implementation is shorter than libgcc's, but may cost more cycles. However this is something about tradeoff.

4. I have tested against avr hardware multiplier, the results are all the same on ArduinoNano (atmega328).

5. My test program locates at https://github.com/benshi001/avr-test/blob/main/mul_int16_int8.ino, I only added 300 pairs of random numbers as test cases, due to the limitation of my device (atmega328 has only 2KB SRAM, more test cases will lead to too large data section). Acutally I have tested 900 pairs.

[MaskRay]

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

171

Keep the list in alphabetical order. Move avr to the beginning. Ignore some entries which are unordered.

216

Keep the list in alphabetical order. Move avr to the beginning. Ignore some entries which are unordered.

compiler-rt/cmake/builtin-config-ix.cmake

55

Keep the list in alphabetical order. Move avr to the beginning. Ignore some entries which are unordered.

compiler-rt/lib/builtins/CMakeLists.txt

671

Keep the *_SOURCES in alphabetical order. Move avr to the beginning. Ignore some entries which are unordered.

[benshi001]

compiler-rt/lib/builtins/CMakeLists.txt

671

I will fix all your concerns about "alphabetical order" when committing.

[aykevl]

@benshi001 I have been looking through the GCC code and I think avr-gcc also has a special calling convention for many other functions, including __mulqi3 and __mulhi3.

Source:

1. I think this is where the ABI is specified in the compiler: https://github.com/gcc-mirror/gcc/blob/releases/gcc-5.4.0/gcc/config/avr/avr.md#L1543-L1549 You can see that it multiplies R24 with R22 and stores the result in R24, and clobbers R22 in the process. But no other registers.
2. In this code sample, avr-gcc doesn't save char c (r20) across the __mulqi3 and __mulhi3 calls, which is normally call-clobbered.

Therefore, I think we need to be a bit more careful with defining these AVR builtins and check the ABI in avr-gcc first.
Also, we can make use of this and optimize the AVR backend more (you can see that the Clang generated code is much worse than avr-gcc in the above examples).

[benshi001]

In D123200#3495356, @aykevl wrote:

@benshi001 I have been looking through the GCC code and I think avr-gcc also has a special calling convention for many other functions, including __mulqi3 and __mulhi3.

Source:

1. I think this is where the ABI is specified in the compiler: https://github.com/gcc-mirror/gcc/blob/releases/gcc-5.4.0/gcc/config/avr/avr.md#L1543-L1549 You can see that it multiplies R24 with R22 and stores the result in R24, and clobbers R22 in the process. But no other registers.
2. In this code sample, avr-gcc doesn't save char c (r20) across the __mulqi3 and __mulhi3 calls, which is normally call-clobbered.

Therefore, I think we need to be a bit more careful with defining these AVR builtins and check the ABI in avr-gcc first.
Also, we can make use of this and optimize the AVR backend more (you can see that the Clang generated code is much worse than avr-gcc in the above examples).

Let us discuss that at https://github.com/llvm/llvm-project/issues/55279

clang/lib/Basic/Targets/AVR.cpp

bool AVRTargetInfo::setCPU(const std::string &Name) {
   // Parameter Name is neither valid family name nor valid device name.
   return false;
 }
 
 void AVRTargetInfo::getTargetDefines(const LangOptions &Opts,
                                      MacroBuilder &Builder) const {
   Builder.defineMacro("AVR");
   Builder.defineMacro("__AVR");
+  Builder.defineMacro("__avr");
   Builder.defineMacro("__AVR__");
+  Builder.defineMacro("__avr__");
   Builder.defineMacro("__ELF__");
 
   if (!this->CPU.empty()) {
     auto It = llvm::find_if(
         AVRMcus, [&](const MCUInfo &Info) { return Info.Name == this->CPU; });
 
     if (It != std::end(AVRMcus)) {
       Builder.defineMacro(It->DefineName);

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

macro(detect_target_arch)
   check_symbol_exists(__powerpc64le__ "" __PPC64LE)
   check_symbol_exists(__riscv "" __RISCV)
   check_symbol_exists(__s390x__ "" __S390X)
   check_symbol_exists(__sparc "" __SPARC)
   check_symbol_exists(__sparcv9 "" __SPARCV9)
   check_symbol_exists(__wasm32__ "" __WEBASSEMBLY32)
   check_symbol_exists(__wasm64__ "" __WEBASSEMBLY64)
   check_symbol_exists(__ve__ "" __VE)
+  check_symbol_exists(__avr__ "" __AVR)
   if(__ARM)
     add_default_target_arch(arm)
   elseif(__AARCH64)
     add_default_target_arch(aarch64)
   elseif(__X86_64)
     if(CMAKE_SIZEOF_VOID_P EQUAL "4")
       add_default_target_arch(x32)
     elseif(CMAKE_SIZEOF_VOID_P EQUAL "8")
macro(detect_target_arch)
   elseif(__SPARC)
     add_default_target_arch(sparc)
   elseif(__WEBASSEMBLY32)
     add_default_target_arch(wasm32)
   elseif(__WEBASSEMBLY64)
     add_default_target_arch(wasm64)
   elseif(__VE)
     add_default_target_arch(ve)
+  elseif(__AVR)
+    add_default_target_arch(avr)
   endif()
 endmacro()
 
 function(get_compiler_rt_root_source_dir ROOT_DIR_VAR)
   # Compute the path to the root of the Compiler-RT source tree
   # regardless of how the project was configured.
   #
   # This function is useful because using `${CMAKE_SOURCE_DIR}`

compiler-rt/cmake/base-config-ix.cmake

elseif(NOT APPLE) # Supported archs for Apple platforms are generated later
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "riscv64")
       test_target_arch(riscv64 "" "")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "wasm32")
       test_target_arch(wasm32 "" "--target=wasm32-unknown-unknown")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "wasm64")
       test_target_arch(wasm64 "" "--target=wasm64-unknown-unknown")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "ve")
       test_target_arch(ve "__ve__" "--target=ve-unknown-none")
+    elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "avr")
+      test_target_arch(avr "__avr__" "--target=avr")
     endif()
     set(COMPILER_RT_OS_SUFFIX "")
   endif()
 endmacro()

compiler-rt/cmake/builtin-config-ix.cmake

 set(PPC64 powerpc64 powerpc64le)
 set(RISCV32 riscv32)
 set(RISCV64 riscv64)
 set(SPARC sparc)
 set(SPARCV9 sparcv9)
 set(WASM32 wasm32)
 set(WASM64 wasm64)
 set(VE ve)
+set(AVR avr)
 
 if(APPLE)
   set(ARM64 arm64 arm64e)
   set(ARM32 armv7 armv7k armv7s)
   set(X86_64 x86_64 x86_64h)
 endif()
 
 set(ALL_BUILTIN_SUPPORTED_ARCH
   ${X86} ${X86_64} ${ARM32} ${ARM64}
   ${HEXAGON} ${MIPS32} ${MIPS64} ${PPC32} ${PPC64}
   ${RISCV32} ${RISCV64} ${SPARC} ${SPARCV9}
-  ${WASM32} ${WASM64} ${VE})
+  ${WASM32} ${WASM64} ${VE} ${AVR})
 
 include(CompilerRTUtils)
 include(CompilerRTDarwinUtils)
 
 if(APPLE)
 
   find_darwin_sdk_dir(DARWIN_osx_SYSROOT macosx)
   find_darwin_sdk_dir(DARWIN_iossim_SYSROOT iphonesimulator)

compiler-rt/cmake/config-ix.cmake

 # platform. We use the results of these tests to build only the various target
 # runtime libraries supported by our current compilers cross-compiling
 # abilities.
 set(SIMPLE_SOURCE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/simple.cc)
 file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\n#include <stdio.h>\nint main() { printf(\"hello, world\"); }\n")
 
 # Detect whether the current target platform is 32-bit or 64-bit, and setup
 # the correct commandline flags needed to attempt to target 32-bit and 64-bit.
+# AVR and MSP430 are omitted since they have 16-bit pointers.
 if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND
-    NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+    NOT CMAKE_SIZEOF_VOID_P EQUAL 8 AND
+    NOT ${arch} MATCHES "avr|msp430")
   message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.")
 endif()
 
 test_targets()
 
 # Returns a list of architecture specific target cflags in @out_var list.
 function(get_target_flags_for_arch arch out_var)
   list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX)

compiler-rt/lib/builtins/CMakeLists.txt

 )
 
 set(ve_SOURCES
   ve/grow_stack.S
   ve/grow_stack_align.S
   ${GENERIC_TF_SOURCES}
   ${GENERIC_SOURCES})
 
+set(avr_SOURCES
+  ${GENERIC_TF_SOURCES}
+  ${GENERIC_SOURCES}
+)
+
 add_custom_target(builtins)
 set_target_properties(builtins PROPERTIES FOLDER "Compiler-RT Misc")
 
 if (APPLE)
   add_subdirectory(Darwin-excludes)
   add_subdirectory(macho_embedded)
   darwin_add_builtin_libraries(${BUILTIN_SUPPORTED_OS})
 else ()