[PATCH] D125652: [LLVM] Add a check if should cast atomic operations to integer type
Shilei Tian via Phabricator via llvm-commits
llvm-commits at lists.llvm.org
Sun May 15 17:45:24 PDT 2022
tianshilei1992 created this revision.
tianshilei1992 added reviewers: jfb, jdoerfert.
Herald added a subscriber: hiraditya.
Herald added a project: All.
tianshilei1992 requested review of this revision.
Herald added a project: LLVM.
Herald added a subscriber: llvm-commits.
Currently for atomic load, store, and rmw instructions, as long as the
operand is floating-point value, they are casted to integer. Nowadays many
targets can actually support part of atomic operations with floating-point
operands. For example, NVPTX supports atomic load and store of floating-point
values. This patch adds a series interface functions `shouldCastAtomicXXXInIR`,
and the default implementations are same as what we currently do. Later for
targets can have their specialization.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D125652
Files:
llvm/include/llvm/CodeGen/TargetLowering.h
llvm/lib/CodeGen/AtomicExpandPass.cpp
Index: llvm/lib/CodeGen/AtomicExpandPass.cpp
===================================================================
--- llvm/lib/CodeGen/AtomicExpandPass.cpp
+++ llvm/lib/CodeGen/AtomicExpandPass.cpp
@@ -254,7 +254,8 @@
}
if (LI) {
- if (LI->getType()->isFloatingPointTy()) {
+ if (TLI->shouldCastAtomicLoadInIR(LI) ==
+ TargetLoweringBase::AtomicExpansionKind::CastToInteger) {
// TODO: add a TLI hook to control this so that each target can
// convert to lowering the original type one at a time.
LI = convertAtomicLoadToIntegerType(LI);
@@ -264,7 +265,8 @@
MadeChange |= tryExpandAtomicLoad(LI);
} else if (SI) {
- if (SI->getValueOperand()->getType()->isFloatingPointTy()) {
+ if (TLI->shouldCastAtomicStoreInIR(SI) ==
+ TargetLoweringBase::AtomicExpansionKind::CastToInteger) {
// TODO: add a TLI hook to control this so that each target can
// convert to lowering the original type one at a time.
SI = convertAtomicStoreToIntegerType(SI);
@@ -285,8 +287,8 @@
MadeChange = true;
} else {
AtomicRMWInst::BinOp Op = RMWI->getOperation();
- if (Op == AtomicRMWInst::Xchg &&
- RMWI->getValOperand()->getType()->isFloatingPointTy()) {
+ if (TLI->shouldCastAtomicRMWIInIR(RMWI) ==
+ TargetLoweringBase::AtomicExpansionKind::CastToInteger) {
// TODO: add a TLI hook to control this so that each target can
// convert to lowering the original type one at a time.
RMWI = convertAtomicXchgToIntegerType(RMWI);
Index: llvm/include/llvm/CodeGen/TargetLowering.h
===================================================================
--- llvm/include/llvm/CodeGen/TargetLowering.h
+++ llvm/include/llvm/CodeGen/TargetLowering.h
@@ -248,6 +248,8 @@
/// w.r.t. what they should expand to.
enum class AtomicExpansionKind {
None, // Don't expand the instruction.
+ CastToInteger, // Cast the atomic instruction to another type, e.g. from
+ // floating-point to integer type.
LLSC, // Expand the instruction into loadlinked/storeconditional; used
// by ARM/AArch64.
LLOnly, // Expand the (load) instruction into just a load-linked, which has
@@ -2045,6 +2047,14 @@
return AtomicExpansionKind::None;
}
+ /// Returns how the given (atomic) load should be casted by the IR-level
+ /// AtomicExpand pass.
+ virtual AtomicExpansionKind shouldCastAtomicLoadInIR(LoadInst *LI) const {
+ if (LI->getType()->isFloatingPointTy())
+ return AtomicExpansionKind::CastToInteger;
+ return AtomicExpansionKind::None;
+ }
+
/// Returns how the given (atomic) store should be expanded by the IR-level
/// AtomicExpand pass into. For instance AtomicExpansionKind::Expand will try
/// to use an atomicrmw xchg.
@@ -2052,6 +2062,15 @@
return AtomicExpansionKind::None;
}
+ /// Returns how the given (atomic) store should be casted by the IR-level
+ /// AtomicExpand pass into. For instance AtomicExpansionKind::CastToInteger
+ /// will try to cast the operands to integer values.
+ virtual AtomicExpansionKind shouldCastAtomicStoreInIR(StoreInst *SI) const {
+ if (SI->getValueOperand()->getType()->isFloatingPointTy())
+ return AtomicExpansionKind::CastToInteger;
+ return AtomicExpansionKind::None;
+ }
+
/// Returns how the given atomic cmpxchg should be expanded by the IR-level
/// AtomicExpand pass.
virtual AtomicExpansionKind
@@ -2066,6 +2085,17 @@
AtomicExpansionKind::CmpXChg : AtomicExpansionKind::None;
}
+ /// Returns how the given atomic atomicrmw should be casted by the IR-level
+ /// AtomicExpand pass.
+ virtual AtomicExpansionKind
+ shouldCastAtomicRMWIInIR(AtomicRMWInst *RMWI) const {
+ if (RMWI->getOperation() == AtomicRMWInst::Xchg &&
+ RMWI->getValOperand()->getType()->isFloatingPointTy())
+ return AtomicExpansionKind::CastToInteger;
+
+ return AtomicExpansionKind::None;
+ }
+
/// On some platforms, an AtomicRMW that never actually modifies the value
/// (such as fetch_add of 0) can be turned into a fence followed by an
/// atomic load. This may sound useless, but it makes it possible for the
-------------- next part --------------
A non-text attachment was scrubbed...
Name: D125652.429581.patch
Type: text/x-patch
Size: 4279 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20220516/1984c149/attachment.bin>
More information about the llvm-commits
mailing list