[Flang] Make the TODO messages for intrinsics more consistent

[PeteSteinfeld]

Summary

This title says it all.

[vdonaldson]

flang/lib/Lower/IntrinsicCall.cpp

3124

IEEE_IS_FINITE is not a language intrinsic. It is an intrinsic module procedure (from intrinsic module IEEE_ARITHMETIC). So the original message is correct.

[PeteSteinfeld]

Responding to Val's comment.

flang/lib/Lower/IntrinsicCall.cpp

3124

Thanks for clarifying. I'll fix this.

[vdonaldson]

Thanks Pete!

flang/lib/Lower/IntrinsicCall.cpp

IntrinsicLibrary::genIeeeIsFinite(mlir::Type resultType,
   mlir::Value intVal =
       builder.create<mlir::arith::BitcastOp>(loc, intType, floatVal);
   int significandBits;
   if (floatType.isa<mlir::Float32Type>())
     significandBits = 23;
   else if (floatType.isa<mlir::Float64Type>())
     significandBits = 52;
   else // problems elsewhere for other kinds
     TODO(loc, "intrinsic module procedure: ieee_is_finite");
   mlir::Value significand =
       builder.createIntegerConstant(loc, intType, significandBits);
   int exponentBits = floatBits - 1 - significandBits;
   mlir::Value maxExponent =
       builder.createIntegerConstant(loc, intType, (1 << exponentBits) - 1);
   mlir::Value exponent = genIbits(
       intType, {intVal, significand,
                 builder.createIntegerConstant(loc, intType, exponentBits)});

 // LEN_TRIM
 fir::ExtendedValue
 IntrinsicLibrary::genLenTrim(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);
   const fir::CharBoxValue *charBox = args[0].getCharBox();
   if (!charBox)
-    TODO(loc, "character array len_trim");
+    TODO(loc, "intrinsic: len_trim for character array");
   auto len =
       fir::factory::CharacterExprHelper(builder, loc).createLenTrim(*charBox);
   return builder.createConvert(loc, resultType, len);
 }
 
 // LGE, LGT, LLE, LLT
 template <mlir::arith::CmpIPredicate pred>
 fir::ExtendedValue
if (resultType.isa<mlir::IntegerType>()) {
     auto remPlusP =
         builder.create<mlir::arith::AddIOp>(loc, remainder, args[1]);
     return builder.create<mlir::arith::SelectOp>(loc, mustAddP, remPlusP,
                                                  remainder);
   }
   // Real case
   if (resultType == mlir::FloatType::getF128(builder.getContext()))
 
-    TODO(loc, "intrinsic: MODULO for floating point of KIND=16");
+    TODO(loc, "intrinsic: modulo for floating point of KIND=16");
   auto remainder = builder.create<mlir::arith::RemFOp>(loc, args[0], args[1]);
   mlir::Value zero = builder.createRealZeroConstant(loc, remainder.getType());
   auto remainderIsNotZero = builder.create<mlir::arith::CmpFOp>(
       loc, mlir::arith::CmpFPredicate::UNE, remainder, zero);
   auto aLessThanZero = builder.create<mlir::arith::CmpFOp>(
       loc, mlir::arith::CmpFPredicate::OLT, args[0], zero);
   auto pLessThanZero = builder.create<mlir::arith::CmpFOp>(
       loc, mlir::arith::CmpFPredicate::OLT, args[1], zero);
IntrinsicLibrary::genReshape(mlir::Type resultType,
   // Handle shape argument
   mlir::Value shape = builder.createBox(loc, args[1]);
   assert(fir::BoxValue(shape).rank() == 1);
   mlir::Type shapeTy = shape.getType();
   mlir::Type shapeArrTy = fir::dyn_cast_ptrOrBoxEleTy(shapeTy);
   auto resultRank = shapeArrTy.cast<fir::SequenceType>().getShape()[0];
 
   if (resultRank == fir::SequenceType::getUnknownExtent())
-    TODO(loc, "RESHAPE intrinsic requires computing rank of result");
+    TODO(loc, "intrinsic: reshape requires computing rank of result");
 
   // Handle optional pad argument
   mlir::Value pad = isStaticallyAbsent(args[2])
                         ? builder.create<fir::AbsentOp>(
                               loc, fir::BoxType::get(builder.getI1Type()))
                         : builder.createBox(loc, args[2]);
 
   // Handle optional order argument

 fir::ExtendedValue
 IntrinsicLibrary::genSize(mlir::Type resultType,
                           llvm::ArrayRef<fir::ExtendedValue> args) {
   // Note that the value of the KIND argument is already reflected in the
   // resultType
   assert(args.size() == 3);
   if (const auto *boxValue = args[0].getBoxOf<fir::BoxValue>())
     if (boxValue->hasAssumedRank())
-      TODO(loc, "SIZE intrinsic with assumed rank argument");
+      TODO(loc, "intrinsic: size with assumed rank argument");
 
   // Get the ARRAY argument
   mlir::Value array = builder.createBox(loc, args[0]);
 
   // The front-end rewrites SIZE without the DIM argument to
   // an array of SIZE with DIM in most cases, but it may not be
   // possible in some cases like when in SIZE(function_call()).
   if (isStaticallyAbsent(args, 1))

 // LBOUND
 fir::ExtendedValue
 IntrinsicLibrary::genLbound(mlir::Type resultType,
                             llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 2 || args.size() == 3);
   const fir::ExtendedValue &array = args[0];
   if (const auto *boxValue = array.getBoxOf<fir::BoxValue>())
     if (boxValue->hasAssumedRank())
-      TODO(loc, "LBOUND intrinsic with assumed rank argument");
+      TODO(loc, "intrinsic: lbound with assumed rank argument");
 
   //===----------------------------------------------------------------------===//
   mlir::Type indexType = builder.getIndexType();
 
   // Semantics builds signatures for LBOUND calls as either
   // LBOUND(array, dim, [kind]) or LBOUND(array, [kind]).
   if (args.size() == 2 || isStaticallyAbsent(args, 1)) {
     // DIM is absent.
if (fir::isa_real(type)) {
     }
   } else if (fir::isa_integer(type)) {
     result =
         builder.create<mlir::arith::CmpIOp>(loc, integerPredicate, left, right);
   } else if (fir::isa_char(type) || fir::isa_char(fir::unwrapRefType(type))) {
     // TODO: ! character min and max is tricky because the result
     // length is the length of the longest argument!
     // So we may need a temp.
-    TODO(loc, "CHARACTER min and max");
+    TODO(loc, "intrinsic: min and max for CHARACTER");
   }
   assert(result && "result must be defined");
   return result;
 }
 
 // UNPACK
 fir::ExtendedValue
 IntrinsicLibrary::genUnpack(mlir::Type resultType,