Merge upstream LLVM into amd-gfx12

Author: SC llvm team

.github/workflows/containers/github-action-ci-windows/Dockerfile

@@ -39,11 +39,16 @@ RUN regsvr32 /S "C:\BuildTools\DIA SDK\bin\amd64\msdia140.dll" & \
 
 # install tools as described in https://llvm.org/docs/GettingStartedVS.html
 # and a few more that were not documented...
-RUN choco install -y ninja git sccache
 # Pin an older version of Python; the current Python 3.10 fails when
 # doing "pip install" for the other dependencies, as it fails to find libxml
 # while compiling some package.
-RUN choco install -y python3 --version 3.9.7
+# We version pin the other packages as well to ensure the container build is as
+# reproducible as possible to prevent issues when upgrading only part of the
+# container.
+RUN choco install -y ninja --version 1.13.1 && \
+    choco install -y git --version 2.50.1 && \
+    choco install -y sccache --version 0.10.0 && \
+    choco install -y python3 --version 3.9.7
 
 # Testing requires psutil
 RUN pip install psutil

clang-tools-extra/clang-tidy/misc/ConfusableTable/confusables.txt

@@ -2642,6 +2642,36 @@ def ComplexRealPtrOp : CIR_Op<"complex.real_ptr", [Pure]> {
   let hasVerifier = 1;
 }
 
