Skip to content

Commit a95b791

Browse files
kaviya2510kaviya2510
committed
Lowering Nontemporal clause to LLVM IR: Added a Flang pass lower-nontemporal, which adds nontemporal attribute to the load and store of nontemporal variables during fir conversion
1 parent a8278b3 commit a95b791

File tree

11 files changed

+185
-129
lines changed

11 files changed

+185
-129
lines changed

‎flang/include/flang/Optimizer/OpenMP/Passes.td

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -81,6 +81,13 @@ def DoConcurrentConversionPass : Pass<"omp-do-concurrent-conversion", "mlir::fun
8181
];
8282
}
8383

84+
def LowerNontemporalPass : Pass<"lower-nontemporal", "mlir::func::FuncOp"> {
85+
let summary =
86+
"Adds nontemporal attribute to loads and stores performed on "
87+
"the list items specified in the nontemporal clause of omp.simd.";
88+
let dependentDialects = ["mlir::omp::OpenMPDialect"];
89+
}
90+
8491
// Needs to be scheduled on Module as we create functions in it
8592
def LowerWorkshare : Pass<"lower-workshare", "::mlir::ModuleOp"> {
8693
let summary = "Lower workshare construct";

‎flang/lib/Optimizer/CodeGen/CodeGen.cpp

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3550,7 +3550,13 @@ struct StoreOpConversion : public fir::FIROpConversion<fir::StoreOp> {
35503550
newOp = rewriter.create<mlir::LLVM::MemcpyOp>(
35513551
loc, llvmMemref, llvmValue, boxSize, /*isVolatile=*/false);
35523552
} else {
3553-
newOp = rewriter.create<mlir::LLVM::StoreOp>(loc, llvmValue, llvmMemref);
3553+
unsigned alignment =
3554+
store->getAttrOfType<mlir::IntegerAttr>("alignment")
3555+
? store->getAttrOfType<mlir::IntegerAttr>("alignment").getInt()
3556+
: 0;
3557+
newOp = rewriter.create<mlir::LLVM::StoreOp>(
3558+
loc, llvmValue, llvmMemref, alignment, store->hasAttr("volatile"),
3559+
store->hasAttr("nontemporal"));
35543560
}
35553561
if (std::optional<mlir::ArrayAttr> optionalTag = store.getTbaa())
35563562
newOp.setTBAATags(*optionalTag);

‎flang/lib/Optimizer/OpenMP/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ add_flang_library(FlangOpenMPTransforms
88
MapInfoFinalization.cpp
99
MarkDeclareTarget.cpp
1010
LowerWorkshare.cpp
11+
LowerNontemporal.cpp
1112

1213
DEPENDS
1314
FIRDialect

‎flang/lib/Optimizer/OpenMP/LowerNontemporal.cpp

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
//===- LowerNontemporal.cpp -------------------------------------------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
//
9+
// Add nontemporal attributes to load and stores of variables marked as
10+
// nontemporal.
11+
//
12+
//===----------------------------------------------------------------------===//
13+
#include "flang/Optimizer/Dialect/FIROpsSupport.h"
14+
#include "flang/Optimizer/OpenMP/Passes.h"
15+
#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
16+
using namespace mlir;
17+
namespace flangomp {
18+
#define GEN_PASS_DEF_LOWERNONTEMPORALPASS
19+
#include "flang/Optimizer/OpenMP/Passes.h.inc"
20+
} // namespace flangomp
21+
namespace {
22+
class LowerNontemporalPass
23+
: public flangomp::impl::LowerNontemporalPassBase<LowerNontemporalPass> {
24+
void addNonTemporalAttr(omp::SimdOp simdOp) {
25+
if (!simdOp.getNontemporalVars().empty()) {
26+
llvm::SmallVector<mlir::Value> nontemporalOrigVars;
27+
mlir::OperandRange nontemporals = simdOp.getNontemporalVars();
28+
for (mlir::Value nontemporal : nontemporals) {
29+
nontemporalOrigVars.push_back(nontemporal);
30+
}
31+
std::function<mlir::Value(mlir::Value)> getBaseOperand =
32+
[&](mlir::Value operand) -> mlir::Value {
33+
if (mlir::isa<fir::DeclareOp>(operand.getDefiningOp()))
34+
return operand;
35+
else if (auto arrayCoorOp = llvm::dyn_cast<fir::ArrayCoorOp>(
36+
operand.getDefiningOp())) {
37+
return getBaseOperand(arrayCoorOp.getMemref());
38+
} else if (auto boxAddrOp = llvm::dyn_cast<fir::BoxAddrOp>(
39+
operand.getDefiningOp())) {
40+
return getBaseOperand(boxAddrOp.getVal());
41+
} else if (auto loadOp =
42+
llvm::dyn_cast<fir::LoadOp>(operand.getDefiningOp())) {
43+
return getBaseOperand(loadOp.getMemref());
44+
} else {
45+
return operand;
46+
}
47+
};
48+
simdOp->walk([&](Operation *op) {
49+
mlir::Value Operand = nullptr;
50+
if (auto loadOp = llvm::dyn_cast<fir::LoadOp>(op)) {
51+
Operand = loadOp.getMemref();
52+
} else if (auto storeOp = llvm::dyn_cast<fir::StoreOp>(op)) {
53+
Operand = storeOp.getMemref();
54+
}
55+
if (Operand && !(fir::isAllocatableType(Operand.getType()) ||
56+
fir::isPointerType((Operand.getType())))) {
57+
Operand = getBaseOperand(Operand);
58+
if (is_contained(nontemporalOrigVars, Operand)) {
59+
// Set the attribute
60+
op->setAttr("nontemporal", UnitAttr::get(op->getContext()));
61+
}
62+
}
63+
});
64+
}
65+
}
66+
void runOnOperation() override {
67+
Operation *op = getOperation();
68+
op->walk([&](omp::SimdOp simdOp) { addNonTemporalAttr(simdOp); });
69+
}
70+
};
71+
} // namespace

‎flang/lib/Optimizer/Passes/Pipelines.cpp

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -274,8 +274,10 @@ void createHLFIRToFIRPassPipeline(mlir::PassManager &pm, bool enableOpenMP,
274274
addNestedPassToAllTopLevelOperations<PassConstructor>(
275275
pm, hlfir::createInlineHLFIRAssign);
276276
pm.addPass(hlfir::createConvertHLFIRtoFIR());
277-
if (enableOpenMP)
277+
if (enableOpenMP) {
278278
pm.addPass(flangomp::createLowerWorkshare());
279+
pm.addPass(flangomp::createLowerNontemporalPass());
280+
}
279281
}
280282

281283
/// Create a pass pipeline for handling certain OpenMP transformations needed

‎flang/test/Fir/basic-program.fir

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -65,6 +65,8 @@ func.func @_QQmain() {
6565
// PASSES-NEXT: InlineHLFIRAssign
6666
// PASSES-NEXT: ConvertHLFIRtoFIR
6767
// PASSES-NEXT: LowerWorkshare
68+
// PASSES-NEXT: 'func.func' Pipeline
69+
// PASSES-NEXT: LowerNontemporalPass
6870
// PASSES-NEXT: CSE
6971
// PASSES-NEXT: (S) 0 num-cse'd - Number of operations CSE'd
7072
// PASSES-NEXT: (S) 0 num-dce'd - Number of operations DCE'd

‎flang/test/Lower/OpenMP/simd-nontemporal.f90

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
! Test nontemporal clause
2+
! RUN: %flang_fc1 -emit-fir -fopenmp -fopenmp-version=50 %s -o - | FileCheck %s
3+
! RUN: bbc -emit-fir -fopenmp -fopenmp-version=50 %s -o - | FileCheck %s
4+
5+
6+
! CHECK-LABEL: func @_QPsimd_with_nontemporal_clause
7+
subroutine simd_with_nontemporal_clause(n)
8+
! CHECK: %[[A_DECL:.*]] = fir.declare %{{.*}} {uniq_name = "_QFsimd_with_nontemporal_clauseEa"} : (!fir.ref<i32>) -> !fir.ref<i32>
9+
! CHECK: %[[C_DECL:.*]] = fir.declare %{{.*}} {uniq_name = "_QFsimd_with_nontemporal_clauseEc"} : (!fir.ref<i32>) -> !fir.ref<i32>
10+
integer :: i, n
11+
integer :: A, B, C
12+
! CHECK: omp.simd nontemporal(%[[A_DECL]], %[[C_DECL]] : !fir.ref<i32>, !fir.ref<i32>) private(@_QFsimd_with_nontemporal_clauseEi_private_i32 %8 -> %arg1 : !fir.ref<i32>) {
13+
! CHECK-NEXT: omp.loop_nest (%{{.*}}) : i32 = (%{{.*}}) to (%{{.*}}) inclusive step (%{{.*}}) {
14+
!$OMP SIMD NONTEMPORAL(A, C)
15+
do i = 1, n
16+
! CHECK: %[[LOAD:.*]] = fir.load %[[A_DECL]] {nontemporal} : !fir.ref<i32>
17+
C = A + B
18+
! CHECK: %[[ADD_VAL:.*]] = arith.addi %{{.*}}, %{{.*}} : i32
19+
! CHECK: fir.store %[[ADD_VAL]] to %[[C_DECL]] {nontemporal} : !fir.ref<i32>
20+
end do
21+
!$OMP END SIMD
22+
end subroutine
23+
24+
! CHECK-LABEL: func.func @_QPsimd_nontemporal_allocatable
25+
subroutine simd_nontemporal_allocatable(x, y)
26+
integer, allocatable :: x(:)
27+
integer :: y
28+
allocate(x(100))
29+
! CHECK: %[[X_DECL:.*]] = fir.declare %{{.*}} dummy_scope %{{.*}} {fortran_attrs = #fir.var_attrs<allocatable>,
30+
! CHECK-SAME: uniq_name = "_QFsimd_nontemporal_allocatableEx"} : (!fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>, !fir.dscope) -> !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
31+
! CHECK: omp.simd nontemporal(%[[X_DECL]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>) private(@_QFsimd_nontemporal_allocatableEi_private_i32 %2 -> %arg2 : !fir.ref<i32>) {
32+
! CHECK: omp.loop_nest (%{{.*}}) : i32 = (%{{.*}}) to (%{{.*}}) inclusive step (%{{.*}}) {
33+
!$omp simd nontemporal(x)
34+
do i=1,100
35+
! CHECK: %[[VAL1:.*]] = fir.load %[[X_DECL]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
36+
! CHECK: %[[BOX_ADDR:.*]] = fir.box_addr %[[VAL1]] : (!fir.box<!fir.heap<!fir.array<?xi32>>>) -> !fir.heap<!fir.array<?xi32>>
37+
! CHECK: %[[ARR_COOR:.*]] = fir.array_coor %[[BOX_ADDR]](%{{.*}}) %{{.*}} : (!fir.heap<!fir.array<?xi32>>, !fir.shapeshift<1>, i64) -> !fir.ref<i32>
38+
! CHECK: %[[VAL2:.*]] = fir.load %[[ARR_COOR]] {nontemporal} : !fir.ref<i32>
39+
x(i) = x(i) + y
40+
! CHECK: fir.store %{{.*}} to %{{.*}} {nontemporal} : !fir.ref<i32>
41+
end do
42+
!$omp end simd
43+
end subroutine
44+
45+
! CHECK-LABEL: func.func @_QPsimd_nontemporal_pointers
46+
subroutine simd_nontemporal_pointers(a, c)
47+
integer :: b, i
48+
integer :: n
49+
integer, pointer, intent(in):: a(:)
50+
integer, pointer, intent(out) :: c(:)
51+
! CHECK: %[[A_DECL:.*]] = fir.declare %{{.*}} dummy_scope %{{.*}} {fortran_attrs = #fir.var_attrs<intent_in, pointer>,
52+
! CHECK-SAME: uniq_name = "_QFsimd_nontemporal_pointersEa"} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, !fir.dscope) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
53+
! CHECK: %[[C_DECL:.*]] = fir.declare %{{.*}} dummy_scope %{{.*}} {fortran_attrs = #fir.var_attrs<intent_out, pointer>,
54+
! CHECK-SAME: uniq_name = "_QFsimd_nontemporal_pointersEc"} : (!fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>, !fir.dscope) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
55+
!$OMP SIMD NONTEMPORAL(a,c)
56+
do i = 1, n
57+
! CHECK: %[[VAL1:.*]] = fir.load %[[A_DECL]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
58+
! CHECK: %[[VAL2:.*]] = fir.array_coor %[[VAL1]](%{{.*}}) %{{.*}} : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, !fir.shift<1>, i64) -> !fir.ref<i32>
59+
! CHECK: %[[VAL3:.*]] = fir.load %[[VAL2]] {nontemporal} : !fir.ref<i32>
60+
c(i) = a(i) + b
61+
! CHECK: %[[VAL4:.*]] = fir.load %[[C_DECL]] : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
62+
! CHECK: %[[VAL5:.*]] = fir.array_coor %[[VAL4]](%{{.*}}) %{{.*}} : (!fir.box<!fir.ptr<!fir.array<?xi32>>>, !fir.shift<1>, i64) -> !fir.ref<i32>
63+
! CHECK: fir.store %{{.*}} to %[[VAL5]] {nontemporal} : !fir.ref<i32>
64+
end do
65+
!$OMP END SIMD
66+
end subroutine
67+

‎llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

Lines changed: 4 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1231,9 +1231,6 @@ class OpenMPIRBuilder {
12311231
void unrollLoopPartial(DebugLoc DL, CanonicalLoopInfo *Loop, int32_t Factor,
12321232
CanonicalLoopInfo **UnrolledCLI);
12331233

1234-
using NonTemporalBodyGenCallbackTy =
1235-
function_ref<void(llvm::BasicBlock *BB, MDNode *NontemporalNode)>;
1236-
12371234
/// Add metadata to simd-ize a loop. If IfCond is not nullptr, the loop
12381235
/// is cloned. The metadata which prevents vectorization is added to
12391236
/// to the cloned loop. The cloned loop is executed when ifCond is evaluated
@@ -1247,15 +1244,10 @@ class OpenMPIRBuilder {
12471244
/// \param Order The enum to map order clause.
12481245
/// \param Simdlen The Simdlen length to apply to the simd loop.
12491246
/// \param Safelen The Safelen length to apply to the simd loop.
1250-
/// \param NontemporalCBFunc Call back function for nontemporal.
1251-
/// \param NontemporalVars Array of nontemporal vars.
1252-
void applySimd(
1253-
CanonicalLoopInfo *Loop, MapVector<Value *, Value *> AlignedVars,
1254-
Value *IfCond, omp::OrderKind Order, ConstantInt *Simdlen,
1255-
ConstantInt *Safelen,
1256-
NonTemporalBodyGenCallbackTy NontemporalCBFunc = [](BasicBlock *,
1257-
MDNode *) {},
1258-
ArrayRef<Value *> NontempralVars = {});
1247+
void applySimd(CanonicalLoopInfo *Loop,
1248+
MapVector<Value *, Value *> AlignedVars, Value *IfCond,
1249+
omp::OrderKind Order, ConstantInt *Simdlen,
1250+
ConstantInt *Safelen);
12591251

12601252
/// Generator for '#omp flush'
12611253
///

‎llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

Lines changed: 4 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -5341,11 +5341,10 @@ OpenMPIRBuilder::getOpenMPDefaultSimdAlign(const Triple &TargetTriple,
53415341
return 0;
53425342
}
53435343

5344-
void OpenMPIRBuilder::applySimd(
5345-
CanonicalLoopInfo *CanonicalLoop, MapVector<Value *, Value *> AlignedVars,
5346-
Value *IfCond, OrderKind Order, ConstantInt *Simdlen, ConstantInt *Safelen,
5347-
OpenMPIRBuilder::NonTemporalBodyGenCallbackTy NontemporalCBFunc,
5348-
ArrayRef<Value *> NontemporalVarsIn) {
5344+
void OpenMPIRBuilder::applySimd(CanonicalLoopInfo *CanonicalLoop,
5345+
MapVector<Value *, Value *> AlignedVars,
5346+
Value *IfCond, OrderKind Order,
5347+
ConstantInt *Simdlen, ConstantInt *Safelen) {
53495348
LLVMContext &Ctx = Builder.getContext();
53505349

53515350
Function *F = CanonicalLoop->getFunction();
@@ -5443,13 +5442,6 @@ void OpenMPIRBuilder::applySimd(
54435442
}
54445443

54455444
addLoopMetadata(CanonicalLoop, LoopMDList);
5446-
5447-
// Set nontemporal metadata to load and stores of nontemporal values
5448-
if (NontemporalVarsIn.size()) {
5449-
MDNode *NontemporalNode = MDNode::getDistinct(Ctx, {});
5450-
for (BasicBlock *BB : Reachable)
5451-
NontemporalCBFunc(BB, NontemporalNode);
5452-
}
54535445
}
54545446

54555447
/// Create the TargetMachine object to query the backend for optimization

‎mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

Lines changed: 5 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -2462,25 +2462,6 @@ convertOrderKind(std::optional<omp::ClauseOrderKind> o) {
24622462
llvm_unreachable("Unknown ClauseOrderKind kind");
24632463
}
24642464

2465-
static void
2466-
appendNontemporalVars(llvm::BasicBlock *Block,
2467-
SmallVectorImpl<llvm::Value *> &NontemporalVars) {
2468-
for (llvm::Instruction &I : *Block) {
2469-
if (const llvm::CallInst *CI = dyn_cast<llvm::CallInst>(&I)) {
2470-
if (CI->getIntrinsicID() == llvm::Intrinsic::memcpy) {
2471-
llvm::Value *DestPtr = CI->getArgOperand(0);
2472-
llvm::Value *SrcPtr = CI->getArgOperand(1);
2473-
for (const llvm::Value *Var : NontemporalVars) {
2474-
if (Var == SrcPtr) {
2475-
NontemporalVars.push_back(DestPtr);
2476-
break;
2477-
}
2478-
}
2479-
}
2480-
}
2481-
}
2482-
}
2483-
24842465
/// Converts an OpenMP simd loop into LLVM IR using OpenMPIRBuilder.
24852466
static LogicalResult
24862467
convertOmpSimd(Operation &opInst, llvm::IRBuilderBase &builder,
@@ -2529,71 +2510,6 @@ convertOmpSimd(Operation &opInst, llvm::IRBuilderBase &builder,
25292510
llvm::MapVector<llvm::Value *, llvm::Value *> alignedVars;
25302511
llvm::omp::OrderKind order = convertOrderKind(simdOp.getOrder());
25312512

2532-
llvm::SmallVector<llvm::Value *> nontemporalOrigVars;
2533-
mlir::OperandRange nontemporals = simdOp.getNontemporalVars();
2534-
for (mlir::Value nontemporal : nontemporals) {
2535-
llvm::Value *nt = moduleTranslation.lookupValue(nontemporal);
2536-
nontemporalOrigVars.push_back(nt);
2537-
}
2538-
2539-
/** Call back function to attach nontemporal metadata to the load/store
2540-
* instructions of nontemporal variables of Block.
2541-
* Nontemporal variables may be a scalar, fixed size or allocatable
2542-
* or pointer array
2543-
*
2544-
* Example scenarios for nontemporal variables:
2545-
* Case 1: Scalar variable
2546-
* If the nontemporal variable is a scalar, it is allocated on stack.Load
2547-
* and store instructions directly access the alloca pointer of the scalar
2548-
* variable for fetching information about scalar variable or writing
2549-
* into the scalar variable. Mark those load and store instructions as
2550-
* non-temporal.
2551-
*
2552-
* Case 2: Fixed Size array
2553-
* If the nontemporal variable is a fixed-size array, it is allocated
2554-
* as a contiguous block of memory. It uses one GEP instruction, to compute
2555-
* the address of each individual array elements and perform load or store
2556-
* operation on it. Mark those load and store instructions as non-temporal.
2557-
*
2558-
* Case 3: Allocatable array
2559-
* For an allocatable array, which might involve runtime type descriptor,
2560-
* needs to navigate through descriptors using two or more GEP and load
2561-
* instructions to compute the address of each individual element in an array.
2562-
* Mark those load or store which access the individual array elements as
2563-
* non-temporal.
2564-
*/
2565-
auto addNonTemporalMetadataCB = [&](llvm::BasicBlock *Block,
2566-
llvm::MDNode *Nontemporal) {
2567-
SmallVector<llvm::Value *> NontemporalVars{nontemporalOrigVars};
2568-
appendNontemporalVars(Block, NontemporalVars);
2569-
for (llvm::Instruction &I : *Block) {
2570-
llvm::Value *mem_ptr = nullptr;
2571-
bool MetadataFlag = true;
2572-
if (llvm::LoadInst *li = dyn_cast<llvm::LoadInst>(&I)) {
2573-
if (!(li->getType()->isPointerTy()))
2574-
mem_ptr = li->getPointerOperand();
2575-
} else if (llvm::StoreInst *si = dyn_cast<llvm::StoreInst>(&I))
2576-
mem_ptr = si->getPointerOperand();
2577-
if (mem_ptr) {
2578-
while (mem_ptr && !(isa<llvm::AllocaInst>(mem_ptr))) {
2579-
if (llvm::GetElementPtrInst *gep =
2580-
dyn_cast<llvm::GetElementPtrInst>(mem_ptr)) {
2581-
llvm::Type *sourceType = gep->getSourceElementType();
2582-
if (sourceType->isStructTy() && gep->getNumIndices() >= 2 &&
2583-
!(gep->hasAllZeroIndices())) {
2584-
MetadataFlag = false;
2585-
break;
2586-
}
2587-
mem_ptr = gep->getPointerOperand();
2588-
} else if (llvm::LoadInst *li = dyn_cast<llvm::LoadInst>(mem_ptr))
2589-
mem_ptr = li->getPointerOperand();
2590-
}
2591-
if (MetadataFlag && is_contained(NontemporalVars, mem_ptr))
2592-
I.setMetadata(llvm::LLVMContext::MD_nontemporal, Nontemporal);
2593-
}
2594-
}
2595-
};
2596-
25972513
llvm::BasicBlock *sourceBlock = builder.GetInsertBlock();
25982514
std::optional<ArrayAttr> alignmentValues = simdOp.getAlignments();
25992515
mlir::OperandRange operands = simdOp.getAlignedVars();
@@ -2621,11 +2537,11 @@ convertOmpSimd(Operation &opInst, llvm::IRBuilderBase &builder,
26212537

26222538
builder.SetInsertPoint(*regionBlock, (*regionBlock)->begin());
26232539
llvm::CanonicalLoopInfo *loopInfo = findCurrentLoopInfo(moduleTranslation);
2624-
ompBuilder->applySimd(
2625-
loopInfo, alignedVars,
2626-
simdOp.getIfExpr() ? moduleTranslation.lookupValue(simdOp.getIfExpr())
2627-
: nullptr,
2628-
order, simdlen, safelen, addNonTemporalMetadataCB, nontemporalOrigVars);
2540+
ompBuilder->applySimd(loopInfo, alignedVars,
2541+
simdOp.getIfExpr()
2542+
? moduleTranslation.lookupValue(simdOp.getIfExpr())
2543+
: nullptr,
2544+
order, simdlen, safelen);
26292545

26302546
return cleanupPrivateVars(builder, moduleTranslation, simdOp.getLoc(),
26312547
privateVarsInfo.llvmVars,

0 commit comments

Comments
 (0)