[clang] [llvm] [mlir] [openmp] [OMPIRBuilder] Fix atomic compare `==` on `x86-64` long double (PR #226567)

Akash Manna via cfe-commits cfe-commits at lists.llvm.org
Fri Nov 6 21:22:15 PST 2026


================
@@ -11810,14 +11810,99 @@ OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::createAtomicCompare(
   }
 
   bool IsInteger = E->getType()->isIntegerTy();
+  // x86_fp80 holds 80 value bits in 16 bytes; the padding must not take part
+  // in the comparison.
+  const DataLayout &DL = M.getDataLayout();
+  bool HasPadding = X.ElemTy->isFloatingPointTy() &&
+                    X.ElemTy->getPrimitiveSizeInBits().getFixedValue() !=
+                        DL.getTypeAllocSizeInBits(X.ElemTy).getFixedValue();
 
   if (Op == OMPAtomicCompareOp::EQ) {
     // OldValue and SuccessOrFail are set below and used in the shared V.Var /
     // R.Var handling.
     Value *OldValue = nullptr;
     Value *SuccessOrFail = nullptr;
 
-    if (!IsInteger && HandleFPNegZero) {
+    if (HasPadding) {
+      // Load x, compare its value bits only, and use the loaded pattern as the
+      // expected value of the cmpxchg; retry if x changed in between.
+      assert(DL.isLittleEndian() && "padded FP type on a big-endian target");
+      LLVMContext &Ctx = M.getContext();
+      IntegerType *IntCastTy = IntegerType::get(
+          Ctx, DL.getTypeAllocSizeInBits(X.ElemTy).getFixedValue());
+      IntegerType *ValueIntTy = IntegerType::get(
+          Ctx, X.ElemTy->getPrimitiveSizeInBits().getFixedValue());
+      Value *EBits = Builder.CreateBitCast(E, ValueIntTy);
+      Value *DInt =
+          Builder.CreateZExt(Builder.CreateBitCast(D, ValueIntTy), IntCastTy);
+
+      LoadInst *XLoad = Builder.CreateAlignedLoad(
+          IntCastTy, X.Var, X.Alignment, X.Var->getName() + ".atomic.load");
+      XLoad->setAtomic(Failure);
+
+      BasicBlock *CurBB = Builder.GetInsertBlock();
+      Function *F = CurBB->getParent();
+      Instruction *CurBBTI = CurBB->getTerminatorOrNull();
+      CurBBTI = CurBBTI ? CurBBTI : Builder.CreateUnreachable();
+      BasicBlock *ExitBB =
+          CurBB->splitBasicBlock(CurBBTI, X.Var->getName() + ".atomic.exit");
+      BasicBlock *ContBB =
+          BasicBlock::Create(Ctx, X.Var->getName() + ".atomic.cont", F, ExitBB);
+      BasicBlock *CasBB =
+          BasicBlock::Create(Ctx, X.Var->getName() + ".atomic.cas", F, ExitBB);
+
+      CurBB->getTerminator()->eraseFromParent();
+      Builder.SetInsertPoint(CurBB);
+      Builder.CreateBr(ContBB);
+
+      Builder.SetInsertPoint(ContBB);
+      PHINode *XCurr =
+          Builder.CreatePHI(IntCastTy, 2, X.Var->getName() + ".atomic.curr");
+      XCurr->addIncoming(XLoad, CurBB);
+      Value *XBits = Builder.CreateTrunc(XCurr, ValueIntTy);
+      Value *Equal;
+      if (HandleFPNegZero) {
+        // Compare as values: -0.0 == +0.0 and NaN != NaN.
+        Value *XFP = Builder.CreateBitCast(XBits, X.ElemTy);
+        Equal = Builder.CreateFCmpOEQ(XFP, E, "atomic.eq");
+      } else {
+        // OpenMP: == compares the bits of the values, as with memcmp.
+        Equal = Builder.CreateICmpEQ(XBits, EBits, "atomic.eq");
+      }
+      Builder.CreateCondBr(Equal, CasBB, ExitBB);
+
+      Builder.SetInsertPoint(CasBB);
+      AtomicCmpXchgInst *Result = Builder.CreateAtomicCmpXchg(
+          X.Var, XCurr, DInt, X.Alignment, AO, Failure);
+      Result->setWeak(IsWeak);
+      Value *CasOld = Builder.CreateExtractValue(Result, /*Idxs=*/0);
+      Value *CasOk = Builder.CreateExtractValue(Result, /*Idxs=*/1);
+      Builder.CreateCondBr(CasOk, ExitBB, ContBB);
+      XCurr->addIncoming(CasOld, CasBB);
+
+      Builder.SetInsertPoint(ExitBB->begin());
+      PHINode *OldIntPHI =
+          Builder.CreatePHI(IntCastTy, 2, X.Var->getName() + ".atomic.old");
+      OldIntPHI->addIncoming(XCurr, ContBB);
+      OldIntPHI->addIncoming(CasOld, CasBB);
+      PHINode *SuccessPHI = Builder.CreatePHI(Builder.getInt1Ty(), 2,
+                                              X.Var->getName() + ".atomic.ok");
+      SuccessPHI->addIncoming(Builder.getFalse(), ContBB);
+      SuccessPHI->addIncoming(Builder.getTrue(), CasBB);
+
+      if (isa<UnreachableInst>(ExitBB->getTerminator())) {
+        CurBBTI->eraseFromParent();
+        Builder.SetInsertPoint(ExitBB);
+      } else {
+        Builder.SetInsertPoint(&*ExitBB->getFirstNonPHIIt());
+      }
+
+      if (V.Var)
----------------
akash-manna-sky wrote:

Done, the padded branch now always emits the old value, and @f's CHECKs allow the trunc and bitcast. Added an f80 "v = x after" case to openmp-atomic-compare-capture.mlir.


https://github.com/llvm/llvm-project/pull/226567


More information about the cfe-commits mailing list