diff --git a/flang/include/flang/Evaluate/tools.h b/flang/include/flang/Evaluate/tools.h
--- a/flang/include/flang/Evaluate/tools.h
+++ b/flang/include/flang/Evaluate/tools.h
@@ -589,8 +589,9 @@
 
 // Given two expressions of arbitrary type, try to combine them with a
 // relational operator (e.g., .LT.), possibly with data type conversion.
-std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &,
-    RelationalOperator, Expr<SomeType> &&, Expr<SomeType> &&);
+std::optional<Expr<LogicalResult>> Relate(semantics::SemanticsContext &context,
+    parser::ContextualMessages &, RelationalOperator, Expr<SomeType> &&,
+    Expr<SomeType> &&);
 
 template <int K>
 Expr<Type<TypeCategory::Logical, K>> LogicalNegation(
@@ -864,7 +865,7 @@
 parser::Message *AttachDeclaration(parser::Message *, const Symbol &);
 template <typename MESSAGES, typename... A>
 parser::Message *SayWithDeclaration(
-    MESSAGES &messages, const Symbol &symbol, A &&... x) {
+    MESSAGES &messages, const Symbol &symbol, A &&...x) {
   return AttachDeclaration(messages.Say(std::forward<A>(x)...), symbol);
 }
 
diff --git a/flang/lib/Evaluate/tools.cpp b/flang/lib/Evaluate/tools.cpp
--- a/flang/lib/Evaluate/tools.cpp
+++ b/flang/lib/Evaluate/tools.cpp
@@ -476,92 +476,109 @@
       AsSameKindExprs(std::move(x), std::move(y)));
 }
 
