Merge branch 'amd-staging' of ssh://gerrit-git.amd.com:29418/lightnin…

…g/ec/llvm-project into amd-staging

clang/include/clang/AST/DeclBase.h

@@ -672,16 +672,6 @@ class alignas(8) Decl {
  /// Whether this declaration comes from explicit global module.
  bool isFromExplicitGlobalModule() const;
 
- /// Check if we should skip checking ODRHash for declaration \param D.
- ///
- /// The existing ODRHash mechanism seems to be not stable enough and
- /// the false positive ODR violation reports are annoying and we rarely see
- /// true ODR violation reports. Also we learned that MSVC disabled ODR checks
- /// for declarations in GMF. So we try to disable ODR checks in the GMF to
- /// get better user experiences before we make the ODR violation checks stable
- /// enough.
- bool shouldSkipCheckingODR() const;
-
  /// Return true if this declaration has an attribute which acts as
  /// definition of the entity, such as 'alias' or 'ifunc'.
  bool hasDefiningAttr() const;

clang/include/clang/Serialization/ASTReader.h

@@ -2457,6 +2457,12 @@ class BitsUnpacker {
  uint32_t Value;
  uint32_t CurrentBitsIndex = ~0;
 };
+
+inline bool shouldSkipCheckingODR(const Decl *D) {
+ return D->getASTContext().getLangOpts().SkipODRCheckInGMF &&
+ D->isFromExplicitGlobalModule();
+}
+
 } // namespace clang
 
 #endif // LLVM_CLANG_SERIALIZATION_ASTREADER_H

clang/lib/AST/Decl.cpp

@@ -4534,7 +4534,7 @@ unsigned FunctionDecl::getODRHash() {
  }
 
  class ODRHash Hash;
- Hash.AddFunctionDecl(this, /*SkipBody=*/shouldSkipCheckingODR());
+ Hash.AddFunctionDecl(this);
  setHasODRHash(true);
  ODRHash = Hash.CalculateHash();
  return ODRHash;

clang/lib/AST/DeclBase.cpp

@@ -1106,11 +1106,6 @@ bool Decl::isFromExplicitGlobalModule() const {
  return getOwningModule() && getOwningModule()->isExplicitGlobalModule();
 }
 
-bool Decl::shouldSkipCheckingODR() const {
- return getASTContext().getLangOpts().SkipODRCheckInGMF &&
- isFromExplicitGlobalModule();
-}
-
 static Decl::Kind getKind(const Decl *D) { return D->getKind(); }
 static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); }
 

clang/lib/AST/Interp/ByteCodeExprGen.cpp

@@ -262,7 +262,7 @@ bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
  return this->discard(SubExpr);
 
  std::optional<PrimType> FromT = classify(SubExpr->getType());
- std::optional<PrimType> ToT = classifyPrim(CE->getType());
+ std::optional<PrimType> ToT = classify(CE->getType());
  if (!FromT || !ToT)
  return false;
 
@@ -1251,17 +1251,35 @@ bool ByteCodeExprGen<Emitter>::VisitUnaryExprOrTypeTraitExpr(
  return this->emitConst(Size.getQuantity(), E);
  }
 
