[MLIR][Flang][OpenMP] Implement lowering simd aligned to MLIR

[domada]

Summary

This patch implements lowering simd aligned clause from PFT to MLIR.

Generated MLIR code contains information which MLIR item needs to be aligned. If the user does not specify the alignment value then the default one is calculated on the basis of target features.

[kiranchandramohan]

For this patch, I would recommend moving the translation changes in MLIR into a separate patch.

Please see comments inline.

flang/lib/Lower/OpenMP.cpp

2438

Has the patch that added this function been reverted?

Is there are test for this case?

flang/test/Lower/OpenMP/simd.f90

168

We need to increase the test coverage.

171

From the standard:
Each list item must have C_PTR or Cray pointer type or have the POINTER or ALLOCATABLE attribute. Cray pointer support has been deprecated.

This array does not meet this criteria and hence not a good test. Will also be good to file a github issue to add this semantic check.

172–177

PARAM_ARG , ARG_0, ARG_1 etc do not seem to be used. Is there a reason for capturing?

mlir/test/Target/LLVMIR/openmp-llvm.mlir

762–777 ↗

(On Diff #492742)

Can you minimise this test to what is only needed to check the translation of this clause?

Could you clarify what types are covered and what types are not covered by this change?

[domada]

flang/lib/Lower/OpenMP.cpp

2438

The patch has been restored: https://reviews.llvm.org/rGbaca3c150733c89686287ba4927c351eec9695e2

Default OpenMP simd alignment is tested here:
https://github.com/llvm/llvm-project/blob/main/clang/test/OpenMP/simd_metadata.c
Would you like to have Flang specific tests as well?

2443–2444

I think that we need to modify Flang parser so that the aligned item is modeled as Expr, not as a symbol.

IMO we should firstly modify parser and then update this review.

flang/test/Lower/OpenMP/simd.f90

171

I created github issue: https://github.com/llvm/llvm-project/issues/61161 to add this semantic check

[domada]

Fortan parser needs to be modified before we will submit lowering simd aligned clause to MLIR.

flang/lib/Lower/OpenMP.cpp

2420–2421

OmpAlignedClause should be modified. It should contain list of Fortran::parser::Variable .

2442–2444

This loop should be modified. We should modify this loop so that it will generate the following MLIR code:

Input Fortran code:

integer, pointer :: a;
! ptr assignment etc.
!$omp simd aligned(a:256)

Pseudo MLIR code which need to be generated:

%a_ptr : !fir.ref<!fir.ref<!fir.ptr<i32>>
; ptr assignment etc.
%a_addr = load %a_ptr
 omp.simdloop aligned(%a_addr -> 256 : i64)

To do it we need to firstly refactor OmpAlignedClause so that it contains list of Fortran::parser::Variable. Then the for loop will look in the following way:

Fortran::lower::StatementContext stmtCtx;
for (const Fortran::parser::Variable &ompItem : ompvarList) {
  alignVars.push_back(fir::getBase(converter.genExprAddr(*Fortran::semantics::GetExpr(ompItem), stmtCtx));
  alignmentValues.push_back(alignmentValueAttr);
}

[domada]

Patch rebased. Use OmpObjectList instead of NameList. Added test cases for C_PTR and Fortran pointers.

[kiranchandramohan]

It will be easier if you can split out the MLIR portions into a separate patch. From a quick look, that looks standalone.

[domada]

Patch rebased.
Applied review remarks - scope of the patch is reduced. It contains only the changes which are required to generate MLIR code for simd aligned clause.

[kiranchandramohan]

LG.

Please add couple more tests with:
-> More than one list item in the aligned clause.
-> List item that is a Fortran pointer.
Also check with the gfortran testsuite before you submit.

flang/lib/Lower/OpenMP.cpp

1199–1201

Nit: No braces.

1202

Nit: Expand auto.

1251

Would passing in a map to getTargetFeatures be better? Will that avoid a copy?

1262–1273

Nit: Can you use getOmpObjectSymbol here, given that Semantics will error out if it is a common block and we will not reach here?

1279

Nit: Does not talk about Less than 0 (which is the comparison used below).

flang/include/flang/Lower/OpenMP.h

 namespace Fortran {
 namespace parser {
 struct OpenMPConstruct;
 struct OpenMPDeclarativeConstruct;
 struct OmpEndLoopDirective;
 struct OmpClauseList;
 } // namespace parser
 
+namespace semantics {
+class SemanticsContext;
+}
+
 namespace lower {
 
 class AbstractConverter;
 
 namespace pft {
 struct Evaluation;
 struct Variable;
 } // namespace pft
 
 // Generate the OpenMP terminator for Operation at Location.
 void genOpenMPTerminator(fir::FirOpBuilder &, mlir::Operation *,
                          mlir::Location);
 
 void genOpenMPConstruct(AbstractConverter &, pft::Evaluation &,
-                        const parser::OpenMPConstruct &);
+                        const parser::OpenMPConstruct &,
+                        Fortran::semantics::SemanticsContext &);
 void genOpenMPDeclarativeConstruct(AbstractConverter &, pft::Evaluation &,
                                    const parser::OpenMPDeclarativeConstruct &);
 int64_t getCollapseValue(const Fortran::parser::OmpClauseList &clauseList);
 void genThreadprivateOp(AbstractConverter &, const pft::Variable &);
 void genDeclareTargetIntGlobal(AbstractConverter &, const pft::Variable &);
 void genOpenMPReduction(AbstractConverter &,
                         const Fortran::parser::OmpClauseList &clauseList);
 

flang/lib/Lower/Bridge.cpp

void genFIR(const Fortran::parser::OpenACCDeclarativeConstruct &accDecl) {
     for (Fortran::lower::pft::Evaluation &e : getEval().getNestedEvaluations())
       genFIR(e);
     builder->restoreInsertionPoint(insertPt);
   }
 
   void genFIR(const Fortran::parser::OpenMPConstruct &omp) {
     mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
     localSymbols.pushScope();
-    genOpenMPConstruct(*this, getEval(), omp);
+    genOpenMPConstruct(*this, getEval(), omp, bridge.getSemanticsContext());
 
     const Fortran::parser::OpenMPLoopConstruct *ompLoop =
         std::get_if<Fortran::parser::OpenMPLoopConstruct>(&omp.u);
     const Fortran::parser::OpenMPBlockConstruct *ompBlock =
         std::get_if<Fortran::parser::OpenMPBlockConstruct>(&omp.u);
 
     // If loop is part of an OpenMP Construct then the OpenMP dialect
     // workshare loop operation has already been created. Only the

flang/lib/Lower/OpenMP.cpp

 #include "flang/Lower/StatementContext.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/tools.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
+#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 
 using DeclareTargetCapturePair =
     std::pair<mlir::omp::DeclareTargetCaptureClause,
               Fortran::semantics::Symbol>;
 
 //===----------------------------------------------------------------------===//
 // Common helper functions
 //===----------------------------------------------------------------------===//
class ClauseProcessor {
   using ClauseTy = Fortran::parser::OmpClause;
 
 public:
   ClauseProcessor(Fortran::lower::AbstractConverter &converter,
                   const Fortran::parser::OmpClauseList &clauses)
       : converter(converter), clauses(clauses) {}
 
   // 'Unique' clauses: They can appear at most once in the clause list.
+  bool processAligned(mlir::Location currentLocation,
+                      Fortran::semantics::SemanticsContext &semanticsContext,
+                      llvm::SmallVector<mlir::Value> &alignVars,
+                      llvm::SmallVector<mlir::Attribute> &alignmentValues);
   bool
   processCollapse(mlir::Location currentLocation,
                   Fortran::lower::pft::Evaluation &eval,
                   llvm::SmallVectorImpl<mlir::Value> &lowerBound,
                   llvm::SmallVectorImpl<mlir::Value> &upperBound,
                   llvm::SmallVectorImpl<mlir::Value> &step,
                   llvm::SmallVectorImpl<const Fortran::semantics::Symbol *> &iv,
                   std::size_t &loopVarTypeSize) const;
for (mlir::Value &operand : operands) {
     useDeviceLocs.push_back(operand.getLoc());
   }
   for (const Fortran::parser::OmpObject &ompObject : useDeviceClause.v) {
     Fortran::semantics::Symbol *sym = getOmpObjectSymbol(ompObject);
     useDeviceSymbols.push_back(sym);
   }
 }
 
+/// Convert MLIR OpenMP target features attribute into
+/// map<string: feature_name, bool is_feature_enabled >
+static llvm::StringMap<bool> getTargetFeatures(mlir::ModuleOp module) {
+  llvm::StringMap<bool> featuresMap;
+  llvm::SmallVector<llvm::StringRef> targetFeaturesVec;
+  llvm::StringRef targetFeaturesStr;
+  auto targetInterface =
+      llvm::dyn_cast<mlir::omp::OffloadModuleInterface>(module.getOperation());
+  if (!targetInterface) {
+    return featuresMap;
+  }
+  auto targetAttr = targetInterface.getTarget();
+  if (!targetAttr)
+    return featuresMap;
+  targetFeaturesStr = targetAttr.getTargetFeatures();
+  targetFeaturesStr.split(targetFeaturesVec, ",");
+  for (auto &feature : targetFeaturesVec) {
+    if (feature.empty())
+      continue;
+    llvm::StringRef featureKeyString = feature.substr(1);
+    featuresMap[featureKeyString] = (feature[0] == '+');
+  }
+
+  return featuresMap;
+}
+
 //===----------------------------------------------------------------------===//
 // ClauseProcessor unique clauses
 //===----------------------------------------------------------------------===//
 
+bool ClauseProcessor::processAligned(
+    mlir::Location currentLocation,
+    Fortran::semantics::SemanticsContext &semanticsContext,
+    llvm::SmallVector<mlir::Value> &alignVars,
+    llvm::SmallVector<mlir::Attribute> &alignmentValues) {
+  auto *alignedClause = findUniqueClause<ClauseTy::Aligned>();
+  if (!alignedClause)
+    return false;
+  const Fortran::parser::OmpAlignedClause &ompAlignClause = alignedClause->v;
+  mlir::IntegerAttr alignmentValueAttr;
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  Fortran::lower::StatementContext stmtCtx;
+  const Fortran::parser::OmpObjectList &ompObjectList =
+      std::get<Fortran::parser::OmpObjectList>(ompAlignClause.t);
+
+  const auto &alignmentValueParserExpr =
+      std::get<std::optional<Fortran::parser::ScalarIntConstantExpr>>(
+          ompAlignClause.t);
+  if (alignmentValueParserExpr) {
+    // Use alignment value specified in the input Fortran code
+    const auto &alignmentValueExpr =
+        Fortran::semantics::GetExpr(alignmentValueParserExpr);
+    const std::optional<std::int64_t> alignment =
+        Fortran::evaluate::ToInt64(*alignmentValueExpr);
+
+    alignmentValueAttr = builder.getI64IntegerAttr(*alignment);
+  } else {
+    // Get target features string stored in MLIR module and generate map where
+    // the key corresponds to given feature and bool value describes if given
+    // feature is enabled
+    llvm::StringMap<bool> featuresMap = getTargetFeatures(builder.getModule());
+
+    const llvm::Triple &triple = fir::getTargetTriple(builder.getModule());
+    // Calculate the default alignment for given target
+    int64_t defaultOpenMPSimdAlignment =
+        llvm::OpenMPIRBuilder::getOpenMPDefaultSimdAlign(triple, featuresMap);
+    alignmentValueAttr = builder.getI64IntegerAttr(defaultOpenMPSimdAlignment);
+  }
+
+  for (const Fortran::parser::OmpObject &ompItem : ompObjectList.v) {
+    const Fortran::parser::Designator *sym = nullptr;
+    std::visit(Fortran::common::visitors{
+                   [&](const Fortran::parser::Designator &designator) {
+                     sym = &designator;
+                   },
+                   [&](const Fortran::parser::Name &name) {
+                     // Common block is represented in OmpObject as Name.
+                     // According to OpenMP 5.2 spec (5.11) common block
+                     // is not allowed as an aligned item. Flang parser checks
+                     // if given aligned item is common block. That's why we
+                     // skip common blocks in MLIR lowering
+                   }},
+               ompItem.u);
+
+    if (!sym)
+      continue;
+
+    // The default alignment for some targets is equal to 0.
+    // Do not generate alignment assumption if alignment is equal to 0.
+    if (alignmentValueAttr.getInt() <= 0)
+      continue;
+
+    mlir::Value alignedItem = fir::getBase(converter.genExprAddr(
+        *(Fortran::semantics::AnalyzeExpr(semanticsContext, *sym)), stmtCtx,
+        &currentLocation));
+    alignVars.push_back(alignedItem);
+    alignmentValues.push_back(alignmentValueAttr);
+  }
+  return true;
+}
+
 bool ClauseProcessor::processCollapse(
     mlir::Location currentLocation, Fortran::lower::pft::Evaluation &eval,
     llvm::SmallVectorImpl<mlir::Value> &lowerBound,
     llvm::SmallVectorImpl<mlir::Value> &upperBound,
     llvm::SmallVectorImpl<mlir::Value> &step,
     llvm::SmallVectorImpl<const Fortran::semantics::Symbol *> &iv,
     std::size_t &loopVarTypeSize) const {
   bool found = false;
createCombinedParallelOp(Fortran::lower::AbstractConverter &converter,
 
   createBodyOfOp<mlir::omp::ParallelOp>(parallelOp, converter, currentLocation,
                                         eval, &opClauseList, /*iv=*/{},
                                         /*isCombined=*/true);
 }
 
 static void genOMP(Fortran::lower::AbstractConverter &converter,
                    Fortran::lower::pft::Evaluation &eval,
-                   const Fortran::parser::OpenMPLoopConstruct &loopConstruct) {
+                   const Fortran::parser::OpenMPLoopConstruct &loopConstruct,
+                   Fortran::semantics::SemanticsContext &semanticsContext) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
   llvm::SmallVector<mlir::Value> lowerBound, upperBound, step, linearVars,
       linearStepVars, reductionVars, alignedVars, nontemporalVars;
   mlir::Value scheduleChunkClauseOperand, ifClauseOperand;
   mlir::IntegerAttr orderedClauseOperand;
   mlir::omp::ClauseOrderKindAttr orderClauseOperand;
   mlir::omp::ClauseScheduleKindAttr scheduleValClauseOperand;
   mlir::omp::ScheduleModifierAttr scheduleModClauseOperand;
   mlir::UnitAttr nowaitClauseOperand, scheduleSimdClauseOperand;
   mlir::IntegerAttr simdlenClauseOperand, safelenClauseOperand;
-  llvm::SmallVector<mlir::Attribute> reductionDeclSymbols;
+  llvm::SmallVector<mlir::Attribute> reductionDeclSymbols, alignmentValues;
   Fortran::lower::StatementContext stmtCtx;
   std::size_t loopVarTypeSize;
   llvm::SmallVector<const Fortran::semantics::Symbol *> iv;
 
   const auto &beginLoopDirective =
       std::get<Fortran::parser::OmpBeginLoopDirective>(loopConstruct.t);
   const auto &loopOpClauseList =
       std::get<Fortran::parser::OmpClauseList>(beginLoopDirective.t);
   mlir::Location currentLocation =
       converter.genLocation(beginLoopDirective.source);
   const auto ompDirective =
       std::get<Fortran::parser::OmpLoopDirective>(beginLoopDirective.t).v;
 
   if (llvm::omp::OMPD_parallel_do == ompDirective) {
     createCombinedParallelOp<Fortran::parser::OmpBeginLoopDirective>(
         converter, eval,
         std::get<Fortran::parser::OmpBeginLoopDirective>(loopConstruct.t));
   } else if (llvm::omp::OMPD_do != ompDirective &&
              llvm::omp::OMPD_simd != ompDirective) {
     TODO(currentLocation, "Construct enclosing do loop");
   }
 
   DataSharingProcessor dsp(converter, loopOpClauseList, eval);
   dsp.processStep1();
 
   ClauseProcessor cp(converter, loopOpClauseList);
   cp.processCollapse(currentLocation, eval, lowerBound, upperBound, step, iv,
                      loopVarTypeSize);
+  cp.processAligned(currentLocation, semanticsContext, alignedVars,
+                    alignmentValues);
   cp.processScheduleChunk(stmtCtx, scheduleChunkClauseOperand);
   cp.processIf(stmtCtx,
                Fortran::parser::OmpIfClause::DirectiveNameModifier::Simd,
                ifClauseOperand);
   cp.processReduction(currentLocation, reductionVars, reductionDeclSymbols);
   cp.processSimdlen(simdlenClauseOperand);
   cp.processSafelen(safelenClauseOperand);
 
static void genOMP(Fortran::lower::AbstractConverter &converter,
   }
 
   // 2.9.3.1 SIMD construct
   // TODO: Support all the clauses
   if (llvm::omp::OMPD_simd == ompDirective) {
     mlir::TypeRange resultType;
     auto simdLoopOp = firOpBuilder.create<mlir::omp::SimdLoopOp>(
         currentLocation, resultType, lowerBound, upperBound, step, alignedVars,
-        /*alignment_values=*/nullptr, ifClauseOperand, nontemporalVars,
-        orderClauseOperand, simdlenClauseOperand, safelenClauseOperand,
+        alignmentValues.empty()
+            ? nullptr
+            : mlir::ArrayAttr::get(firOpBuilder.getContext(), alignmentValues),
+        ifClauseOperand, nontemporalVars, orderClauseOperand,
+        simdlenClauseOperand, safelenClauseOperand,
         /*inclusive=*/firOpBuilder.getUnitAttr());
     createBodyOfOp<mlir::omp::SimdLoopOp>(
         simdLoopOp, converter, currentLocation, eval, &loopOpClauseList, iv,
         /*outer=*/false, &dsp);
     return;
   }
 
   // FIXME: Add support for following clauses:
if (mlir::isa<mlir::omp::WsLoopOp, mlir::omp::ReductionDeclareOp,
     builder.create<mlir::omp::YieldOp>(loc);
   else
     builder.create<mlir::omp::TerminatorOp>(loc);
 }
 
 void Fortran::lower::genOpenMPConstruct(
     Fortran::lower::AbstractConverter &converter,
     Fortran::lower::pft::Evaluation &eval,
-    const Fortran::parser::OpenMPConstruct &ompConstruct) {
+    const Fortran::parser::OpenMPConstruct &ompConstruct,
+    Fortran::semantics::SemanticsContext &semanticsContext) {
   std::visit(
       common::visitors{
           [&](const Fortran::parser::OpenMPStandaloneConstruct
                   &standaloneConstruct) {
             genOMP(converter, eval, standaloneConstruct);
           },
           [&](const Fortran::parser::OpenMPSectionsConstruct
                   &sectionsConstruct) {
             genOMP(converter, eval, sectionsConstruct);
           },
           [&](const Fortran::parser::OpenMPSectionConstruct &sectionConstruct) {
             genOMP(converter, eval, sectionConstruct);
           },
           [&](const Fortran::parser::OpenMPLoopConstruct &loopConstruct) {
-            genOMP(converter, eval, loopConstruct);
+            genOMP(converter, eval, loopConstruct, semanticsContext);
           },
           [&](const Fortran::parser::OpenMPDeclarativeAllocate
                   &execAllocConstruct) {
             TODO(converter.getCurrentLocation(), "OpenMPDeclarativeAllocate");
           },
           [&](const Fortran::parser::OpenMPExecutableAllocate
                   &execAllocConstruct) {
             TODO(converter.getCurrentLocation(), "OpenMPExecutableAllocate");

flang/test/Lower/OpenMP/simd.f90

! CHECK-SAME:               %[[STEP_I]], %[[STEP_J]]) {
   !$OMP SIMD COLLAPSE(2)
   do i = 1, n
     do j = 1, n
        A(i,j) = i + j
     end do
   end do
   !$OMP END SIMD
 end subroutine
+
+!CHECK: func.func @_QPsimdloop_aligned_cptr(%[[ARG_A:.*]]: !fir.ref
+!CHECK-SAME: <!fir.type<_QM__fortran_builtinsT__builtin_c_ptr
+!CHECK-SAME: {__address:i64}>> {fir.bindc_name = "a"}) {
+subroutine simdloop_aligned_cptr( A)
+  use iso_c_binding
+  integer :: i
+  type (c_ptr) :: A
+!CHECK: omp.simdloop aligned(%[[ARG_A]] : !fir.ref
+!CHECK-SAME: <!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>
+!CHECK-SAME: -> 256 : i64)
+  !$OMP SIMD ALIGNED(A:256)
+  do i = 1, 10
+    call c_test_call(A)
+  end do
+  !$OMP END SIMD
+end subroutine
+
+!CHECK-LABEL: func @_QPsimdloop_aligned_allocatable
+subroutine simdloop_aligned_allocatable()
+  integer :: i
+  integer, allocatable :: A(:)
+  allocate(A(10))
+!CHECK: %[[A_PTR:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>> {bindc_name = "a",
+!CHECK-SAME: uniq_name = "_QFsimdloop_aligned_allocatableEa"}
+!CHECK: %[[A_PTR_LOAD:.*]] = fir.load %[[A_PTR]] : !fir.ref<!fir.box<!fir.heap<!fir.array<?xi32>>>>
+!CHECK: %[[A_ALIGNED:.*]] = fir.box_addr %[[A_PTR_LOAD]]  : (!fir.box<!fir.heap<!fir.array<?xi32>>>)
+!CHECK-SAME: -> !fir.heap<!fir.array<?xi32>>
+!CHECK: omp.simdloop aligned(%[[A_ALIGNED]] : !fir.heap<!fir.array<?xi32>> -> 256 : i64)
+  !$OMP SIMD ALIGNED(A:256)
+  do i = 1, 10
+    A(i) = i
+  end do
+end subroutine

flang/test/Lower/OpenMP/simd_aarch64.f90

+! Tests for 2.9.3.1 Simd and target dependent defult alignment for AArch64
+! The default alignment for AARch is 0 so we do not emit aligned clause
+
+! REQUIRES: aarch64-registered-target
+! RUN: %flang_fc1 -triple aarch64-unknown-linux-gnu -emit-fir -fopenmp %s -o - | FileCheck  %s
+
+subroutine simdloop_aligned_cptr(A)
+  use iso_c_binding
+  integer :: i
+  type (c_ptr) :: A
+!CHECK: omp.simdloop
+!CHECK-NOT: aligned(
+!CHECK-SAME: for (%[[IT:.*]]) : i32 = (%[[LB:.*]]) to (%[[UB:.*]]) inclusive step (%[[INC:.*]]) {
+  !$OMP SIMD ALIGNED(A)
+  do i = 1, 10
+    call c_test_call(A)
+  end do
+  !$OMP END SIMD
+end subroutine
+

flang/test/Lower/OpenMP/simd_x86_64.f90

+! Tests for 2.9.3.1 Simd and target dependent defult alignment for x86
+
+! REQUIRES: x86-registered-target
+! RUN: %flang_fc1 -triple x86_64-unknown-linux-gnu -emit-fir -fopenmp -target-cpu x86-64  %s -o - | FileCheck --check-prefixes=DEFAULT %s
+! RUN: %flang_fc1 -triple x86_64-unknown-linux-gnu -emit-fir -fopenmp -target-cpu x86-64 -target-feature +avx %s -o - | FileCheck --check-prefixes=AVX %s
+! RUN: %flang_fc1 -triple x86_64-unknown-linux-gnu -emit-fir -fopenmp -target-cpu x86-64  -target-feature +avx512f  %s -o - | FileCheck --check-prefixes=AVX512F %s
+
+!DEFAULT: func.func @_QPsimdloop_aligned_cptr(%[[ARG_A:.*]]: !fir.ref
+!DEFAULT-SAME: <!fir.type<_QM__fortran_builtinsT__builtin_c_ptr
+!DEFAULT-SAME: {__address:i64}>> {fir.bindc_name = "a"}) {
+!AVX: func.func @_QPsimdloop_aligned_cptr(%[[ARG_A:.*]]: !fir.ref
+!AVX-SAME: <!fir.type<_QM__fortran_builtinsT__builtin_c_ptr
+!AVX-SAME: {__address:i64}>> {fir.bindc_name = "a"}) {
+!AVX512F: func.func @_QPsimdloop_aligned_cptr(%[[ARG_A:.*]]: !fir.ref
+!AVX512F-SAME: <!fir.type<_QM__fortran_builtinsT__builtin_c_ptr
+!AVX512F-SAME: {__address:i64}>> {fir.bindc_name = "a"}) {
+subroutine simdloop_aligned_cptr(A)
+  use iso_c_binding
+  integer :: i
+  type (c_ptr) :: A
+!DEFAULT: omp.simdloop aligned(%[[ARG_A]] : !fir.ref
+!DEFAULT-SAME: <!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>
+!DEFAULT-SAME: -> 128 : i64)
+!AVX: omp.simdloop aligned(%[[ARG_A]] : !fir.ref
+!AVX-SAME: <!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>
+!AVX-SAME: -> 256 : i64)
+!AVX512F: omp.simdloop aligned(%[[ARG_A]] : !fir.ref
+!AVX512F-SAME: <!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>
+!AVX512F-SAME: -> 512 : i64)
+  !$OMP SIMD ALIGNED(A)
+  do i = 1, 10
+    call c_test_call(A)
+  end do
+  !$OMP END SIMD
+end subroutine
+