-std::optional<Expr<LogicalResult>> Relate(parser::ContextualMessages &messages,
-    RelationalOperator opr, Expr<SomeType> &&x, Expr<SomeType> &&y) {
-  return std::visit(
-      common::visitors{
-          [=](Expr<SomeInteger> &&ix,
-              Expr<SomeInteger> &&iy) -> std::optional<Expr<LogicalResult>> {
-            return PromoteAndRelate(opr, std::move(ix), std::move(iy));
-          },
-          [=](Expr<SomeReal> &&rx,
-              Expr<SomeReal> &&ry) -> std::optional<Expr<LogicalResult>> {
-            return PromoteAndRelate(opr, std::move(rx), std::move(ry));
-          },
-          [&](Expr<SomeReal> &&rx, Expr<SomeInteger> &&iy) {
-            return Relate(messages, opr, std::move(x),
-                AsGenericExpr(ConvertTo(rx, std::move(iy))));
-          },
-          [&](Expr<SomeInteger> &&ix, Expr<SomeReal> &&ry) {
-            return Relate(messages, opr,
-                AsGenericExpr(ConvertTo(ry, std::move(ix))), std::move(y));
-          },
-          [&](Expr<SomeComplex> &&zx,
-              Expr<SomeComplex> &&zy) -> std::optional<Expr<LogicalResult>> {
-            if (opr != RelationalOperator::EQ &&
-                opr != RelationalOperator::NE) {
-              messages.Say(
-                  "COMPLEX data may be compared only for equality"_err_en_US);
-            } else {
-              auto rr{Relate(messages, opr,
-                  AsGenericExpr(GetComplexPart(zx, false)),
-                  AsGenericExpr(GetComplexPart(zy, false)))};
-              auto ri{
-                  Relate(messages, opr, AsGenericExpr(GetComplexPart(zx, true)),
-                      AsGenericExpr(GetComplexPart(zy, true)))};
-              if (auto parts{
-                      common::AllPresent(std::move(rr), std::move(ri))}) {
-                // (a,b)==(c,d) -> (a==c) .AND. (b==d)
-                // (a,b)/=(c,d) -> (a/=c) .OR. (b/=d)
-                LogicalOperator combine{opr == RelationalOperator::EQ
-                        ? LogicalOperator::And
-                        : LogicalOperator::Or};
-                return Expr<LogicalResult>{
-                    LogicalOperation<LogicalResult::kind>{combine,
-                        std::get<0>(std::move(*parts)),
-                        std::get<1>(std::move(*parts))}};
+std::optional<Expr<LogicalResult>> Relate(semantics::SemanticsContext &context,
+    parser::ContextualMessages &messages, RelationalOperator opr,
+    Expr<SomeType> &&x, Expr<SomeType> &&y) {
+  // Convert any BOZ literal operands to integers
+  if (auto *boz{std::get_if<BOZLiteralConstant>(&x.u)}) {
+    return Relate(context, messages, opr,
+        std::move(Expr<SomeType>{ConvertToKind<TypeCategory::Integer>(
+            context.GetDefaultKind(TypeCategory::Integer), std::move(*boz))}),
+        std::move(y));
+  } else if (auto *boz{std::get_if<BOZLiteralConstant>(&y.u)}) {
+    Expr<SomeType> yExpr{ConvertToKind<TypeCategory::Integer>(
+        context.GetDefaultKind(TypeCategory::Integer), std::move(*boz))};
+    return Relate(context, messages, opr, std::move(x),
+        std::move(Expr<SomeType>{ConvertToKind<TypeCategory::Integer>(
+            context.GetDefaultKind(TypeCategory::Integer), std::move(*boz))}));
+  } else {
+    return std::visit(
+        common::visitors{
+            [=](Expr<SomeInteger> &&ix,
+                Expr<SomeInteger> &&iy) -> std::optional<Expr<LogicalResult>> {
+              return PromoteAndRelate(opr, std::move(ix), std::move(iy));
+            },
+            [=](Expr<SomeReal> &&rx,
+                Expr<SomeReal> &&ry) -> std::optional<Expr<LogicalResult>> {
+              return PromoteAndRelate(opr, std::move(rx), std::move(ry));
+            },
+            [&](Expr<SomeReal> &&rx, Expr<SomeInteger> &&iy) {
+              return Relate(context, messages, opr, std::move(x),
+                  AsGenericExpr(ConvertTo(rx, std::move(iy))));
+            },
+            [&](Expr<SomeInteger> &&ix, Expr<SomeReal> &&ry) {
+              return Relate(context, messages, opr,
+                  AsGenericExpr(ConvertTo(ry, std::move(ix))), std::move(y));
+            },
+            [&](Expr<SomeComplex> &&zx,
+                Expr<SomeComplex> &&zy) -> std::optional<Expr<LogicalResult>> {
+              if (opr != RelationalOperator::EQ &&
+                  opr != RelationalOperator::NE) {
+                messages.Say(
+                    "COMPLEX data may be compared only for equality"_err_en_US);
+              } else {
+                auto rr{Relate(context, messages, opr,
+                    AsGenericExpr(GetComplexPart(zx, false)),
+                    AsGenericExpr(GetComplexPart(zy, false)))};
+                auto ri{Relate(context, messages, opr,
+                    AsGenericExpr(GetComplexPart(zx, true)),
+                    AsGenericExpr(GetComplexPart(zy, true)))};
+                if (auto parts{
+                        common::AllPresent(std::move(rr), std::move(ri))}) {
+                  // (a,b)==(c,d) -> (a==c) .AND. (b==d)
+                  // (a,b)/=(c,d) -> (a/=c) .OR. (b/=d)
+                  LogicalOperator combine{opr == RelationalOperator::EQ
+                          ? LogicalOperator::And
+                          : LogicalOperator::Or};
+                  return Expr<LogicalResult>{
+                      LogicalOperation<LogicalResult::kind>{combine,
+                          std::get<0>(std::move(*parts)),
+                          std::get<1>(std::move(*parts))}};
+                }
               }
-            }
-            return std::nullopt;
-          },
-          [&](Expr<SomeComplex> &&zx, Expr<SomeInteger> &&iy) {
-            return Relate(messages, opr, std::move(x),
-                AsGenericExpr(ConvertTo(zx, std::move(iy))));
-          },
-          [&](Expr<SomeComplex> &&zx, Expr<SomeReal> &&ry) {
-            return Relate(messages, opr, std::move(x),
-                AsGenericExpr(ConvertTo(zx, std::move(ry))));
-          },
-          [&](Expr<SomeInteger> &&ix, Expr<SomeComplex> &&zy) {
-            return Relate(messages, opr,
-                AsGenericExpr(ConvertTo(zy, std::move(ix))), std::move(y));
-          },
-          [&](Expr<SomeReal> &&rx, Expr<SomeComplex> &&zy) {
-            return Relate(messages, opr,
-                AsGenericExpr(ConvertTo(zy, std::move(rx))), std::move(y));
-          },
-          [&](Expr<SomeCharacter> &&cx, Expr<SomeCharacter> &&cy) {
-            return std::visit(
-                [&](auto &&cxk,
-                    auto &&cyk) -> std::optional<Expr<LogicalResult>> {
-                  using Ty = ResultType<decltype(cxk)>;
-                  if constexpr (std::is_same_v<Ty, ResultType<decltype(cyk)>>) {
-                    return PackageRelation(opr, std::move(cxk), std::move(cyk));
-                  } else {
-                    messages.Say(
-                        "CHARACTER operands do not have same KIND"_err_en_US);
-                    return std::nullopt;
-                  }
-                },
-                std::move(cx.u), std::move(cy.u));
-          },
-          // Default case
-          [&](auto &&, auto &&) {
-            DIE("invalid types for relational operator");
-            return std::optional<Expr<LogicalResult>>{};
-          },
-      },
-      std::move(x.u), std::move(y.u));
+              return std::nullopt;
+            },
+            [&](Expr<SomeComplex> &&zx, Expr<SomeInteger> &&iy) {
+              return Relate(context, messages, opr, std::move(x),
+                  AsGenericExpr(ConvertTo(zx, std::move(iy))));
+            },
+            [&](Expr<SomeComplex> &&zx, Expr<SomeReal> &&ry) {
+              return Relate(context, messages, opr, std::move(x),
+                  AsGenericExpr(ConvertTo(zx, std::move(ry))));
+            },
+            [&](Expr<SomeInteger> &&ix, Expr<SomeComplex> &&zy) {
+              return Relate(context, messages, opr,
+                  AsGenericExpr(ConvertTo(zy, std::move(ix))), std::move(y));
+            },
+            [&](Expr<SomeReal> &&rx, Expr<SomeComplex> &&zy) {
+              return Relate(context, messages, opr,
+                  AsGenericExpr(ConvertTo(zy, std::move(rx))), std::move(y));
+            },
+            [&](Expr<SomeCharacter> &&cx, Expr<SomeCharacter> &&cy) {
+              return std::visit(
+                  [&](auto &&cxk,
+                      auto &&cyk) -> std::optional<Expr<LogicalResult>> {
+                    using Ty = ResultType<decltype(cxk)>;
+                    if constexpr (std::is_same_v<Ty,
+                                      ResultType<decltype(cyk)>>) {
+                      return PackageRelation(
+                          opr, std::move(cxk), std::move(cyk));
+                    } else {
+                      messages.Say(
+                          "CHARACTER operands do not have same KIND"_err_en_US);
+                      return std::nullopt;
+                    }
+                  },
+                  std::move(cx.u), std::move(cy.u));
+            },
+            // Default case
+            [&](auto &&, auto &&) {
+              DIE("invalid types for relational operator");
+              return std::optional<Expr<LogicalResult>>{};
+            },
+        },
+        std::move(x.u), std::move(y.u));
+  }
 }
 
 Expr<SomeLogical> BinaryLogicalOperation(
@@ -597,8 +614,8 @@
   switch (type.category()) {
   case TypeCategory::Integer:
     if (auto *boz{std::get_if<BOZLiteralConstant>(&x.u)}) {
-      // Extension to C7109: allow BOZ literals to appear in integer contexts
-      // when the type is unambiguous.
+      // Extension to C7109: allow BOZ literals to appear in integer
+      // contexts when the type is unambiguous.
       return Expr<SomeType>{
           ConvertToKind<TypeCategory::Integer>(type.kind(), std::move(*boz))};
     }
diff --git a/flang/lib/Semantics/expression.cpp b/flang/lib/Semantics/expression.cpp
--- a/flang/lib/Semantics/expression.cpp
+++ b/flang/lib/Semantics/expression.cpp
@@ -2338,8 +2338,9 @@
   if (analyzer.fatalErrors()) {
     return std::nullopt;
   } else if (analyzer.IsIntrinsicRelational(opr)) {
-    return AsMaybeExpr(Relate(context.GetContextualMessages(), opr,
-        analyzer.MoveExpr(0), analyzer.MoveExpr(1)));
+    return AsMaybeExpr(
+        Relate(context.context(), context.GetContextualMessages(), opr,
+            analyzer.MoveExpr(0), analyzer.MoveExpr(1)));
   } else {
     return analyzer.TryDefinedOp(opr,
         "Operands of %s must have comparable types; have %s and %s"_err_en_US);
diff --git a/flang/test/Semantics/resolve63.f90 b/flang/test/Semantics/resolve63.f90
--- a/flang/test/Semantics/resolve63.f90
+++ b/flang/test/Semantics/resolve63.f90
@@ -44,10 +44,14 @@
   type(t) :: x, y
   real :: r
   logical :: l
+  integer :: iVar
 contains
   subroutine test_relational()
     l = x == y  !OK
     l = x .eq. y  !OK
+    l = x .eq. y  !OK
+    l = iVar == z'fe' !OK
+    l = z'fe' == iVar !OK
     !ERROR: No intrinsic or user-defined OPERATOR(==) matches operand types TYPE(t) and REAL(4)
     l = x == r
   end