+//===----------------------------------------------------------------------===//
+// ComplexImagPtrOp
+//===----------------------------------------------------------------------===//
+
+def ComplexImagPtrOp : CIR_Op<"complex.imag_ptr", [Pure]> {
+  let summary = "Derive a pointer to the imaginary part of a complex value";
+  let description = [{
+    `cir.complex.imag_ptr` operation takes a pointer operand that points to a
+    complex value of type `!cir.complex` and yields a pointer to the imaginary
+    part of the operand.
+
+    Example:
+
+    ```mlir
+    %1 = cir.complex.imag_ptr %0 : !cir.ptr<!cir.complex<!cir.double>>
+      -> !cir.ptr<!cir.double>
+    ```
+  }];
+
+  let arguments = (ins CIR_PtrToComplexType:$operand);
+  let results = (outs CIR_PtrToIntOrFloatType:$result);
+
+  let assemblyFormat = [{
+    $operand `:`
+    qualified(type($operand)) `->` qualified(type($result)) attr-dict
+  }];
+
+  let hasVerifier = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // ComplexAddOp
 //===----------------------------------------------------------------------===//

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -250,6 +250,10 @@ struct MissingFeatures {
   static bool typeChecks() { return false; }
   static bool weakRefReference() { return false; }
   static bool writebacks() { return false; }
+  static bool appleKext() { return false; }
+  static bool dtorCleanups() { return false; }
+  static bool completeDtors() { return false; }
+  static bool vtableInitialization() { return false; }
 
   // Missing types
   static bool dataMemberType() { return false; }

clang/include/clang/CIR/MissingFeatures.h

@@ -582,7 +582,7 @@ class TemplateDiff {
   /// IsBold - Keeps track of the bold formatting for the output string.
   bool IsBold;
 
-  /// DiffTree - A tree representation the differences between two types.
+  /// DiffTree - A tree representation of the differences between two types.
   class DiffTree {
   public:
     /// DiffKind - The difference in a DiffNode.  Fields of
@@ -802,7 +802,7 @@ class TemplateDiff {
       CurrentNode = FlatTree[CurrentNode].ParentNode;
     }
 
-    /// AddNode - Adds a child node to the current node, then sets that node
+    /// AddNode - Adds a child node to the current node, then sets that
     /// node as the current node.
     void AddNode() {
       assert(FlatTree[CurrentNode].Kind == Template &&
@@ -937,12 +937,12 @@ class TemplateDiff {
       return FlatTree[ReadNode].ToArgInfo.IsDefault;
     }
 
-    /// NodeIsSame - Returns true the arguments are the same.
+    /// NodeIsSame - Returns true if the arguments are the same.
     bool NodeIsSame() {
       return FlatTree[ReadNode].Same;
     }
 
-    /// HasChildrend - Returns true if the node has children.
+    /// HasChildren - Returns true if the node has children.
     bool HasChildren() {
       return FlatTree[ReadNode].ChildNode != 0;
     }
@@ -982,7 +982,7 @@ class TemplateDiff {
 
   /// TSTiterator - a pair of iterators that walks the
   /// TemplateSpecializationType and the desugared TemplateSpecializationType.
-  /// The deseguared TemplateArgument should provide the canonical argument
+  /// The desugared TemplateArgument should provide the canonical argument
   /// for comparisons.
   class TSTiterator {
     typedef const TemplateArgument& reference;
@@ -993,7 +993,7 @@ class TemplateDiff {
     /// parameter packs in order with the rest of the TemplateArguments.
     struct InternalIterator {
       /// TST - the template specialization whose arguments this iterator
-      /// traverse over.
+      /// traverses over.
       const TemplateSpecializationType *TST;
 
       /// Index - the index of the template argument in TST.

clang/lib/AST/ASTDiagnostic.cpp

@@ -378,6 +378,21 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
                    addr.getAlignment()};
   }
 
+  /// Create a cir.complex.imag_ptr operation that derives a pointer to the
+  /// imaginary part of the complex value pointed to by the specified pointer
+  /// value.
+  mlir::Value createComplexImagPtr(mlir::Location loc, mlir::Value value) {
+    auto srcPtrTy = mlir::cast<cir::PointerType>(value.getType());
+    auto srcComplexTy = mlir::cast<cir::ComplexType>(srcPtrTy.getPointee());
+    return create<cir::ComplexImagPtrOp>(
+        loc, getPointerTo(srcComplexTy.getElementType()), value);
+  }
+
+  Address createComplexImagPtr(mlir::Location loc, Address addr) {
+    return Address{createComplexImagPtr(loc, addr.getPointer()),
+                   addr.getAlignment()};
+  }
+
   /// Create a cir.ptr_stride operation to get access to an array element.
   /// \p idx is the index of the element to access, \p shouldDecay is true if
   /// the result should decay to a pointer to the element type.

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -41,6 +41,13 @@ void CIRGenCXXABI::buildThisParam(CIRGenFunction &cgf,
   assert(!cir::MissingFeatures::cxxabiThisAlignment());
 }
 
+cir::GlobalLinkageKind CIRGenCXXABI::getCXXDestructorLinkage(
+    GVALinkage linkage, const CXXDestructorDecl *dtor, CXXDtorType dt) const {
+  // Delegate back to cgm by default.
+  return cgm.getCIRLinkageForDeclarator(dtor, linkage,
+                                        /*isConstantVariable=*/false);
+}
+
 mlir::Value CIRGenCXXABI::loadIncomingCXXThis(CIRGenFunction &cgf) {
   ImplicitParamDecl *vd = getThisDecl(cgf);
   Address addr = cgf.getAddrOfLocalVar(vd);

clang/lib/CIR/CodeGen/CIRGenCXXABI.cpp

@@ -72,6 +72,19 @@ class CIRGenCXXABI {
   /// Emit constructor variants required by this ABI.
   virtual void emitCXXConstructors(const clang::CXXConstructorDecl *d) = 0;
 
+  /// Emit dtor variants required by this ABI.
+  virtual void emitCXXDestructors(const clang::CXXDestructorDecl *d) = 0;
+
+  /// Returns true if the given destructor type should be emitted as a linkonce
+  /// delegating thunk, regardless of whether the dtor is defined in this TU or
+  /// not.
+  virtual bool useThunkForDtorVariant(const CXXDestructorDecl *dtor,
+                                      CXXDtorType dt) const = 0;
+
+  virtual cir::GlobalLinkageKind
+  getCXXDestructorLinkage(GVALinkage linkage, const CXXDestructorDecl *dtor,
+                          CXXDtorType dt) const;
+
   /// Returns true if the given constructor or destructor is one of the kinds
   /// that the ABI says returns 'this' (only applies when called non-virtually
   /// for destructors).

clang/lib/CIR/CodeGen/CIRGenCXXABI.h

@@ -637,11 +637,6 @@ LValue CIRGenFunction::emitUnaryOpLValue(const UnaryOperator *e) {
   }
   case UO_Real:
   case UO_Imag: {
-    if (op == UO_Imag) {
-      cgm.errorNYI(e->getSourceRange(), "UnaryOp real/imag");
-      return LValue();
-    }
-
     LValue lv = emitLValue(e->getSubExpr());
     assert(lv.isSimple() && "real/imag on non-ordinary l-value");
 
@@ -656,7 +651,10 @@ LValue CIRGenFunction::emitUnaryOpLValue(const UnaryOperator *e) {
     QualType exprTy = getContext().getCanonicalType(e->getSubExpr()->getType());
     QualType elemTy = exprTy->castAs<clang::ComplexType>()->getElementType();
     mlir::Location loc = getLoc(e->getExprLoc());
-    Address component = builder.createComplexRealPtr(loc, lv.getAddress());
+    Address component =
+        e->getOpcode() == UO_Real
+            ? builder.createComplexRealPtr(loc, lv.getAddress())
+            : builder.createComplexImagPtr(loc, lv.getAddress());
     assert(!cir::MissingFeatures::opTBAA());
     LValue elemLV = makeAddrLValue(component, elemTy);
     elemLV.getQuals().addQualifiers(lv.getQuals());

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -520,12 +520,10 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
         cgf, cgf.getLoc(e->getSourceRange())};
 
     // Store the updated result through the lvalue
-    if (lv.isBitField()) {
-      cgf.cgm.errorNYI(e->getSourceRange(), "Unary inc/dec bitfield");
-      return {};
-    } else {
+    if (lv.isBitField())
+      return cgf.emitStoreThroughBitfieldLValue(RValue::get(value), lv);
+    else
       cgf.emitStoreThroughLValue(RValue::get(value), lv);
-    }
 
     // If this is a postinc, return the value read from memory, otherwise use
     // the updated value.