[flang] Accept legacy aliases for intrinsic function names

[klausler]

Summary

Support the names AND, OR, and XOR for the generic intrinsic
functions IAND, IOR, and IEOR respectively.

flang/docs/Extensions.md

* Format expressions that have type but are not character and not
   This legacy extension supports pre-Fortran'77 usage in which
   variables initialized in DATA statements with Hollerith literals
   as modifiable formats.
 * At runtime, `NAMELIST` input will skip over `NAMELIST` groups
   with other names, and will treat text before and between groups
   as if they were comment lines, even if not begun with `!`.
 * Commas are required in FORMAT statements and character variables
   only when they prevent ambiguity.
+* Legacy names `AND`, `OR`, and `XOR` are accepted as aliases for
+  the standard intrinsic functions `IAND`, `IOR`, and `IEOR`
+  respectively.
 
 ### Extensions supported when enabled by options
 
 * C-style backslash escape sequences in quoted CHARACTER literals
   (but not Hollerith) [-fbackslash]
 * Logical abbreviations `.T.`, `.F.`, `.N.`, `.A.`, `.O.`, and `.X.`
   [-flogical-abbreviations]
 * `.XOR.` as a synonym for `.NEQV.` [-fxor-operator]

flang/lib/Evaluate/intrinsics.cpp

// NULL() is a special case handled in Probe() below
             {"field", SameType, Rank::conformable}},
         SameType, Rank::conformable, IntrinsicClass::transformationalFunction},
     {"verify",
         {{"string", SameChar}, {"set", SameChar},
             {"back", AnyLogical, Rank::elemental, Optionality::optional},
             DefaultingKIND},
         KINDInt},
     {"__builtin_ieee_is_nan", {{"a", AnyFloating}}, DefaultLogical},
-    {"__builtin_ieee_is_normal", {{"a", AnyFloating}}, DefaultLogical},
     {"__builtin_ieee_is_negative", {{"a", AnyFloating}}, DefaultLogical},
+    {"__builtin_ieee_is_normal", {{"a", AnyFloating}}, DefaultLogical},
     {"__builtin_ieee_next_after", {{"x", SameReal}, {"y", AnyReal}}, SameReal},
     {"__builtin_ieee_next_down", {{"x", SameReal}}, SameReal},
     {"__builtin_ieee_next_up", {{"x", SameReal}}, SameReal},
-    {"__builtin_ieee_selected_real_kind", // alias for selected_real_kind
-        {{"p", AnyInt, Rank::scalar},
-            {"r", AnyInt, Rank::scalar, Optionality::optional},
-            {"radix", AnyInt, Rank::scalar, Optionality::optional}},
-        DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"__builtin_ieee_support_datatype",
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
         DefaultLogical},
     {"__builtin_ieee_support_denormal",
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
         DefaultLogical},
     {"__builtin_ieee_support_divide",
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
// NULL() is a special case handled in Probe() below
         {{"x", AnyReal, Rank::elemental, Optionality::optional}},
         DefaultLogical},
 };
 
 // TODO: Coarray intrinsic functions
 //   LCOBOUND, UCOBOUND, FAILED_IMAGES, IMAGE_INDEX,
 //   STOPPED_IMAGES, COSHAPE
 // TODO: Non-standard intrinsic functions
-//  AND, OR, XOR, LSHIFT, RSHIFT, SHIFT, ZEXT, IZEXT,
+//  LSHIFT, RSHIFT, SHIFT, ZEXT, IZEXT,
 //  COMPL, EQV, NEQV, INT8, JINT, JNINT, KNINT,
 //  QCMPLX, QEXT, QFLOAT, QREAL, DNUM,
 //  INUM, JNUM, KNUM, QNUM, RNUM, RAN, RANF, ILEN,
 //  MCLOCK, SECNDS, COTAN, IBCHNG, ISHA, ISHC, ISHL, IXOR
 //  IARG, IARGC, NARGS, NUMARG, BADDRESS, IADDR, CACHESIZE,
 //  EOF, FP_CLASS, INT_PTR_KIND, MALLOC
 //  probably more (these are PGI + Intel, possibly incomplete)
 // TODO: Optionally warn on use of non-standard intrinsics:
 //  LOC, probably others
 // TODO: Optionally warn on operand promotion extension
 
