Merged main:64735ad63975 into amd-gfx:0ea05753df73

Local branch amd-gfx 0ea0575 Manual merge main:2cd8207b26ea into amd-gfx:6f68ba52734c
Remote branch main 64735ad [libclc] Move sign to the CLC builtins library (llvm#115699)

Author: SC llvm team

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h

@@ -35,7 +35,7 @@ class CallDescription {
     /// Match calls to functions from the C standard library. This also
     /// recognizes builtin variants whose name is derived by adding
     /// "__builtin", "__inline" or similar prefixes or suffixes; but only
-    /// matches functions than are externally visible and are declared either
+    /// matches functions that are externally visible and are declared either
     /// directly within a TU or in the namespace 'std'.
     /// For the exact heuristics, see CheckerContext::isCLibraryFunction().
     CLibrary,
@@ -152,7 +152,7 @@ class CallDescription {
   /// exists only when that is not available, for example, when _only_
   /// syntactic check is done on a piece of code.
   ///
-  /// Also, StdLibraryFunctionsChecker::Signature is likely a better candicade
+  /// Also, StdLibraryFunctionsChecker::Signature is likely a better candidate
   /// for syntactic only matching if you are writing a new checker. This is
   /// handy if a CallDescriptionMap is already there.
   ///
@@ -233,7 +233,7 @@ template <typename T> class CallDescriptionMap {
   /// exists only when that is not available, for example, when _only_
   /// syntactic check is done on a piece of code.
   ///
-  /// Also, StdLibraryFunctionsChecker::Signature is likely a better candicade
+  /// Also, StdLibraryFunctionsChecker::Signature is likely a better candidate
   /// for syntactic only matching if you are writing a new checker. This is
   /// handy if a CallDescriptionMap is already there.
   ///
@@ -274,7 +274,7 @@ class CallDescriptionSet {
   /// exists only when that is not available, for example, when _only_
   /// syntactic check is done on a piece of code.
   ///
-  /// Also, StdLibraryFunctionsChecker::Signature is likely a better candicade
+  /// Also, StdLibraryFunctionsChecker::Signature is likely a better candidate
   /// for syntactic only matching if you are writing a new checker. This is
   /// handy if a CallDescriptionMap is already there.
   ///

clang/lib/Sema/HeuristicResolver.cpp

@@ -247,7 +247,11 @@ QualType HeuristicResolverImpl::simplifyType(QualType Type, const Expr *E,
     }
     return T;
   };
-  while (!Type.isNull()) {
+  // As an additional protection against infinite loops, bound the number of
+  // simplification steps.
+  size_t StepCount = 0;
+  const size_t MaxSteps = 64;
+  while (!Type.isNull() && StepCount++ < MaxSteps) {
     QualType New = SimplifyOneStep(Type);
     if (New == Type)
       break;

clang/test/AST/ByteCode/builtin-functions.cpp

@@ -1272,6 +1272,22 @@ namespace BuiltinMemcpy {
     return arr[0] * 1000 + arr[1] * 100 + arr[2] * 10 + arr[3];
   }
   static_assert(test_incomplete_array_type() == 1234); // both-error {{constant}} both-note {{in call}}
+
+
+  /// FIXME: memmove needs to support overlapping memory regions.
+  constexpr bool memmoveOverlapping() {
+    char s1[] {1, 2, 3};
+    __builtin_memmove(s1, s1 + 1, 2 * sizeof(char));
+    // Now: 2, 3, 3
+    bool Result1 = (s1[0] == 2 && s1[1] == 3 && s1[2]== 3);
+
+    __builtin_memmove(s1 + 1, s1, 2 * sizeof(char));
+    // Now: 2, 2, 3
+    bool Result2 = (s1[0] == 2 && s1[1] == 2 && s1[2]== 3);
+
+    return Result1 && Result2;
+  }
+  static_assert(memmoveOverlapping()); // expected-error {{failed}}
 }
 
 namespace Memcmp {

compiler-rt/lib/sanitizer_common/tests/sanitizer_libc_test.cpp

@@ -352,6 +352,7 @@ TEST(SanitizerCommon, ReportFile) {
   // This will close tmpfile.
   report_file.SetReportPath("stderr");
   Unlink(tmpfile);
+  Unlink(path);
 }
 
 TEST(SanitizerCommon, FileExists) {

compiler-rt/test/builtins/Unit/arm/aeabi_idivmod_test.c

@@ -14,8 +14,19 @@ int test__aeabi_idivmod(si_int a, si_int b,
 {
 	  si_int rem;
     du_int ret = __aeabi_idivmod(a, b);
+    // __aeabi_idivmod actually returns a struct { quotient; remainder; } using
+    // value_in_regs calling convention. Due to the ABI rules, struct fields
+    // come in the same order regardless of endianness. However since the
+    // result is received here as a 64-bit integer, in which endianness does
+    // matter, the position of each component (quotient and remainder) varies
+    // depending on endianness.
+#  if _YUGA_BIG_ENDIAN
+    rem = ret & 0xFFFFFFFF;
+    si_int result = ret >> 32;
+#  else
     rem = ret >> 32;
     si_int result = ret & 0xFFFFFFFF;
+#  endif
     if (result != expected_result) {
         printf("error in __aeabi_idivmod: %d / %d = %d, expected %d\n",
                a, b, result, expected_result);

compiler-rt/test/builtins/Unit/arm/aeabi_uidivmod_test.c

@@ -13,8 +13,19 @@ int test__aeabi_uidivmod(su_int a, su_int b,
 						su_int expected_result, su_int expected_rem)
 {
     du_int ret = __aeabi_uidivmod(a, b);
+    // __aeabi_uidivmod actually returns a struct { quotient; remainder; }
+    // using value_in_regs calling convention. Due to the ABI rules, struct
+    // fields come in the same order regardless of endianness. However since
+    // the result is received here as a 64-bit integer, in which endianness
+    // does matter, the position of each component (quotient and remainder)
+    // varies depending on endianness.
+#  if _YUGA_BIG_ENDIAN
+    su_int rem = ret & 0xFFFFFFFF;
+    si_int result = ret >> 32;
+#  else
     su_int rem = ret >> 32;
     si_int result = ret & 0xFFFFFFFF;
+#  endif
 
     if (result != expected_result) {
         printf("error in __aeabi_uidivmod: %u / %u = %u, expected %u\n",

compiler-rt/test/builtins/Unit/arm/aeabi_uldivmod_test.c

@@ -12,20 +12,37 @@ COMPILER_RT_ABI void /* __value_in_regs */ __aeabi_uldivmod(du_int a, du_int b);
 int test_aeabi_uldivmod(du_int a, du_int b, du_int expected_q, du_int expected_r)
 {
     du_int q, r;
+    // __aeabi_uldivmod returns a struct { quotient; remainder; } using
+    // value_in_regs calling convention. Each field is a 64-bit integer, so the
+    // quotient resides in r0 and r1, while the remainder in r2 and r3. The
+    // byte order however depends on the endianness.
     __asm__(
+#  if _YUGA_BIG_ENDIAN
+        "movs r1, %Q[a] \n"
+        "movs r0, %R[a] \n"
+        "movs r3, %Q[b] \n"
+        "movs r2, %R[b] \n"
+#  else
         "movs r0, %Q[a] \n"
         "movs r1, %R[a] \n"
         "movs r2, %Q[b] \n"
         "movs r3, %R[b] \n"
+#  endif
         "bl __aeabi_uldivmod \n"
+#  if _YUGA_BIG_ENDIAN
+        "movs %Q[q], r1\n"
+        "movs %R[q], r0\n"
+        "movs %Q[r], r3\n"
+        "movs %R[r], r2\n"
+#  else
         "movs %Q[q], r0\n"
         "movs %R[q], r1\n"
         "movs %Q[r], r2\n"
         "movs %R[r], r3\n"
-        : [q] "=r" (q), [r] "=r"(r)
+#  endif
+        : [q] "=r"(q), [r] "=r"(r)
         : [a] "r"(a), [b] "r"(b)
-        : "lr", "r0", "r1", "r2", "r3"
-        );
+        : "lr", "r0", "r1", "r2", "r3");
     if (q != expected_q || r != expected_r)
         printf("error in aeabi_uldivmod: %llX / %llX = %llX, R = %llX, expected %llX, %llX\n",
                a, b, q, r, expected_q, expected_r);