Merged main:3082a381f57ef2885c270f41f2955e08c79634c5 into amd-gfx:961ceed5c647

Local branch amd-gfx 961ceed Merged main:6932f47cfdf4734d68759586047aee240861058e into amd-gfx:781baf4fd9cc
Remote branch main 3082a38 [LTO] Introduce helper functions to add GUIDs to ImportList (NFC) (llvm#105555)

Author: SC llvm team

clang/docs/ReleaseNotes.rst

@@ -294,6 +294,8 @@ Bug Fixes to C++ Support
 - Correctly check constraints of explicit instantiations of member functions. (#GH46029)
 - Fixed an assertion failure about a constraint of a friend function template references to a value with greater
   template depth than the friend function template. (#GH98258)
+- Clang now rebuilds the template parameters of out-of-line declarations and specializations in the context
+  of the current instantiation in all cases.
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^

clang/include/clang/Basic/BuiltinsWebAssembly.def

@@ -135,10 +135,10 @@ TARGET_BUILTIN(__builtin_wasm_min_f64x2, "V2dV2dV2d", "nc", "simd128")
 TARGET_BUILTIN(__builtin_wasm_max_f64x2, "V2dV2dV2d", "nc", "simd128")
 TARGET_BUILTIN(__builtin_wasm_pmin_f64x2, "V2dV2dV2d", "nc", "simd128")
 TARGET_BUILTIN(__builtin_wasm_pmax_f64x2, "V2dV2dV2d", "nc", "simd128")
-TARGET_BUILTIN(__builtin_wasm_min_f16x8, "V8hV8hV8h", "nc", "half-precision")
-TARGET_BUILTIN(__builtin_wasm_max_f16x8, "V8hV8hV8h", "nc", "half-precision")
-TARGET_BUILTIN(__builtin_wasm_pmin_f16x8, "V8hV8hV8h", "nc", "half-precision")
-TARGET_BUILTIN(__builtin_wasm_pmax_f16x8, "V8hV8hV8h", "nc", "half-precision")
+TARGET_BUILTIN(__builtin_wasm_min_f16x8, "V8hV8hV8h", "nc", "fp16")
+TARGET_BUILTIN(__builtin_wasm_max_f16x8, "V8hV8hV8h", "nc", "fp16")
+TARGET_BUILTIN(__builtin_wasm_pmin_f16x8, "V8hV8hV8h", "nc", "fp16")
+TARGET_BUILTIN(__builtin_wasm_pmax_f16x8, "V8hV8hV8h", "nc", "fp16")
 
 TARGET_BUILTIN(__builtin_wasm_ceil_f32x4, "V4fV4f", "nc", "simd128")
 TARGET_BUILTIN(__builtin_wasm_floor_f32x4, "V4fV4f", "nc", "simd128")
@@ -170,8 +170,8 @@ TARGET_BUILTIN(__builtin_wasm_relaxed_madd_f32x4, "V4fV4fV4fV4f", "nc", "relaxed
 TARGET_BUILTIN(__builtin_wasm_relaxed_nmadd_f32x4, "V4fV4fV4fV4f", "nc", "relaxed-simd")
 TARGET_BUILTIN(__builtin_wasm_relaxed_madd_f64x2, "V2dV2dV2dV2d", "nc", "relaxed-simd")
 TARGET_BUILTIN(__builtin_wasm_relaxed_nmadd_f64x2, "V2dV2dV2dV2d", "nc", "relaxed-simd")
-TARGET_BUILTIN(__builtin_wasm_relaxed_madd_f16x8, "V8hV8hV8hV8h", "nc", "half-precision")
-TARGET_BUILTIN(__builtin_wasm_relaxed_nmadd_f16x8, "V8hV8hV8hV8h", "nc", "half-precision")
+TARGET_BUILTIN(__builtin_wasm_relaxed_madd_f16x8, "V8hV8hV8hV8h", "nc", "fp16")
+TARGET_BUILTIN(__builtin_wasm_relaxed_nmadd_f16x8, "V8hV8hV8hV8h", "nc", "fp16")
 
 TARGET_BUILTIN(__builtin_wasm_relaxed_laneselect_i8x16, "V16ScV16ScV16ScV16Sc", "nc", "relaxed-simd")
 TARGET_BUILTIN(__builtin_wasm_relaxed_laneselect_i16x8, "V8sV8sV8sV8s", "nc", "relaxed-simd")
@@ -197,11 +197,11 @@ TARGET_BUILTIN(__builtin_wasm_relaxed_dot_i8x16_i7x16_add_s_i32x4, "V4iV16ScV16S
 TARGET_BUILTIN(__builtin_wasm_relaxed_dot_bf16x8_add_f32_f32x4, "V4fV8UsV8UsV4f", "nc", "relaxed-simd")
 
 // Half-Precision (fp16)
-TARGET_BUILTIN(__builtin_wasm_loadf16_f32, "fh*", "nU", "half-precision")
-TARGET_BUILTIN(__builtin_wasm_storef16_f32, "vfh*", "n", "half-precision")
-TARGET_BUILTIN(__builtin_wasm_splat_f16x8, "V8hf", "nc", "half-precision")
-TARGET_BUILTIN(__builtin_wasm_extract_lane_f16x8, "fV8hi", "nc", "half-precision")
-TARGET_BUILTIN(__builtin_wasm_replace_lane_f16x8, "V8hV8hif", "nc", "half-precision")
+TARGET_BUILTIN(__builtin_wasm_loadf16_f32, "fh*", "nU", "fp16")
+TARGET_BUILTIN(__builtin_wasm_storef16_f32, "vfh*", "n", "fp16")
+TARGET_BUILTIN(__builtin_wasm_splat_f16x8, "V8hf", "nc", "fp16")
+TARGET_BUILTIN(__builtin_wasm_extract_lane_f16x8, "fV8hi", "nc", "fp16")
+TARGET_BUILTIN(__builtin_wasm_replace_lane_f16x8, "V8hV8hif", "nc", "fp16")
 
 // Reference Types builtins
 // Some builtins are custom type-checked - see 't' as part of the third argument,

clang/include/clang/Basic/CodeGenOptions.def

@@ -37,6 +37,7 @@ VALUE_CODEGENOPT(Name, Bits, Default)
 
 CODEGENOPT(DisableIntegratedAS, 1, 0) ///< -no-integrated-as
 CODEGENOPT(Crel, 1, 0) ///< -Wa,--crel
+CODEGENOPT(ImplicitMapSyms, 1, 0) ///< -Wa,-mmapsyms=implicit
 CODEGENOPT(AsmVerbose        , 1, 0) ///< -dA, -fverbose-asm.
 CODEGENOPT(PreserveAsmComments, 1, 1) ///< -dA, -fno-preserve-as-comments.
 CODEGENOPT(AssumeSaneOperatorNew , 1, 1) ///< implicit __attribute__((malloc)) operator new

clang/include/clang/Driver/Options.td

@@ -5033,8 +5033,8 @@ def mexception_handing : Flag<["-"], "mexception-handling">, Group<m_wasm_Featur
 def mno_exception_handing : Flag<["-"], "mno-exception-handling">, Group<m_wasm_Features_Group>;
 def mextended_const : Flag<["-"], "mextended-const">, Group<m_wasm_Features_Group>;
 def mno_extended_const : Flag<["-"], "mno-extended-const">, Group<m_wasm_Features_Group>;
-def mhalf_precision : Flag<["-"], "mhalf-precision">, Group<m_wasm_Features_Group>;
-def mno_half_precision : Flag<["-"], "mno-half-precision">, Group<m_wasm_Features_Group>;
+def mfp16 : Flag<["-"], "mfp16">, Group<m_wasm_Features_Group>;
+def mno_fp16 : Flag<["-"], "mno-fp16">, Group<m_wasm_Features_Group>;
 def mmultimemory : Flag<["-"], "mmultimemory">, Group<m_wasm_Features_Group>;
 def mno_multimemory : Flag<["-"], "mno-multimemory">, Group<m_wasm_Features_Group>;
 def mmultivalue : Flag<["-"], "mmultivalue">, Group<m_wasm_Features_Group>;
@@ -7142,6 +7142,12 @@ def massembler_fatal_warnings : Flag<["-"], "massembler-fatal-warnings">,
 def crel : Flag<["--"], "crel">,
   HelpText<"Enable CREL relocation format (ELF only)">,
   MarshallingInfoFlag<CodeGenOpts<"Crel">>;
+def mmapsyms_implicit : Flag<["-"], "mmapsyms=implicit">,
+  HelpText<"Allow mapping symbol at section beginning to be implicit, "
+    "lowering number of mapping symbols at the expense of some "
+    "portability. Recommended for projects that can build all their "
+    "object files using this option">,
+  MarshallingInfoFlag<CodeGenOpts<"ImplicitMapSyms">>;
 def mrelax_relocations_no : Flag<["-"], "mrelax-relocations=no">,
     HelpText<"Disable x86 relax relocations">,
     MarshallingInfoNegativeFlag<CodeGenOpts<"X86RelaxRelocations">>;

clang/lib/AST/ByteCode/Compiler.cpp

@@ -885,34 +885,60 @@ bool Compiler<Emitter>::VisitPointerArithBinOp(const BinaryOperator *E) {
   if (!LT || !RT)
     return false;
 
+  // Visit the given pointer expression and optionally convert to a PT_Ptr.
+  auto visitAsPointer = [&](const Expr *E, PrimType T) -> bool {
+    if (!this->visit(E))
+      return false;
+    if (T != PT_Ptr)
+      return this->emitDecayPtr(T, PT_Ptr, E);
+    return true;
+  };
+
   if (LHS->getType()->isPointerType() && RHS->getType()->isPointerType()) {
     if (Op != BO_Sub)
       return false;
 
     assert(E->getType()->isIntegerType());
-    if (!visit(RHS) || !visit(LHS))
+    if (!visitAsPointer(RHS, *RT) || !visitAsPointer(LHS, *LT))
       return false;
 
     return this->emitSubPtr(classifyPrim(E->getType()), E);
   }
 
   PrimType OffsetType;
   if (LHS->getType()->isIntegerType()) {
-    if (!visit(RHS) || !visit(LHS))
+    if (!visitAsPointer(RHS, *RT))
+      return false;
+    if (!this->visit(LHS))
       return false;
     OffsetType = *LT;
   } else if (RHS->getType()->isIntegerType()) {
-    if (!visit(LHS) || !visit(RHS))
+    if (!visitAsPointer(LHS, *LT))
+      return false;
+    if (!this->visit(RHS))
       return false;
     OffsetType = *RT;
   } else {
     return false;
   }
 
-  if (Op == BO_Add)
-    return this->emitAddOffset(OffsetType, E);
-  else if (Op == BO_Sub)
-    return this->emitSubOffset(OffsetType, E);
+  // Do the operation and optionally transform to
+  // result pointer type.
+  if (Op == BO_Add) {
+    if (!this->emitAddOffset(OffsetType, E))
+      return false;
+
+    if (classifyPrim(E) != PT_Ptr)
+      return this->emitDecayPtr(PT_Ptr, classifyPrim(E), E);
+    return true;
+  } else if (Op == BO_Sub) {
+    if (!this->emitSubOffset(OffsetType, E))
+      return false;
+
+    if (classifyPrim(E) != PT_Ptr)
+      return this->emitDecayPtr(PT_Ptr, classifyPrim(E), E);
+    return true;
+  }
 
   return false;
 }
@@ -4359,11 +4385,6 @@ bool Compiler<Emitter>::visitReturnStmt(const ReturnStmt *RS) {
 }
 
 template <class Emitter> bool Compiler<Emitter>::visitIfStmt(const IfStmt *IS) {
-  if (IS->isNonNegatedConsteval())
-    return visitStmt(IS->getThen());
-  if (IS->isNegatedConsteval())
-    return IS->getElse() ? visitStmt(IS->getElse()) : true;
-
   if (auto *CondInit = IS->getInit())
     if (!visitStmt(CondInit))
       return false;
@@ -4372,8 +4393,19 @@ template <class Emitter> bool Compiler<Emitter>::visitIfStmt(const IfStmt *IS) {
     if (!visitDeclStmt(CondDecl))
       return false;
 
-  if (!this->visitBool(IS->getCond()))
-    return false;
+  // Compile condition.
+  if (IS->isNonNegatedConsteval()) {
+    if (!this->emitIsConstantContext(IS))
+      return false;
+  } else if (IS->isNegatedConsteval()) {
+    if (!this->emitIsConstantContext(IS))
+      return false;
+    if (!this->emitInv(IS))
+      return false;
+  } else {
+    if (!this->visitBool(IS->getCond()))
+      return false;
+  }
 
   if (const Stmt *Else = IS->getElse()) {
     LabelTy LabelElse = this->getLabel();

clang/lib/AST/ByteCode/FunctionPointer.cpp

@@ -0,0 +1,43 @@
+//===----------------------- FunctionPointer.cpp ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "FunctionPointer.h"
+
+namespace clang {
+namespace interp {
+
+APValue FunctionPointer::toAPValue(const ASTContext &) const {
+  if (!Func)
+    return APValue(static_cast<Expr *>(nullptr), CharUnits::Zero(), {},
+                   /*OnePastTheEnd=*/false, /*IsNull=*/true);
+
+  if (!Valid)
+    return APValue(static_cast<Expr *>(nullptr),
+                   CharUnits::fromQuantity(getIntegerRepresentation()), {},
+                   /*OnePastTheEnd=*/false, /*IsNull=*/false);
+
+  if (Func->getDecl())
+    return APValue(Func->getDecl(), CharUnits::fromQuantity(Offset), {},
+                   /*OnePastTheEnd=*/false, /*IsNull=*/false);
+  return APValue(Func->getExpr(), CharUnits::fromQuantity(Offset), {},
+                 /*OnePastTheEnd=*/false, /*IsNull=*/false);
+}
+
+void FunctionPointer::print(llvm::raw_ostream &OS) const {
+  OS << "FnPtr(";
+  if (Func && Valid)
+    OS << Func->getName();
+  else if (Func)
+    OS << reinterpret_cast<uintptr_t>(Func);
+  else
+    OS << "nullptr";
+  OS << ") + " << Offset;
+}
+
+} // namespace interp
+} // namespace clang

clang/lib/AST/ByteCode/FunctionPointer.h

@@ -11,25 +11,29 @@
 
 #include "Function.h"
 #include "Primitives.h"
-#include "clang/AST/APValue.h"
 
 namespace clang {
 class ASTContext;
+class APValue;
 namespace interp {
 
 class FunctionPointer final {
 private:
   const Function *Func;
+  uint64_t Offset;
   bool Valid;
 
 public:
   FunctionPointer() = default;
-  FunctionPointer(const Function *Func) : Func(Func), Valid(true) {}
+  FunctionPointer(const Function *Func, uint64_t Offset = 0)
+      : Func(Func), Offset(Offset), Valid(true) {}
 
   FunctionPointer(uintptr_t IntVal, const Descriptor *Desc = nullptr)
-      : Func(reinterpret_cast<const Function *>(IntVal)), Valid(false) {}
+      : Func(reinterpret_cast<const Function *>(IntVal)), Offset(0),
+        Valid(false) {}
 
   const Function *getFunction() const { return Func; }
+  uint64_t getOffset() const { return Offset; }
   bool isZero() const { return !Func; }
   bool isValid() const { return Valid; }
   bool isWeak() const {
@@ -39,33 +43,8 @@ class FunctionPointer final {
     return Func->getDecl()->isWeak();
   }
 
-  APValue toAPValue(const ASTContext &) const {
-    if (!Func)
-      return APValue(static_cast<Expr *>(nullptr), CharUnits::Zero(), {},
-                     /*OnePastTheEnd=*/false, /*IsNull=*/true);
-
-    if (!Valid)
-      return APValue(static_cast<Expr *>(nullptr),
-                     CharUnits::fromQuantity(getIntegerRepresentation()), {},
-                     /*OnePastTheEnd=*/false, /*IsNull=*/false);
-
-    if (Func->getDecl())
-      return APValue(Func->getDecl(), CharUnits::Zero(), {},
-                     /*OnePastTheEnd=*/false, /*IsNull=*/false);
-    return APValue(Func->getExpr(), CharUnits::Zero(), {},
-                   /*OnePastTheEnd=*/false, /*IsNull=*/false);
-  }
-
-  void print(llvm::raw_ostream &OS) const {
-    OS << "FnPtr(";
-    if (Func && Valid)
-      OS << Func->getName();
-    else if (Func)
-      OS << reinterpret_cast<uintptr_t>(Func);
-    else
-      OS << "nullptr";
-    OS << ")";
-  }
+  APValue toAPValue(const ASTContext &) const;
+  void print(llvm::raw_ostream &OS) const;
 
   std::string toDiagnosticString(const ASTContext &Ctx) const {
     if (!Func)
@@ -79,7 +58,7 @@ class FunctionPointer final {
   }
 
   ComparisonCategoryResult compare(const FunctionPointer &RHS) const {
-    if (Func == RHS.Func)
+    if (Func == RHS.Func && Offset == RHS.Offset)
       return ComparisonCategoryResult::Equal;
     return ComparisonCategoryResult::Unordered;
   }

clang/lib/AST/ByteCode/Interp.h

@@ -1857,8 +1857,23 @@ bool OffsetHelper(InterpState &S, CodePtr OpPC, const T &Offset,
     else
       S.Stk.push<Pointer>(V - O, Ptr.asIntPointer().Desc);
     return true;
+  } else if (Ptr.isFunctionPointer()) {
+    uint64_t O = static_cast<uint64_t>(Offset);
+    uint64_t N;
+    if constexpr (Op == ArithOp::Add)
+      N = Ptr.getByteOffset() + O;
+    else
+      N = Ptr.getByteOffset() - O;
+
+    if (N > 1)
+      S.CCEDiag(S.Current->getSource(OpPC), diag::note_constexpr_array_index)
+          << N << /*non-array*/ true << 0;
+    S.Stk.push<Pointer>(Ptr.asFunctionPointer().getFunction(), N);
+    return true;
   }
 
+  assert(Ptr.isBlockPointer());
+
   uint64_t MaxIndex = static_cast<uint64_t>(Ptr.getNumElems());
   uint64_t Index;
   if (Ptr.isOnePastEnd())
@@ -2024,10 +2039,15 @@ inline bool SubPtr(InterpState &S, CodePtr OpPC) {
     return true;
   }
 
-  T A = LHS.isElementPastEnd() ? T::from(LHS.getNumElems())
-                               : T::from(LHS.getIndex());
-  T B = RHS.isElementPastEnd() ? T::from(RHS.getNumElems())
-                               : T::from(RHS.getIndex());
+  T A = LHS.isBlockPointer()
+            ? (LHS.isElementPastEnd() ? T::from(LHS.getNumElems())
+                                      : T::from(LHS.getIndex()))
+            : T::from(LHS.getIntegerRepresentation());
+  T B = RHS.isBlockPointer()
+            ? (RHS.isElementPastEnd() ? T::from(RHS.getNumElems())
+                                      : T::from(RHS.getIndex()))
+            : T::from(RHS.getIntegerRepresentation());
+
   return AddSubMulHelper<T, T::sub, std::minus>(S, OpPC, A.bitWidth(), A, B);
 }
 
@@ -2905,8 +2925,15 @@ inline bool DecayPtr(InterpState &S, CodePtr OpPC) {
 
   if constexpr (std::is_same_v<FromT, FunctionPointer> &&
                 std::is_same_v<ToT, Pointer>) {
-    S.Stk.push<Pointer>(OldPtr.getFunction());
+    S.Stk.push<Pointer>(OldPtr.getFunction(), OldPtr.getOffset());
     return true;
+  } else if constexpr (std::is_same_v<FromT, Pointer> &&
+                       std::is_same_v<ToT, FunctionPointer>) {
+    if (OldPtr.isFunctionPointer()) {
+      S.Stk.push<FunctionPointer>(OldPtr.asFunctionPointer().getFunction(),
+                                  OldPtr.getByteOffset());
+      return true;
+    }
   }
 
   S.Stk.push<ToT>(ToT(OldPtr.getIntegerRepresentation(), nullptr));
@@ -3049,6 +3076,11 @@ static inline bool Free(InterpState &S, CodePtr OpPC, bool DeleteIsArrayForm) {
                              BlockDesc, Source);
 }
 
+static inline bool IsConstantContext(InterpState &S, CodePtr OpPC) {
+  S.Stk.push<Boolean>(Boolean::from(S.inConstantContext()));
+  return true;
+}
+
 inline bool CheckLiteralType(InterpState &S, CodePtr OpPC, const Type *T) {
   assert(T);
   assert(!S.getLangOpts().CPlusPlus23);

clang/lib/AST/ByteCode/Opcodes.td

@@ -780,3 +780,5 @@ def AllocCN : Opcode {
 def Free : Opcode {
   let Args = [ArgBool];
 }
+
+def IsConstantContext: Opcode;