Lower F08 bit-population count intrinsics

[tarunprabhu]

Summary

This patch implements lowering for the Fortran 2008 bit-population count intrinsics POPCNT, POPPAR, LEADZ and TRAILZ.

POPCNT, LEADZ and TRAILZ are implemented using calls to the corresponding LLVM intrinsic.

POPVAR is implemented in terms of POPCNT.

[klausler]

flang/lib/Lower/IntrinsicCall.cpp

3543

Most modern architectures support bit population count instructions; it would be better to use them where available.

[tarunprabhu]

Thanks. Hadn't realized that.

I will reimplement using LLVM intrinsics.

[tarunprabhu]

Use LLVM intrinsics instead of calculating POPCNT by hand.

Add implementation and tests for LEADZ and TRAILZ in addition to POPCNT and POPPAR since they are also related.

[kiranchandramohan]

The math dialect has operations that model leadz, trailz, pop etc. There exists a conversion from math dialect to llvm (https://github.com/llvm/llvm-project/blob/4ae254e48850033f4e441a28fb28ae27d63ea458/mlir/lib/Conversion/MathToLLVM/MathToLLVM.cpp#L87). Using these ops might be useful since the might have some transformations/folding, the existence of vector versions might help vectorisation in the future.
https://mlir.llvm.org/docs/Dialects/MathOps/#mathctpop-mlirmathctpopop
https://mlir.llvm.org/docs/Dialects/MathOps/#mathctlz-mlirmathcountleadingzerosop
https://mlir.llvm.org/docs/Dialects/MathOps/#mathcttz-mlirmathcounttrailingzerosop

flang/test/Evaluate/fold-popcnt.f90

1 ↗

(On Diff #444080)

I think this can go in as a separate NFC patch since the patch is testing the implementation of existing code.

[tarunprabhu]

Updated patch to use mlir population operators for leadz, popcnt and trailz instead of calling the LLVM intrinsics.

Removed the folding tests from this patch.

[kiranchandramohan]

flang/lib/Lower/IntrinsicCall.cpp

3220

The genMathOp function seems to switch between the libm version and the Math dialect Op version based on whether the setting of mathRuntimeVersion is precise or not. I believe the mathRuntimeVersion is for floating point intrinsics and probably not applicable for integer intrinsics. Adding @vzakhari for an opinion on this.

flang/test/Lower/Intrinsics/leadz.f90

2

Nit: Could you add the flang driver also for tests.

[vzakhari]

flang/lib/Lower/IntrinsicCall.cpp

3220

Thanks for adding me @kiranchandramohan!

Yes, genMathOp cannot distinguish between FP and non-FP operations currntly, so it will treat the operation as FP and generate a call to ctlz under mathRuntimeVersion == precise. We'd better just create the math operation directly here. Moreover, I do not see which library provides ctlz API...

[tarunprabhu]

Create the call to the MLIR ctpop, leadz and trailz instructions directly instead of using genMathOp.

Use the flang driver in the tests.

[kiranchandramohan]

LGTM. Thanks for all the changes. Please wait a day before submitting in case there are further comments from others.

flang/test/Lower/Intrinsics/leadz.f90

2

Apologies, I was requesting flang driver tests in addition. You may add bbc back when you submit.

[tarunprabhu]

flang/test/Lower/Intrinsics/leadz.f90

2

Could you clarify what you mean by this?

[kiranchandramohan]

flang/test/Lower/Intrinsics/leadz.f90

2

I meant having tests with the driver as well as bbc like the test https://github.com/llvm/llvm-project/blob/main/flang/test/Lower/Intrinsics/exp.f90.

! RUN: bbc -emit-fir %s -o - | FileCheck %s
! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s

The second part is applicable if you finally use git push to submit. Then you do not need to create another revision in phabricator for review. You can fetch this patch. Add the RUN like for bbc, rebase and then submit using git push

[tarunprabhu]

Added flang driver in addition to BBC in the tests.

[PeteSteinfeld]

@tarunprabhu , this implementation is failing NAG tests. Do you have access to them?

[tarunprabhu]

In D129584#3673356, @PeteSteinfeld wrote:

@tarunprabhu , this implementation is failing NAG tests. Do you have access to them?

@PeteSteinfeld, no I do not. If you can file a bug report, I can investigate the failure.

[PeteSteinfeld]

In D129584#3712537, @tarunprabhu wrote:

In D129584#3673356, @PeteSteinfeld wrote:

@tarunprabhu , this implementation is failing NAG tests. Do you have access to them?

@PeteSteinfeld, no I do not. If you can file a bug report, I can investigate the failure.

Thanks, @tarunprabhu . I'm all set for now.

flang/lib/Lower/IntrinsicCall.cpp

struct IntrinsicLibrary {
   fir::ExtendedValue genIeeeTypeCompare(mlir::Type,
                                         llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genIeor(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genIndex(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genIor(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genIshft(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genIshftc(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genLbound(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+  mlir::Value genLeadz(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genLen(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genLenTrim(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genMatmul(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genMaxloc(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genMaxval(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genMerge(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genMergeBits(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genMinloc(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genMinval(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genMod(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genModulo(mlir::Type, llvm::ArrayRef<mlir::Value>);
   void genMvbits(llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genNearest(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genNint(mlir::Type, llvm::ArrayRef<mlir::Value>);
   mlir::Value genNot(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genNull(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genPack(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
+  mlir::Value genPopcnt(mlir::Type, llvm::ArrayRef<mlir::Value>);
+  mlir::Value genPoppar(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genPresent(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genProduct(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   void genRandomInit(llvm::ArrayRef<fir::ExtendedValue>);
   void genRandomNumber(llvm::ArrayRef<fir::ExtendedValue>);
   void genRandomSeed(llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genRepeat(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genReshape(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genRRSpacing(mlir::Type resultType,
                            llvm::ArrayRef<mlir::Value> args);
   mlir::Value genScale(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genScan(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genSetExponent(mlir::Type resultType,
                              llvm::ArrayRef<mlir::Value> args);
   mlir::Value genSign(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genSize(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   mlir::Value genSpacing(mlir::Type resultType,
                          llvm::ArrayRef<mlir::Value> args);
   fir::ExtendedValue genSpread(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genSum(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   void genSystemClock(llvm::ArrayRef<fir::ExtendedValue>);
+  mlir::Value genTrailz(mlir::Type, llvm::ArrayRef<mlir::Value>);
   fir::ExtendedValue genTransfer(mlir::Type,
                                  llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genTranspose(mlir::Type,
                                   llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genTrim(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genUbound(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genUnpack(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
   fir::ExtendedValue genVerify(mlir::Type, llvm::ArrayRef<fir::ExtendedValue>);
&I::genIndex,
        {"kind", asValue}}}},
     {"ior", &I::genIor},
     {"ishft", &I::genIshft},
     {"ishftc", &I::genIshftc},
     {"lbound",
      &I::genLbound,
      {{{"array", asInquired}, {"dim", asValue}, {"kind", asValue}}},
      /*isElemental=*/false},
+    {"leadz", &I::genLeadz},
     {"len",
      &I::genLen,
      {{{"string", asInquired}, {"kind", asValue}}},
      /*isElemental=*/false},
     {"len_trim", &I::genLenTrim},
     {"lge", &I::genCharacterCompare<mlir::arith::CmpIPredicate::sge>},
     {"lgt", &I::genCharacterCompare<mlir::arith::CmpIPredicate::sgt>},
     {"lle", &I::genCharacterCompare<mlir::arith::CmpIPredicate::sle>},
static constexpr IntrinsicHandler handlers[]{
     {"not", &I::genNot},
     {"null", &I::genNull, {{{"mold", asInquired}}}, /*isElemental=*/false},
     {"pack",
      &I::genPack,
      {{{"array", asBox},
        {"mask", asBox},
        {"vector", asBox, handleDynamicOptional}}},
      /*isElemental=*/false},
+    {"popcnt", &I::genPopcnt},
+    {"poppar", &I::genPoppar},
     {"present",
      &I::genPresent,
      {{{"a", asInquired}}},
      /*isElemental=*/false},
     {"product",
      &I::genProduct,
      {{{"array", asBox},
        {"dim", asValue},
static constexpr IntrinsicHandler handlers[]{
      {{{"array", asBox},
        {"dim", asValue},
        {"mask", asBox, handleDynamicOptional}}},
      /*isElemental=*/false},
     {"system_clock",
      &I::genSystemClock,
      {{{"count", asAddr}, {"count_rate", asAddr}, {"count_max", asAddr}}},
      /*isElemental=*/false},
+    {"trailz", &I::genTrailz},
     {"transfer",
      &I::genTransfer,
      {{{"source", asAddr}, {"mold", asAddr}, {"size", asValue}}},
      /*isElemental=*/false},
     {"transpose",
      &I::genTranspose,
      {{{"matrix", asAddr}}},
      /*isElemental=*/false},
auto rightMask =
       builder.create<mlir::arith::ShRUIOp>(loc, ones, rightMaskShift);
   auto rightTmp = builder.create<mlir::arith::AndIOp>(loc, I, rightMask);
   auto right = builder.create<mlir::arith::ShLIOp>(loc, rightTmp, leftSize);
   auto resTmp = builder.create<mlir::arith::OrIOp>(loc, unchanged, left);
   auto res = builder.create<mlir::arith::OrIOp>(loc, resTmp, right);
   return builder.create<mlir::arith::SelectOp>(loc, shiftIsNop, I, res);
 }
 
+// LEADZ
+mlir::Value IntrinsicLibrary::genLeadz(mlir::Type resultType,
+                                       llvm::ArrayRef<mlir::Value> args) {
+  assert(args.size() == 1);
+
+  mlir::Value result =
+      builder.create<mlir::math::CountLeadingZerosOp>(loc, args);
+
+  return builder.createConvert(loc, resultType, result);
+}
+
 // LEN
 // Note that this is only used for an unrestricted intrinsic LEN call.
 // Other uses of LEN are rewritten as descriptor inquiries by the front-end.
 fir::ExtendedValue
 IntrinsicLibrary::genLen(mlir::Type resultType,
                          llvm::ArrayRef<fir::ExtendedValue> args) {
   // Optional KIND argument reflected in result type and otherwise ignored.
   assert(args.size() == 1 || args.size() == 2);
mlir::Value resultIrBox =
       fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
 
   fir::runtime::genPack(builder, loc, resultIrBox, array, mask, vector);
 
   return readAndAddCleanUp(resultMutableBox, resultType,
                            "unexpected result for PACK");
 }
 
+// POPCNT
+mlir::Value IntrinsicLibrary::genPopcnt(mlir::Type resultType,
+                                        llvm::ArrayRef<mlir::Value> args) {
+  assert(args.size() == 1);
+
+  mlir::Value count = builder.create<mlir::math::CtPopOp>(loc, args);
+
+  return builder.createConvert(loc, resultType, count);
+}
+
+// POPPAR
+mlir::Value IntrinsicLibrary::genPoppar(mlir::Type resultType,
+                                        llvm::ArrayRef<mlir::Value> args) {
+  assert(args.size() == 1);
+
+  mlir::Value count = genPopcnt(resultType, args);
+  mlir::Value one = builder.createIntegerConstant(loc, resultType, 1);
+
+  return builder.create<mlir::arith::AndIOp>(loc, count, one);
+}
+
 // PRESENT
 fir::ExtendedValue
 IntrinsicLibrary::genPresent(mlir::Type,
                              llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 1);
   return builder.create<fir::IsPresentOp>(loc, builder.getI1Type(),
                                           fir::getBase(args[0]));
 }
 
 // PRODUCT
 fir::ExtendedValue
 IntrinsicLibrary::genProduct(mlir::Type resultType,
return builder
         mlir::Value size = builder.createConvert(
             loc, resultType,
             fir::runtime::genSizeDim(builder, loc, array, dimValue));
         builder.create<fir::ResultOp>(loc, size);
       })
       .getResults()[0];
 }
 
+// TRAILZ
+mlir::Value IntrinsicLibrary::genTrailz(mlir::Type resultType,
+                                        llvm::ArrayRef<mlir::Value> args) {
+  assert(args.size() == 1);
+
+  mlir::Value result =
+      builder.create<mlir::math::CountTrailingZerosOp>(loc, args);
+
+  return builder.createConvert(loc, resultType, result);
+}
+
 static bool hasDefaultLowerBound(const fir::ExtendedValue &exv) {
   return exv.match(
       [](const fir::ArrayBoxValue &arr) { return arr.getLBounds().empty(); },
       [](const fir::CharArrayBoxValue &arr) {
         return arr.getLBounds().empty();
       },
       [](const fir::BoxValue &arr) { return arr.getLBounds().empty(); },
       [](const auto &) { return false; });

flang/test/Lower/Intrinsics/leadz.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: leadz1_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i8>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine leadz1_test(a, b)
+  integer(1) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i8>
+  b = leadz(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctlz %[[AVAL]] : i8
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i8) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine leadz1_test
+
+! CHECK-LABEL: leadz2_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i16>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine leadz2_test(a, b)
+  integer(2) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i16>
+  b = leadz(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctlz %[[AVAL]] : i16
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i16) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine leadz2_test
+
+! CHECK-LABEL: leadz4_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i32>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine leadz4_test(a, b)
+  integer(4) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i32>
+  b = leadz(a)
+  ! CHECK:  %[[RESULT:.*]] = math.ctlz %[[AVAL]] : i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine leadz4_test
+
+! CHECK-LABEL: leadz8_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i64>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine leadz8_test(a, b)
+  integer(8) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i64>
+  b = leadz(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctlz %[[AVAL]] : i64
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i64) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine leadz8_test
+
+! CHECK-LABEL: leadz16_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i128>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine leadz16_test(a, b)
+  integer(16) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i128>
+  b = leadz(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctlz %[[AVAL]] : i128
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i128) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine leadz16_test

flang/test/Lower/Intrinsics/popcnt.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: popcnt1_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i8>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine popcnt1_test(a, b)
+  integer(1) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i8>
+  b = popcnt(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i8
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i8) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine popcnt1_test
+
+! CHECK-LABEL: popcnt2_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i16>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine popcnt2_test(a, b)
+  integer(2) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i16>
+  b = popcnt(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i16
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i16) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine popcnt2_test
+
+! CHECK-LABEL: popcnt4_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i32>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine popcnt4_test(a, b)
+  integer(4) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i32>
+  b = popcnt(a)
+  ! CHECK:  %[[RESULT:.*]] = math.ctpop %[[AVAL]] : i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine popcnt4_test
+
+! CHECK-LABEL: popcnt8_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i64>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine popcnt8_test(a, b)
+  integer(8) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i64>
+  b = popcnt(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i64
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i64) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine popcnt8_test
+
+! CHECK-LABEL: popcnt16_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i128>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine popcnt16_test(a, b)
+  integer(16) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i128>
+  b = popcnt(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i128
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i128) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine popcnt16_test

flang/test/Lower/Intrinsics/poppar.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: poppar1_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i8>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine poppar1_test(a, b)
+  integer(1) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i8>
+  b = poppar(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i8
+  ! CHECK:  %[[CONV:.*]] = fir.convert %[[COUNT]] : (i8) -> i32
+  ! CHECK:  %[[C1:.*]] = arith.constant 1 : i32
+  ! CHECK:  %[[RESULT:.*]] = arith.andi %[[CONV]], %[[C1]] : i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine poppar1_test
+
+! CHECK-LABEL: poppar2_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i16>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine poppar2_test(a, b)
+  integer(2) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i16>
+  b = poppar(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i16
+  ! CHECK:  %[[CONV:.*]] = fir.convert %[[COUNT]] : (i16) -> i32
+  ! CHECK:  %[[C1:.*]] = arith.constant 1 : i32
+  ! CHECK:  %[[RESULT:.*]] = arith.andi %[[CONV]], %[[C1]] : i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine poppar2_test
+
+! CHECK-LABEL: poppar4_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i32>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine poppar4_test(a, b)
+  integer(4) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i32>
+  b = poppar(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i32
+  ! CHECK:  %[[C1:.*]] = arith.constant 1 : i32
+  ! CHECK:  %[[RESULT:.*]] = arith.andi %[[COUNT]], %[[C1]] : i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine poppar4_test
+
+! CHECK-LABEL: poppar8_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i64>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine poppar8_test(a, b)
+  integer(8) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i64>
+  b = poppar(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i64
+  ! CHECK:  %[[CONV:.*]] = fir.convert %[[COUNT]] : (i64) -> i32
+  ! CHECK:  %[[C1:.*]] = arith.constant 1 : i32
+  ! CHECK:  %[[RESULT:.*]] = arith.andi %[[CONV]], %[[C1]] : i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine poppar8_test
+
+! CHECK-LABEL: poppar16_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i128>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine poppar16_test(a, b)
+  integer(16) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i128>
+  b = poppar(a)
+  ! CHECK:  %[[COUNT:.*]] = math.ctpop %[[AVAL]] : i128
+  ! CHECK:  %[[CONV:.*]] = fir.convert %[[COUNT]] : (i128) -> i32
+  ! CHECK:  %[[C1:.*]] = arith.constant 1 : i32
+  ! CHECK:  %[[RESULT:.*]] = arith.andi %[[CONV]], %[[C1]] : i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine poppar16_test

flang/test/Lower/Intrinsics/trailz.f90

+! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+
+! CHECK-LABEL: trailz1_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i8>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine trailz1_test(a, b)
+  integer(1) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i8>
+  b = trailz(a)
+  ! CHECK:  %[[COUNT:.*]] = math.cttz %[[AVAL]] : i8
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i8) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine trailz1_test
+
+! CHECK-LABEL: trailz2_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i16>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine trailz2_test(a, b)
+  integer(2) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i16>
+  b = trailz(a)
+  ! CHECK:  %[[COUNT:.*]] = math.cttz %[[AVAL]] : i16
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i16) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine trailz2_test
+
+! CHECK-LABEL: trailz4_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i32>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine trailz4_test(a, b)
+  integer(4) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i32>
+  b = trailz(a)
+  ! CHECK:  %[[RESULT:.*]] = math.cttz %[[AVAL]] : i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine trailz4_test
+
+! CHECK-LABEL: trailz8_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i64>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine trailz8_test(a, b)
+  integer(8) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i64>
+  b = trailz(a)
+  ! CHECK:  %[[COUNT:.*]] = math.cttz %[[AVAL]] : i64
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i64) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine trailz8_test
+
+! CHECK-LABEL: trailz16_test
+! CHECK-SAME: %[[AREF:.*]]: !fir.ref<i128>{{.*}}, %[[BREF:.*]]: !fir.ref<i32>{{.*}}
+subroutine trailz16_test(a, b)
+  integer(16) :: a
+  integer :: b
+
+  ! CHECK:  %[[AVAL:.*]] = fir.load %[[AREF]] : !fir.ref<i128>
+  b = trailz(a)
+  ! CHECK:  %[[COUNT:.*]] = math.cttz %[[AVAL]] : i128
+  ! CHECK:  %[[RESULT:.*]] = fir.convert %[[COUNT]] : (i128) -> i32
+  ! CHECK:  fir.store %[[RESULT]] to %[[BREF]] : !fir.ref<i32>
+end subroutine trailz16_test