+ if (Kind == UETT_VectorElements) {
+ if (const auto *VT = E->getTypeOfArgument()->getAs<VectorType>())
+ return this->emitConst(VT->getNumElements(), E);
+
+ // FIXME: Apparently we need to catch the fact that a sizeless vector type
+ // has been passed and diagnose that (at run time).
+ assert(E->getTypeOfArgument()->isSizelessVectorType());
+ }
+
  return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitMemberExpr(const MemberExpr *E) {
  // 'Base.Member'
  const Expr *Base = E->getBase();
+ const ValueDecl *Member = E->getMemberDecl();
 
  if (DiscardResult)
  return this->discard(Base);
 
+ if (const auto *VD = dyn_cast<VarDecl>(Member)) {
+ // I am almost confident in saying that a var decl must be static
+ // and therefore registered as a global variable. But this will probably
+ // turn out to be wrong some time in the future, as always.
+ if (auto GlobalIndex = P.getGlobal(VD))
+ return this->emitGetPtrGlobal(*GlobalIndex, E);
+ }
+
  if (Initializing) {
  if (!this->delegate(Base))
  return false;
@@ -1271,8 +1289,6 @@ bool ByteCodeExprGen<Emitter>::VisitMemberExpr(const MemberExpr *E) {
  }
 
  // Base above gives us a pointer on the stack.
- // TODO: Implement non-FieldDecl members.
- const ValueDecl *Member = E->getMemberDecl();
  if (const auto *FD = dyn_cast<FieldDecl>(Member)) {
  const RecordDecl *RD = FD->getParent();
  const Record *R = getRecord(RD);
@@ -1615,7 +1631,7 @@ bool ByteCodeExprGen<Emitter>::VisitCompoundAssignOperator(
  return false;
  if (!this->emitLoad(*LT, E))
  return false;
- if (*LT != *LHSComputationT) {
+ if (LT != LHSComputationT) {
  if (!this->emitCast(*LT, *LHSComputationT, E))
  return false;
  }
@@ -1671,7 +1687,7 @@ bool ByteCodeExprGen<Emitter>::VisitCompoundAssignOperator(
  }
 
  // And now cast from LHSComputationT to ResultT.
- if (*ResultT != *LHSComputationT) {
+ if (ResultT != LHSComputationT) {
  if (!this->emitCast(*LHSComputationT, *ResultT, E))
  return false;
  }

clang/lib/AST/Interp/Disasm.cpp

@@ -264,3 +264,19 @@ LLVM_DUMP_METHOD void Record::dump(llvm::raw_ostream &OS, unsigned Indentation,
  ++I;
  }
 }
+
+LLVM_DUMP_METHOD void Block::dump(llvm::raw_ostream &OS) const {
+ {
+ ColorScope SC(OS, true, {llvm::raw_ostream::BRIGHT_BLUE, true});
+ OS << "Block " << (void *)this << "\n";
+ }
+ unsigned NPointers = 0;
+ for (const Pointer *P = Pointers; P; P = P->Next) {
+ ++NPointers;
+ }
+ OS << " Pointers: " << NPointers << "\n";
+ OS << " Dead: " << IsDead << "\n";
+ OS << " Static: " << IsStatic << "\n";
+ OS << " Extern: " << IsExtern << "\n";
+ OS << " Initialized: " << IsInitialized << "\n";
+}

clang/lib/AST/Interp/FunctionPointer.h

@@ -32,6 +32,7 @@ class FunctionPointer final {
 
  const Function *getFunction() const { return Func; }
  bool isZero() const { return !Func; }
+ bool isValid() const { return Valid; }
  bool isWeak() const {
  if (!Func || !Valid)
  return false;

clang/lib/AST/Interp/Interp.h

@@ -2236,6 +2236,10 @@ inline bool CallPtr(InterpState &S, CodePtr OpPC, uint32_t ArgSize,
  << const_cast<Expr *>(E) << E->getSourceRange();
  return false;
  }
+
+ if (!FuncPtr.isValid())
+ return false;
+
  assert(F);
 
  // Check argument nullability state.

clang/lib/AST/Interp/InterpBlock.h

@@ -118,6 +118,9 @@ class Block final {
  IsInitialized = false;
  }
 
+ void dump() const { dump(llvm::errs()); }
+ void dump(llvm::raw_ostream &OS) const;
+
 protected:
  friend class Pointer;
  friend class DeadBlock;

clang/lib/AST/Interp/Pointer.h

@@ -241,13 +241,10 @@ class Pointer {
 
  /// Checks if the pointer is null.
  bool isZero() const {
- if (Offset != 0)
- return false;
-
  if (isBlockPointer())
  return asBlockPointer().Pointee == nullptr;
  assert(isIntegralPointer());
- return asIntPointer().Value == 0;
+ return asIntPointer().Value == 0 && Offset == 0;
  }
  /// Checks if the pointer is live.
  bool isLive() const {

clang/lib/AST/StmtProfile.cpp

@@ -2071,13 +2071,31 @@ StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) {
  }
 
  CXXRecordDecl *Lambda = S->getLambdaClass();
- ID.AddInteger(Lambda->getODRHash());
-
  for (const auto &Capture : Lambda->captures()) {
  ID.AddInteger(Capture.getCaptureKind());
  if (Capture.capturesVariable())
  VisitDecl(Capture.getCapturedVar());
  }
+
+ // Profiling the body of the lambda may be dangerous during deserialization.
+ // So we'd like only to profile the signature here.
+ ODRHash Hasher;
+ // FIXME: We can't get the operator call easily by
+ // `CXXRecordDecl::getLambdaCallOperator()` if we're in deserialization.
+ // So we have to do something raw here.
+ for (auto *SubDecl : Lambda->decls()) {
+ FunctionDecl *Call = nullptr;
+ if (auto *FTD = dyn_cast<FunctionTemplateDecl>(SubDecl))
+ Call = FTD->getTemplatedDecl();
+ else if (auto *FD = dyn_cast<FunctionDecl>(SubDecl))
+ Call = FD;
+
+ if (!Call)
+ continue;
+
+ Hasher.AddFunctionDecl(Call, /*SkipBody=*/true);
+ }
+ ID.AddInteger(Hasher.CalculateHash());
 }
 
 void

clang/lib/Analysis/FlowSensitive/DataflowEnvironment.cpp

@@ -508,6 +508,11 @@ class ResultObjectVisitor : public RecursiveASTVisitor<ResultObjectVisitor> {
  isa<CXXStdInitializerListExpr>(E)) {
  return;
  }
+ if (auto *Op = dyn_cast<BinaryOperator>(E);
+ Op && Op->getOpcode() == BO_Cmp) {
+ // Builtin `<=>` returns a `std::strong_ordering` object.
+ return;
+ }
 
  if (auto *InitList = dyn_cast<InitListExpr>(E)) {
  if (!InitList->isSemanticForm())

clang/lib/Basic/Targets/SPIR.h

@@ -259,7 +259,7 @@ class LLVM_LIBRARY_VISIBILITY SPIR32TargetInfo : public SPIRTargetInfo {
  SizeType = TargetInfo::UnsignedInt;
  PtrDiffType = IntPtrType = TargetInfo::SignedInt;
  resetDataLayout("e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
- "v96:128-v192:256-v256:256-v512:512-v1024:1024");
+ "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1");
  }
 
  void getTargetDefines(const LangOptions &Opts,
@@ -276,7 +276,7 @@ class LLVM_LIBRARY_VISIBILITY SPIR64TargetInfo : public SPIRTargetInfo {
  SizeType = TargetInfo::UnsignedLong;
  PtrDiffType = IntPtrType = TargetInfo::SignedLong;
  resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-"
- "v96:128-v192:256-v256:256-v512:512-v1024:1024");
+ "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1");
  }
 
  void getTargetDefines(const LangOptions &Opts,
@@ -336,7 +336,7 @@ class LLVM_LIBRARY_VISIBILITY SPIRV32TargetInfo : public BaseSPIRVTargetInfo {
  SizeType = TargetInfo::UnsignedInt;
  PtrDiffType = IntPtrType = TargetInfo::SignedInt;
  resetDataLayout("e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
- "v96:128-v192:256-v256:256-v512:512-v1024:1024");
+ "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1");
  }
 
  void getTargetDefines(const LangOptions &Opts,
@@ -357,7 +357,7 @@ class LLVM_LIBRARY_VISIBILITY SPIRV64TargetInfo : public BaseSPIRVTargetInfo {
  SizeType = TargetInfo::UnsignedLong;
  PtrDiffType = IntPtrType = TargetInfo::SignedLong;
  resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-"
- "v96:128-v192:256-v256:256-v512:512-v1024:1024");
+ "v96:128-v192:256-v256:256-v512:512-v1024:1024-G1");
  }
 
  void getTargetDefines(const LangOptions &Opts,

clang/lib/CodeGen/CGCall.cpp

@@ -4708,11 +4708,11 @@ void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
  AggValueSlot Slot = args.isUsingInAlloca()
  ? createPlaceholderSlot(*this, type) : CreateAggTemp(type, "agg.tmp");
 
- bool DestroyedInCallee = true, NeedsEHCleanup = true;
+ bool DestroyedInCallee = true, NeedsCleanup = true;
  if (const auto *RD = type->getAsCXXRecordDecl())
  DestroyedInCallee = RD->hasNonTrivialDestructor();
  else
- NeedsEHCleanup = needsEHCleanup(type.isDestructedType());
+ NeedsCleanup = type.isDestructedType();
 
  if (DestroyedInCallee)
  Slot.setExternallyDestructed();
@@ -4721,14 +4721,15 @@ void CodeGenFunction::EmitCallArg(CallArgList &args, const Expr *E,
  RValue RV = Slot.asRValue();
  args.add(RV, type);
 
- if (DestroyedInCallee && NeedsEHCleanup) {
+ if (DestroyedInCallee && NeedsCleanup) {
  // Create a no-op GEP between the placeholder and the cleanup so we can
  // RAUW it successfully. It also serves as a marker of the first
  // instruction where the cleanup is active.
- pushFullExprCleanup<DestroyUnpassedArg>(EHCleanup, Slot.getAddress(),
- type);
+ pushFullExprCleanup<DestroyUnpassedArg>(NormalAndEHCleanup,
+ Slot.getAddress(), type);
  // This unreachable is a temporary marker which will be removed later.
- llvm::Instruction *IsActive = Builder.CreateUnreachable();
+ llvm::Instruction *IsActive =
+ Builder.CreateFlagLoad(llvm::Constant::getNullValue(Int8PtrTy));
  args.addArgCleanupDeactivation(EHStack.stable_begin(), IsActive);
  }
  return;

clang/lib/CodeGen/CGCleanup.cpp

@@ -634,12 +634,19 @@ static void destroyOptimisticNormalEntry(CodeGenFunction &CGF,
 /// Pops a cleanup block. If the block includes a normal cleanup, the
 /// current insertion point is threaded through the cleanup, as are
 /// any branch fixups on the cleanup.
-void CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) {
+void CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough,
+ bool ForDeactivation) {
  assert(!EHStack.empty() && "cleanup stack is empty!");
  assert(isa<EHCleanupScope>(*EHStack.begin()) && "top not a cleanup!");
  EHCleanupScope &Scope = cast<EHCleanupScope>(*EHStack.begin());
  assert(Scope.getFixupDepth() <= EHStack.getNumBranchFixups());
 
+ // If we are deactivating a normal cleanup, we need to pretend that the
+ // fallthrough is unreachable. We restore this IP before returning.
+ CGBuilderTy::InsertPoint NormalDeactivateOrigIP;
+ if (ForDeactivation && (Scope.isNormalCleanup() || !getLangOpts().EHAsynch)) {
+ NormalDeactivateOrigIP = Builder.saveAndClearIP();
+ }
  // Remember activation information.
  bool IsActive = Scope.isActive();
  Address NormalActiveFlag =
@@ -729,6 +736,8 @@ void CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) {
  EHStack.popCleanup(); // safe because there are no fixups
  assert(EHStack.getNumBranchFixups() == 0 ||
  EHStack.hasNormalCleanups());
+ if (NormalDeactivateOrigIP.isSet())
+ Builder.restoreIP(NormalDeactivateOrigIP);
  return;
  }
 
@@ -765,9 +774,16 @@ void CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) {
  if (!RequiresNormalCleanup) {
  // Mark CPP scope end for passed-by-value Arg temp
  // per Windows ABI which is "normally" Cleanup in callee
- if (IsEHa && getInvokeDest() && Builder.GetInsertBlock()) {
- if (Personality.isMSVCXXPersonality())
+ if (IsEHa && getInvokeDest()) {
+ // If we are deactivating a normal cleanup then we don't have a
+ // fallthrough. Restore original IP to emit CPP scope ends in the correct
+ // block.
+ if (NormalDeactivateOrigIP.isSet())
+ Builder.restoreIP(NormalDeactivateOrigIP);
+ if (Personality.isMSVCXXPersonality() && Builder.GetInsertBlock())
  EmitSehCppScopeEnd();
+ if (NormalDeactivateOrigIP.isSet())
+ NormalDeactivateOrigIP = Builder.saveAndClearIP();
  }
  destroyOptimisticNormalEntry(*this, Scope);
  Scope.MarkEmitted();
@@ -992,6 +1008,8 @@ void CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) {
  }
  }
 
+ if (NormalDeactivateOrigIP.isSet())
+ Builder.restoreIP(NormalDeactivateOrigIP);
  assert(EHStack.hasNormalCleanups() || EHStack.getNumBranchFixups() == 0);
 
  // Emit the EH cleanup if required.
@@ -1281,17 +1299,8 @@ void CodeGenFunction::DeactivateCleanupBlock(EHScopeStack::stable_iterator C,
  // to the current RunCleanupsScope.
  if (C == EHStack.stable_begin() &&
  CurrentCleanupScopeDepth.strictlyEncloses(C)) {
- // Per comment below, checking EHAsynch is not really necessary
- // it's there to assure zero-impact w/o EHAsynch option
- if (!Scope.isNormalCleanup() && getLangOpts().EHAsynch) {
- PopCleanupBlock();
- } else {
- // If it's a normal cleanup, we need to pretend that the
- // fallthrough is unreachable.
- CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
- PopCleanupBlock();
- Builder.restoreIP(SavedIP);
- }
+ PopCleanupBlock(/*FallthroughIsBranchThrough=*/false,
+ /*ForDeactivation=*/true);
  return;
  }
 

clang/lib/CodeGen/CodeGenFunction.h

@@ -957,7 +957,8 @@ class CodeGenFunction : public CodeGenTypeCache {
 
  /// PopCleanupBlock - Will pop the cleanup entry on the stack and
  /// process all branch fixups.
- void PopCleanupBlock(bool FallThroughIsBranchThrough = false);
+ void PopCleanupBlock(bool FallThroughIsBranchThrough = false,
+ bool ForDeactivation = false);
 
  /// DeactivateCleanupBlock - Deactivates the given cleanup block.
  /// The block cannot be reactivated. Pops it if it's the top of the