[libc][AArch64] Fix fullbuild when using G++/GCC

[DavidSpickett]

Summary

The libc uses some functions that GCC does not currently
implement, that come from Arm's ACLE header usually.

These are:

__arm_wsr64
__arm_rsr64
__arm_wsr
__arm_rsr

This issue was reported to us (https://github.com/llvm/llvm-project/issues/60473)
and I've then reported that back to GCC (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108642).

Even if these functions are added, clang has some non standard extensions
to them that gcc may not take. So we're looking at a fix in gcc 13 at best,
and that may not be enough for what we're doing with them.

So I've added ifdefs to use alternatives with gcc.

For handling the stack pointer, inline assembly is unfortunately the only option.
I have verified that the single mov is essentially what __arm_rsr64 generates.

For fpsr and fpcr the gcc devs suggested using
https://gcc.gnu.org/onlinedocs/gcc-12.2.0/gcc/AArch64-Built-in-Functions.html#AArch64-Built-in-Functions.

[DavidSpickett]

I don't know what your policies on defines by compiler are, but this passes all tests on AArch64 Linux building with gcc 11.

If you don't want them then I'll instead note in the documentation that gcc is not supported for AArch64 for these reasons.

libc/src/__support/threads/linux/thread.cpp

221

This I maybe don't need volatile and might need to describe the side effects? If you're ok with inline asm here in general, I'll check if I need those.

[DavidSpickett]

I'm assuming any non clang is a gcc, going by https://libc.llvm.org/compiler_support.html.

If you know people are using non clang non gcc compilers I should refactor to check for gcc first, and otherwise do something else.

[sivachandra]

In D143261#4102273, @DavidSpickett wrote:

I'm assuming any non clang is a gcc, going by https://libc.llvm.org/compiler_support.html.

If you know people are using non clang non gcc compilers I should refactor to check for gcc first, and otherwise do something else.

I think we can safely assume non-clang implies GCC until we find a user with non-gcc/non-clang compiler trying to build the libc.

libc/src/__support/threads/linux/thread.cpp

221

Yes, this is OK. I am not an inline assembly expert, but I suspect you do need volatile (because the instruction is not touching any variables in C++), and that you don't need to describe side effects as it is clear that x29 is being updated. I will let you tell me what is the most appropriate thing to do here.

[DavidSpickett]

Side note, I suspect that __arm_wsr64("x29", __arm_rsr64("sp")) could end up optimised out in some scenarios because clang doesn't see that it has a side effect, unlike a write to a sysreg. Checking a clang build, it is there so maybe I am wrong but I will do some more investigation.

Shouldn't block this though.

libc/src/__support/threads/linux/thread.cpp

221

Volatile is needed so the compiler doesn't move it about.

x29 (frame pointer) is set here so that in start_thread you can read the arguments. So in fact we don't want to tell the compiler that x29 is updated.

If we did it would save and restore the value around the statement and when we went to start thread, it would be incorrect.

[DavidSpickett]

Checking a clang build, it is there so maybe I am wrong but I will do some more investigation.

I looked into what this compiles down to and it turns out that with frame pointers on AArch64, there's always going to be a mov x29, sp somewhere before calling start_thread. Whether we add one or not. clang could remove the __arm_wsr64 call in some circumstances but in this one it does not. Even if it did remove it here, there would be another mov to achieve the same thing.

https://godbolt.org/z/6vK8GEvfj

1 extra instruction is not an issue, it documents what we're doing nicely and puts the mov nearer to the start_thread call for anyone (like me) who went looking for it.

[DavidSpickett]

ping!

libc/src/__support/FPUtil/aarch64/FEnvImpl.h

struct FEnv {
   LIBC_INLINE static int exceptionStatusToMacro(uint32_t status) {
     return (status & INVALID ? FE_INVALID : 0) |
            (status & DIVBYZERO ? FE_DIVBYZERO : 0) |
            (status & OVERFLOW ? FE_OVERFLOW : 0) |
            (status & UNDERFLOW ? FE_UNDERFLOW : 0) |
            (status & INEXACT ? FE_INEXACT : 0);
   }
 
-  static uint32_t getControlWord() { return __arm_rsr("fpcr"); }
+  static uint32_t getControlWord() {
+#ifdef __clang__
+    // GCC does not currently support __arm_rsr.
+    return __arm_rsr("fpcr");
+#else
+    return __builtin_aarch64_get_fpcr();
+#endif
+  }
 
-  static void writeControlWord(uint32_t fpcr) { __arm_wsr("fpcr", fpcr); }
+  static void writeControlWord(uint32_t fpcr) {
+#ifdef __clang__
+    // GCC does not currently support __arm_wsr.
+    __arm_wsr("fpcr", fpcr);
+#else
+    __builtin_aarch64_set_fpcr(fpcr);
+#endif
+  }
 
-  static uint32_t getStatusWord() { return __arm_rsr("fpsr"); }
+  static uint32_t getStatusWord() {
+#ifdef __clang__
+    return __arm_rsr("fpsr");
+#else
+    return __builtin_aarch64_get_fpsr();
+#endif
+  }
 
-  static void writeStatusWord(uint32_t fpsr) { __arm_wsr("fpsr", fpsr); }
+  static void writeStatusWord(uint32_t fpsr) {
+#ifdef __clang__
+    __arm_wsr("fpsr", fpsr);
+#else
+    __builtin_aarch64_set_fpsr(fpsr);
+#endif
+  }
 };
 
 LIBC_INLINE int enable_except(int excepts) {
   uint32_t newExcepts = FEnv::getStatusValueForExcept(excepts);
   uint32_t controlWord = FEnv::getControlWord();
   int oldExcepts =
       (controlWord >> FEnv::ExceptionControlFlagsBitPosition) & 0x1F;
   controlWord |= (newExcepts << FEnv::ExceptionControlFlagsBitPosition);

libc/src/__support/threads/linux/thread.cpp

 #else
 #error "Unsupported architecture for the clone syscall."
 #endif
 
   if (clone_result == 0) {
 #ifdef LIBC_TARGET_ARCH_IS_AARCH64
     // We set the frame pointer to be the same as the "sp" so that start args
     // can be sniffed out from start_thread.
+#ifdef __clang__
+    // GCC does not currently implement __arm_wsr64/__arm_rsr64.
     __arm_wsr64("x29", __arm_rsr64("sp"));
+#else
+    asm volatile("mov x29, sp");
+#endif
 #endif
     start_thread();
   } else if (clone_result < 0) {
     cleanup_thread_resources(attrib);
     return -clone_result;
   }
 
   return 0;