+// Aliases for a few generic intrinsic functions for legacy
+// compatibility and builtins.
+static const std::pair<const char *, const char *> genericAlias[]{
+    {"and", "iand"},
+    {"or", "ior"},
+    {"xor", "ieor"},
+    {"__builtin_ieee_selected_real_kind", "selected_real_kind"},
+};
+
 // The following table contains the intrinsic functions listed in
 // Tables 16.2 and 16.3 in Fortran 2018.  The "unrestricted" functions
 // in Table 16.2 can be used as actual arguments, PROCEDURE() interfaces,
 // and procedure pointer targets.
 // Note that the restricted conversion functions dcmplx, dreal, float, idint,
 // ifix, and sngl are extended to accept any argument kind because this is a
 // common Fortran compilers behavior, and as far as we can tell, is safe and
 // useful.

 
 class IntrinsicProcTable::Implementation {
 public:
   explicit Implementation(const common::IntrinsicTypeDefaultKinds &dfts)
       : defaults_{dfts} {
     for (const IntrinsicInterface &f : genericIntrinsicFunction) {
       genericFuncs_.insert(std::make_pair(std::string{f.name}, &f));
     }
+    for (const std::pair<const char *, const char *> &a : genericAlias) {
+      aliases_.insert(
+          std::make_pair(std::string{a.first}, std::string{a.second}));
+    }
     for (const SpecificIntrinsicInterface &f : specificIntrinsicFunction) {
       specificFuncs_.insert(std::make_pair(std::string{f.name}, &f));
     }
     for (const IntrinsicInterface &f : intrinsicSubroutine) {
       subroutines_.insert(std::make_pair(std::string{f.name}, &f));
     }
   }
 
public:
 
   llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
 
 private:
   DynamicType GetSpecificType(const TypePattern &) const;
   SpecificCall HandleNull(ActualArguments &, FoldingContext &) const;
   std::optional<SpecificCall> HandleC_F_Pointer(
       ActualArguments &, FoldingContext &) const;
+  const std::string &ResolveAlias(const std::string &name) const {
+    auto iter{aliases_.find(name)};
+    return iter == aliases_.end() ? name : iter->second;
+  }
 
   common::IntrinsicTypeDefaultKinds defaults_;
   std::multimap<std::string, const IntrinsicInterface *> genericFuncs_;
   std::multimap<std::string, const SpecificIntrinsicInterface *> specificFuncs_;
   std::multimap<std::string, const IntrinsicInterface *> subroutines_;
   const semantics::Scope *builtinsScope_{nullptr};
+  std::map<std::string, std::string> aliases_;
 };
 
 bool IntrinsicProcTable::Implementation::IsIntrinsicFunction(
-    const std::string &name) const {
+    const std::string &name0) const {
+  const std::string &name{ResolveAlias(name0)};
   auto specificRange{specificFuncs_.equal_range(name)};
   if (specificRange.first != specificRange.second) {
     return true;
   }
   auto genericRange{genericFuncs_.equal_range(name)};
   if (genericRange.first != genericRange.second) {
     return true;
   }
auto matchOrBufferMessages{
         } else if (buffer.empty()) {
           buffer.Annex(std::move(localBuffer));
         } else {
           localBuffer.clear();
         }
         return std::nullopt;
       }};
 
-  // Probe the generic intrinsic function table first.
+  // Probe the generic intrinsic function table first; allow for
+  // the use of a legacy alias.
   parser::Messages genericBuffer;
-  auto genericRange{genericFuncs_.equal_range(call.name)};
+  const std::string &name{ResolveAlias(call.name)};
+  auto genericRange{genericFuncs_.equal_range(name)};
   for (auto iter{genericRange.first}; iter != genericRange.second; ++iter) {
     if (auto specificCall{
             matchOrBufferMessages(*iter->second, genericBuffer)}) {
       ApplySpecificChecks(*specificCall, context);
       return specificCall;
     }
   }
 

flang/test/Semantics/boz-literal-constants.f90

subroutine bozchecks
   !ERROR: Invalid digit ('a') in BOZ literal 'o"a"'
   integer :: d = O"A"
 
   ! C7109
   !    A) can appear only in data statement
   !    B) Argument to intrinsics listed from 16.9 below
   !       BGE, BGT, BLE, BLT, CMPLX, DBLE, DSHIFTL,
   !       DSHIFTR, IAND, IEOR, INT, IOR, MERGE_BITS, REAL
+  !       and legacy aliases AND, OR, XOR
 
   ! part A
   data f / Z"AA" / ! OK
   !ERROR: DATA statement value could not be converted to the type 'COMPLEX(4)' of the object 'rescmplx'
   data rescmplx / B"010101" /
   ! part B
   resbit = BGE(B"0101", B"1111")
   resbit = BGT(Z"0101", B"1111")
subroutine bozchecks
   !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
   dbl = DSHIFTR(B"1010",B"1010",2)
   dbl = DSHIFTL(B"0101",5,2) ! OK
   dbl = DSHIFTR(B"1010",5,2) ! OK
 
   !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
   resint = IAND(B"0001", B"0011")
   resint = IAND(B"0001", 3)
+  !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
+  resint = AND(B"0001", B"0011")
+  resint = AND(B"0001", 3)
 
   !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
   resint = IEOR(B"0001", B"0011")
   resint = IEOR(B"0001", 3)
+  !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
+  resint = XOR(B"0001", B"0011")
+  resint = XOR(B"0001", 3)
 
   resint = INT(B"1010")
 
   !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
   res = IOR(B"0101", B"0011")
   res = IOR(B"0101", 3)
+  !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
+  res = OR(B"0101", B"0011")
+  res = OR(B"0101", 3)
 
   res = MERGE_BITS(13,3,11)
   res = MERGE_BITS(B"1101",3,11)
   !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
   res = MERGE_BITS(B"1101",B"0011",11)
   !ERROR: Typeless (BOZ) not allowed for both 'i=' & 'j=' arguments
   res = MERGE_BITS(B"1101",B"0011",B"1011")
   res = MERGE_BITS(B"1101",3,B"1011")