Merge branch 'main' into cir_upstream_sizeof_alignof

Author: AmrDeveloper

clang/lib/Frontend/CompilerInstance.cpp

@@ -1502,19 +1502,19 @@ static bool compileModuleAndReadASTBehindLock(
 
     // Someone else is responsible for building the module. Wait for them to
     // finish.
-    switch (Lock.waitForUnlock()) {
-    case llvm::LockFileManager::Res_Success:
+    switch (Lock.waitForUnlockFor(std::chrono::seconds(90))) {
+    case llvm::WaitForUnlockResult::Success:
       break; // The interesting case.
-    case llvm::LockFileManager::Res_OwnerDied:
+    case llvm::WaitForUnlockResult::OwnerDied:
       continue; // try again to get the lock.
-    case llvm::LockFileManager::Res_Timeout:
+    case llvm::WaitForUnlockResult::Timeout:
       // Since ModuleCache takes care of correctness, we try waiting for
       // another process to complete the build so clang does not do it done
       // twice. If case of timeout, build it ourselves.
       Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
           << Module->Name;
       // Clear the lock file so that future invocations can make progress.
-      Lock.unsafeRemoveLockFile();
+      Lock.unsafeMaybeUnlock();
       continue;
     }
 

clang/lib/Sema/SemaDeclCXX.cpp

@@ -10938,8 +10938,7 @@ void Sema::CheckConstructor(CXXConstructorDecl *Constructor) {
   //   parameters have default arguments.
   if (!Constructor->isInvalidDecl() &&
       Constructor->hasOneParamOrDefaultArgs() &&
-      !Constructor->isFunctionTemplateSpecialization()
-          ) {
+      !Constructor->isFunctionTemplateSpecialization()) {
     QualType ParamType = Constructor->getParamDecl(0)->getType();
     QualType ClassTy = Context.getTagDeclType(ClassDecl);
     if (Context.getCanonicalType(ParamType).getUnqualifiedType() == ClassTy) {

clang/test/C/C2y/n3482.c

@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -verify -std=c2y -Wall -pedantic -ffreestanding %s
+
+/* WG14 N3482: Yes
+ * Slay Some Earthly Demons XVII
+ *
+ * This paper makes it a constraint violation to call va_start in a non-
+ * variadic function. This is something Clang has always diagnosed.
+ */
+
+#include <stdarg.h>
+
+void func(int a) {
+  va_list list;
+  va_start(list, a); // expected-error {{'va_start' used in function with fixed args}}
+}

clang/test/Driver/print-supported-extensions-riscv.c

@@ -202,6 +202,7 @@
 // CHECK-NEXT:     xqcics               0.2       'Xqcics' (Qualcomm uC Conditional Select Extension)
 // CHECK-NEXT:     xqcicsr              0.2       'Xqcicsr' (Qualcomm uC CSR Extension)
 // CHECK-NEXT:     xqciint              0.4       'Xqciint' (Qualcomm uC Interrupts Extension)
+// CHECK-NEXT:     xqcili               0.2       'Xqcili' (Qualcomm uC Load Large Immediate Extension)
 // CHECK-NEXT:     xqcilia              0.2       'Xqcilia' (Qualcomm uC Large Immediate Arithmetic Extension)
 // CHECK-NEXT:     xqcilo               0.2       'Xqcilo' (Qualcomm uC Large Offset Load Store Extension)
 // CHECK-NEXT:     xqcilsm              0.2       'Xqcilsm' (Qualcomm uC Load Store Multiple Extension)

clang/www/c_status.html

@@ -308,7 +308,7 @@ <h2 id="c2y">C2y implementation status</h2>
     <tr>
       <td>Slay Some Earthly Demons XVII</td>
       <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3482.pdf">N3482</a></td>
-      <td class="unknown" align="center">Unknown</td>
+      <td class="full" align="center">Yes</td>
 	</tr>
     <tr>
       <td>Clarify the specification of the width macros</td>

flang/include/flang/Lower/BoxAnalyzer.h

@@ -403,8 +403,9 @@ class BoxAnalyzer : public fir::details::matcher<BoxAnalyzer> {
                 continue;
               }
             } else if (subs.ubound().isStar()) {
-              assert(Fortran::semantics::IsNamedConstant(sym) &&
-                     "expect implied shape constant");
+              assert(Fortran::semantics::IsNamedConstant(sym) ||
+                     Fortran::semantics::IsCUDAShared(sym) &&
+                         "expect implied shape constant");
               shapes.push_back(fir::SequenceType::getUnknownExtent());
               continue;
             }

flang/include/flang/Semantics/tools.h

@@ -222,6 +222,16 @@ inline bool HasCUDAAttr(const Symbol &sym) {
   return false;
 }
 
+inline bool IsCUDAShared(const Symbol &sym) {
+  if (const auto *details{sym.GetUltimate().detailsIf<ObjectEntityDetails>()}) {
+    if (details->cudaDataAttr() &&
+        *details->cudaDataAttr() == common::CUDADataAttr::Shared) {
+      return true;
+    }
+  }
+  return false;
+}
+
 inline bool NeedCUDAAlloc(const Symbol &sym) {
   if (IsDummy(sym)) {
     return false;

flang/lib/Lower/OpenMP/Clauses.cpp

@@ -165,6 +165,7 @@ std::optional<Object> getBaseObject(const Object &object,
       // e.g. A(i) is represented as {Symbol(A), Designator(ArrayRef(A, i))}.
       // Here we have the Symbol(A), which is what we started with.
       assert(&**symRef == object.sym());
+      [[maybe_unused]] auto *unused = symRef;
       return std::nullopt;
     }
   } else {

flang/test/Lower/CUDA/cuda-shared01.cuf

@@ -0,0 +1,9 @@
+
+! RUN: bbc -emit-hlfir -fcuda %s -o - | FileCheck %s
+
+attributes(global) subroutine sharedstar()
+  real, shared :: s(*) ! ok. dynamic shared memory.
+end subroutine
+
+! CHECK-LABEL: func.func @_QPsharedstar()
+! CHECK: hlfir.declare %{{.*}}(%{{.*}}) {data_attr = #cuf.cuda<shared>, uniq_name = "_QFsharedstarEs"} : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>) -> (!fir.box<!fir.array<?xf32>>, !fir.ref<!fir.array<?xf32>>)

libc/src/stdio/baremetal/printf.cpp

@@ -38,7 +38,8 @@ LLVM_LIBC_FUNCTION(int, printf, (const char *__restrict format, ...)) {
   constexpr size_t BUFF_SIZE = 1024;
   char buffer[BUFF_SIZE];
 
-  printf_core::WriteBuffer wb(buffer, BUFF_SIZE, &raw_write_hook, nullptr);
+  printf_core::WriteBuffer<Mode<WriteMode::FLUSH_TO_STREAM>::value> wb(
+      buffer, BUFF_SIZE, &raw_write_hook, nullptr);
   printf_core::Writer writer(&wb);
 
   int retval = printf_core::printf_main(&writer, format, args);