diff --git a/_typos.toml b/_typos.toml
index ea8855283c486..398fe1704181a 100644
--- a/_typos.toml
+++ b/_typos.toml
@@ -133,7 +133,4 @@ suppport = 'suppport'
 SWTICH = 'SWTICH'
 Swith = 'Swith'
 sysyem = 'sysyem'
-unsupport = 'unsupport'
-upsupported = 'upsupported'
-Unsupport = 'Unsupport'
 UNSUPPORT = 'UNSUPPORT'
diff --git a/cmake/operators.cmake b/cmake/operators.cmake
index 07c5c91afe817..3fe84a66287d2 100644
--- a/cmake/operators.cmake
+++ b/cmake/operators.cmake
@@ -311,8 +311,8 @@ function(op_library TARGET)
   endif()
   if(WIN32)
     # remove windows unsupported op, because windows has no nccl, no warpctc such ops.
-    foreach(windows_unsupport_op "nccl_op" "gen_nccl_id_op")
-      if("${TARGET}" STREQUAL "${windows_unsupport_op}")
+    foreach(windows_unsupported_op "nccl_op" "gen_nccl_id_op")
+      if("${TARGET}" STREQUAL "${windows_unsupported_op}")
         return()
       endif()
     endforeach()
diff --git a/paddle/cinn/hlir/op/custom_call.cc b/paddle/cinn/hlir/op/custom_call.cc
index 9125b185cba95..11b0095541b24 100644
--- a/paddle/cinn/hlir/op/custom_call.cc
+++ b/paddle/cinn/hlir/op/custom_call.cc
@@ -1209,7 +1209,7 @@ std::vector<ir::Expr> CustomCallArgsForMemset(
     void operator()(int64_t v) { *scalar_ = static_cast<int>(v); }
     void operator()(bool v) { *scalar_ = v ? 0xFFFFFFFF : 0; }
 
-#define EXPAND_MEMSET_TYPE_UNSUPPORT(TYPE)                            \
+#define EXPAND_MEMSET_TYPE_UNSUPPORTED(TYPE)                          \
   void operator()(const TYPE &) {                                     \
     std::stringstream ss;                                             \
     ss << "The type of \"value\" of memset custom_call not support: " \
@@ -1217,16 +1217,16 @@ std::vector<ir::Expr> CustomCallArgsForMemset(
     PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));        \
   }
 
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::string)
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::vector<int>)
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::vector<int64_t>)
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::vector<float>)
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::vector<double>)
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::vector<bool>)
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::vector<std::string>)
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::vector<symbol::DimExpr>)
-    EXPAND_MEMSET_TYPE_UNSUPPORT(std::vector<cinn::dialect::SymbolBinding>)
-#undef EXPAND_MEMSET_TYPE_UNSUPPORT
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::string)
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::vector<int>)
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::vector<int64_t>)
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::vector<float>)
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::vector<double>)
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::vector<bool>)
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::vector<std::string>)
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::vector<symbol::DimExpr>)
+    EXPAND_MEMSET_TYPE_UNSUPPORTED(std::vector<cinn::dialect::SymbolBinding>)
+#undef EXPAND_MEMSET_TYPE_UNSUPPORTED
   };
 
   int value = 0;
diff --git a/paddle/cinn/ir/op/ir_operators.cc b/paddle/cinn/ir/op/ir_operators.cc
index c16ebd6536992..1cef32c2c31f0 100644
--- a/paddle/cinn/ir/op/ir_operators.cc
+++ b/paddle/cinn/ir/op/ir_operators.cc
@@ -96,7 +96,7 @@ Expr BitwiseOrCallImpl(common::UnknownArch,
                        Expr a,
                        Expr b) {
   std::stringstream ss;
-  ss << "Unsupport arch: " << target.arch_str() << " for bitwise_or.";
+  ss << "Unsupported arch: " << target.arch_str() << " for bitwise_or.";
   PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));
 }
 
@@ -106,7 +106,7 @@ Expr BitwiseOrCallImpl(common::X86Arch, const Target &target, Expr a, Expr b) {
 
 Expr BitwiseOrCallImpl(common::ARMArch, const Target &target, Expr a, Expr b) {
   std::stringstream ss;
-  ss << "Unsupport arch: " << target.arch_str() << " for bitwise_or.";
+  ss << "Unsupported arch: " << target.arch_str() << " for bitwise_or.";
   PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));
 }
 
@@ -170,7 +170,7 @@ Expr BitwiseAndCallImpl(common::UnknownArch,
                         Expr a,
                         Expr b) {
   std::stringstream ss;
-  ss << "Unsupport arch: " << target.arch_str() << " for bitwise_and.";
+  ss << "Unsupported arch: " << target.arch_str() << " for bitwise_and.";
   PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));
 }
 
@@ -180,7 +180,7 @@ Expr BitwiseAndCallImpl(common::X86Arch, const Target &target, Expr a, Expr b) {
 
 Expr BitwiseAndCallImpl(common::ARMArch, const Target &target, Expr a, Expr b) {
   std::stringstream ss;
-  ss << "Unsupport arch: " << target.arch_str() << " for bitwise_and.";
+  ss << "Unsupported arch: " << target.arch_str() << " for bitwise_and.";
   PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));
 }
 
@@ -244,7 +244,7 @@ Expr BitwiseXorCallImpl(common::UnknownArch,
                         Expr a,
                         Expr b) {
   std::stringstream ss;
-  ss << "Unsupport arch: " << target.arch_str() << " for bitwise_xor.";
+  ss << "Unsupported arch: " << target.arch_str() << " for bitwise_xor.";
   PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));
 }
 
@@ -254,7 +254,7 @@ Expr BitwiseXorCallImpl(common::X86Arch, const Target &target, Expr a, Expr b) {
 
 Expr BitwiseXorCallImpl(common::ARMArch, const Target &target, Expr a, Expr b) {
   std::stringstream ss;
-  ss << "Unsupport arch: " << target.arch_str() << " for bitwise_xor.";
+  ss << "Unsupported arch: " << target.arch_str() << " for bitwise_xor.";
   PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));
 }
 
@@ -315,7 +315,7 @@ Expr operator^(Expr a, Expr b) {
 
 Expr BitwiseNotCallImpl(common::UnknownArch, const Target &target, Expr a) {
   std::stringstream ss;
-  ss << "Unsupport arch: " << target.arch_str() << " for bitwise_not.";
+  ss << "Unsupported arch: " << target.arch_str() << " for bitwise_not.";
   PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));
 }
 
@@ -325,7 +325,7 @@ Expr BitwiseNotCallImpl(common::X86Arch, const Target &target, Expr a) {
 
 Expr BitwiseNotCallImpl(common::ARMArch, const Target &target, Expr a) {
   std::stringstream ss;
-  ss << "Unsupport arch: " << target.arch_str() << " for bitwise_not.";
+  ss << "Unsupported arch: " << target.arch_str() << " for bitwise_not.";
   PADDLE_THROW(::common::errors::InvalidArgument(ss.str()));
 }
 
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index baf3225b91632..ae29dea8b6f29 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -32,7 +32,7 @@ enum class PatternType {
   ReduceTreePlusTrivial,
   ItersPermutation,
   Horizontal,
-  Unsupport = -1,
+  Unsupported = -1,
 };
 
 struct PatternContent {
@@ -216,11 +216,11 @@ struct HorizontalFusionPattern : public PatternBase {
   void update_tracker() const;
 };
 
-struct UnsupportPattern : public PatternBase {
-  explicit UnsupportPattern(const std::vector<pir::Operation*>& ops,
-                            const FusionTrackerPtr& tracker)
+struct UnsupportedPattern : public PatternBase {
+  explicit UnsupportedPattern(const std::vector<pir::Operation*>& ops,
+                              const FusionTrackerPtr& tracker)
       : PatternBase(UniqueId(), tracker, ops) {}
-  DEFINE_PATTERN_STATIC_ATTR(Unsupport);
+  DEFINE_PATTERN_STATIC_ATTR(Unsupported);
 };
 
 using StmtPattern = std::variant<TrivialPattern,
@@ -228,7 +228,7 @@ using StmtPattern = std::variant<TrivialPattern,
                                  ReduceTreePattern,
                                  ReduceTreePlusTrivialPattern,
                                  HorizontalFusionPattern,
-                                 UnsupportPattern,
+                                 UnsupportedPattern,
                                  ItersPermutationPattern>;
 
 static std::string GetPatternId(const StmtPattern& s);
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 532d7fd61d503..3717b8ff1bcfc 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -54,9 +54,9 @@ static StmtPattern ConvertToStmtPattern(const PatternContent& content) {
     return result;
   } else {
     PADDLE_THROW(::common::errors::InvalidArgument(
-        "Unsupport op for fusion: %s", OpsDebugStr({content.op})));
+        "Unsupported op for fusion: %s", OpsDebugStr({content.op})));
     auto result =
-        UnsupportPattern({content.op}, std::make_shared<FusionTracker>());
+        UnsupportedPattern({content.op}, std::make_shared<FusionTracker>());
     result.tracker_->append(
         std::make_shared<InitPatternInstr>(content.op, result.id()));
     return result;
@@ -186,9 +186,9 @@ static std::vector<pir::Operation*> GetOutputOpsInPattern(
     std::vector<pir::Operation*> operator()(const TrivialPattern& pattern) {
       return {pattern.sink_op()};
     }
-    std::vector<pir::Operation*> operator()(const UnsupportPattern& pattern) {
+    std::vector<pir::Operation*> operator()(const UnsupportedPattern& pattern) {
       PADDLE_THROW(::common::errors::Unimplemented(
-          "Get output ops in UnsupportPattern is not implement!"));
+          "Get output ops in UnsupportedPattern is not implement!"));
     }
     std::vector<pir::Operation*> operator()(const ReduceTreePattern& pattern) {
       return this->operator()(pattern.GetRootPattern());
@@ -304,7 +304,7 @@ struct LoopValueDimsVisitor {
     return res;
   }
 
-  std::vector<LoopValueDims> operator()(const UnsupportPattern& pattern) {
+  std::vector<LoopValueDims> operator()(const UnsupportedPattern& pattern) {
     PADDLE_ENFORCE(false, "Not support GetLoopRange.");
   }
 
@@ -465,9 +465,9 @@ struct LoopFrameworkVisitor {
             CreateIsReduceVector(trivial_loop.size(), reduce_loop.size())};
   }
 
-  MaybeLoopFramework operator()(const UnsupportPattern& pattern) {
+  MaybeLoopFramework operator()(const UnsupportedPattern& pattern) {
     PADDLE_THROW(
-        ::common::errors::Unimplemented("Unsupport for GetLoopRange."));
+        ::common::errors::Unimplemented("Unsupported for GetLoopRange."));
   }
 
   MaybeLoopFramework operator()(const ItersPermutationPattern& pattern) {
diff --git a/paddle/cinn/utils/profiler.cc b/paddle/cinn/utils/profiler.cc
index 0715963770542..bc18680982aab 100644
--- a/paddle/cinn/utils/profiler.cc
+++ b/paddle/cinn/utils/profiler.cc
@@ -51,7 +51,7 @@ void ProfilerHelper::UpdateState() {
       g_state = ProfilerState::kAll;
       break;
     default:
-      LOG(WARNING) << "Unsupport FLAGS_cinn_profiler_state = "
+      LOG(WARNING) << "Unsupported FLAGS_cinn_profiler_state = "
                    << FLAGS_cinn_profiler_state << ", and will do nothing.";
   }
 }
diff --git a/paddle/fluid/framework/fleet/box_wrapper.cc b/paddle/fluid/framework/fleet/box_wrapper.cc
index 49f92d655006f..307df1d5c78ae 100644
--- a/paddle/fluid/framework/fleet/box_wrapper.cc
+++ b/paddle/fluid/framework/fleet/box_wrapper.cc
@@ -83,15 +83,15 @@ void BoxWrapper::PullSparse(const phi::Place& place,
                             const std::vector<int64_t>& slot_lengths,
                             const int hidden_size,
                             const int expand_embed_dim) {
-#define EMBEDX_CASE(i, ...)                                                  \
-  case i: {                                                                  \
-    constexpr size_t EmbedxDim = i;                                          \
-    switch (expand_embed_dim) {                                              \
-      __VA_ARGS__                                                            \
-      default:                                                               \
-        PADDLE_THROW(common::errors::InvalidArgument(                        \
-            "Unsupport this expand embedding size [%d]", expand_embed_dim)); \
-    }                                                                        \
+#define EMBEDX_CASE(i, ...)                                                    \
+  case i: {                                                                    \
+    constexpr size_t EmbedxDim = i;                                            \
+    switch (expand_embed_dim) {                                                \
+      __VA_ARGS__                                                              \
+      default:                                                                 \
+        PADDLE_THROW(common::errors::InvalidArgument(                          \
+            "Unsupported this expand embedding size [%d]", expand_embed_dim)); \
+    }                                                                          \
   } break
 
 #define PULLSPARSE_CASE(i, ...)                                            \
@@ -108,7 +108,7 @@ void BoxWrapper::PullSparse(const phi::Place& place,
     EMBEDX_CASE(16, PULLSPARSE_CASE(0););
     default:
       PADDLE_THROW(common::errors::InvalidArgument(
-          "Unsupport this embedding size [%d]", hidden_size - 3));
+          "Unsupported this embedding size [%d]", hidden_size - 3));
   }
 #undef PULLSPARSE_CASE
 #undef EMBEDX_CASE
@@ -121,15 +121,15 @@ void BoxWrapper::PushSparseGrad(const phi::Place& place,
                                 const int hidden_size,
                                 const int expand_embed_dim,
                                 const int batch_size) {
-#define EMBEDX_CASE(i, ...)                                                  \
-  case i: {                                                                  \
-    constexpr size_t EmbedxDim = i;                                          \
-    switch (expand_embed_dim) {                                              \
-      __VA_ARGS__                                                            \
-      default:                                                               \
-        PADDLE_THROW(common::errors::InvalidArgument(                        \
-            "Unsupport this expand embedding size [%d]", expand_embed_dim)); \
-    }                                                                        \
+#define EMBEDX_CASE(i, ...)                                                    \
+  case i: {                                                                    \
+    constexpr size_t EmbedxDim = i;                                            \
+    switch (expand_embed_dim) {                                                \
+      __VA_ARGS__                                                              \
+      default:                                                                 \
+        PADDLE_THROW(common::errors::InvalidArgument(                          \
+            "Unsupported this expand embedding size [%d]", expand_embed_dim)); \
+    }                                                                          \
   } break
 
 #define PUSHSPARSE_CASE(i, ...)                                \
@@ -151,7 +151,7 @@ void BoxWrapper::PushSparseGrad(const phi::Place& place,
     EMBEDX_CASE(16, PUSHSPARSE_CASE(0););
     default:
       PADDLE_THROW(common::errors::InvalidArgument(
-          "Unsupport this embedding size [%d]", hidden_size - 3));
+          "Unsupported this embedding size [%d]", hidden_size - 3));
   }
 #undef PUSHSPARSE_CASE
 #undef EMBEDX_CASE
diff --git a/paddle/fluid/framework/fleet/box_wrapper.cu b/paddle/fluid/framework/fleet/box_wrapper.cu
index 39bbd9de6c99e..12f22ec9d76d4 100644
--- a/paddle/fluid/framework/fleet/box_wrapper.cu
+++ b/paddle/fluid/framework/fleet/box_wrapper.cu
@@ -167,15 +167,15 @@ void BoxWrapper::CopyForPull(const phi::Place& place,
              values.size() * sizeof(float*),
              cudaMemcpyHostToDevice);
 #endif
-#define EMBEDX_CASE(i, ...)                                                  \
-  case i: {                                                                  \
-    constexpr size_t EmbedxDim = i;                                          \
-    switch (expand_embed_dim) {                                              \
-      __VA_ARGS__                                                            \
-      default:                                                               \
-        PADDLE_THROW(common::errors::InvalidArgument(                        \
-            "Unsupport this expand embedding size [%d]", expand_embed_dim)); \
-    }                                                                        \
+#define EMBEDX_CASE(i, ...)                                                    \
+  case i: {                                                                    \
+    constexpr size_t EmbedxDim = i;                                            \
+    switch (expand_embed_dim) {                                                \
+      __VA_ARGS__                                                              \
+      default:                                                                 \
+        PADDLE_THROW(common::errors::InvalidArgument(                          \
+            "Unsupported this expand embedding size [%d]", expand_embed_dim)); \
+    }                                                                          \
   } break
 
 #ifdef PADDLE_WITH_HIP
@@ -222,7 +222,7 @@ void BoxWrapper::CopyForPull(const phi::Place& place,
     EMBEDX_CASE(16, EXPAND_EMBED_PULL_CASE(0););
     default:
       PADDLE_THROW(common::errors::InvalidArgument(
-          "Unsupport this embedding size [%d]", hidden_size - 3));
+          "Unsupported this embedding size [%d]", hidden_size - 3));
   }
   cudaStreamSynchronize(stream);
 #undef EXPAND_EMBED_PULL_CASE
@@ -310,15 +310,15 @@ void BoxWrapper::CopyForPush(const phi::Place& place,
              cudaMemcpyHostToDevice);
 #endif
 
-#define EMBEDX_CASE(i, ...)                                                  \
-  case i: {                                                                  \
-    constexpr size_t EmbedxDim = i;                                          \
-    switch (expand_embed_dim) {                                              \
-      __VA_ARGS__                                                            \
-      default:                                                               \
-        PADDLE_THROW(common::errors::InvalidArgument(                        \
-            "Unsupport this expand embedding size [%d]", expand_embed_dim)); \
-    }                                                                        \
+#define EMBEDX_CASE(i, ...)                                                    \
+  case i: {                                                                    \
+    constexpr size_t EmbedxDim = i;                                            \
+    switch (expand_embed_dim) {                                                \
+      __VA_ARGS__                                                              \
+      default:                                                                 \
+        PADDLE_THROW(common::errors::InvalidArgument(                          \
+            "Unsupported this expand embedding size [%d]", expand_embed_dim)); \
+    }                                                                          \
   } break
 
 #ifdef PADDLE_WITH_HIP
@@ -357,7 +357,7 @@ void BoxWrapper::CopyForPush(const phi::Place& place,
     EMBEDX_CASE(16, EXPAND_EMBED_PUSH_CASE(0););
     default:
       PADDLE_THROW(common::errors::InvalidArgument(
-          "Unsupport this embedding size [%d]", hidden_size - 3));
+          "Unsupported this embedding size [%d]", hidden_size - 3));
   }
 
   cudaStreamSynchronize(stream);
diff --git a/paddle/fluid/framework/io/fs.cc b/paddle/fluid/framework/io/fs.cc
index d12aa4e811475..ca12a20965e82 100644
--- a/paddle/fluid/framework/io/fs.cc
+++ b/paddle/fluid/framework/io/fs.cc
@@ -425,7 +425,7 @@ std::shared_ptr<FILE> fs_open_read(const std::string& path,
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system and "
+          "Unsupported file system. Now only supports local file system and "
           "HDFS."));
   }
 
@@ -444,7 +444,7 @@ std::shared_ptr<FILE> fs_open_write(const std::string& path,
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system and "
+          "Unsupported file system. Now only supports local file system and "
           "HDFS."));
   }
 
@@ -463,7 +463,7 @@ std::shared_ptr<FILE> fs_open_append_write(const std::string& path,
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system and "
+          "Unsupported file system. Now only supports local file system and "
           "HDFS."));
   }
 
@@ -483,7 +483,7 @@ std::shared_ptr<FILE> fs_open(const std::string& path,
   }
 
   PADDLE_THROW(common::errors::Unavailable(
-      "Unsupport file open mode: %s. Only supports 'r', 'rb', 'w' or 'wb'.",
+      "Unsupported file open mode: %s. Only supports 'r', 'rb', 'w' or 'wb'.",
       mode));
   return {};
 }
@@ -495,7 +495,7 @@ int64_t fs_file_size(const std::string& path) {
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system."));
+          "Unsupported file system. Now only supports local file system."));
   }
 
   return 0;
@@ -511,7 +511,7 @@ void fs_remove(const std::string& path) {
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system and "
+          "Unsupported file system. Now only supports local file system and "
           "HDFS."));
   }
 }
@@ -526,7 +526,7 @@ std::vector<std::string> fs_list(const std::string& path) {
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system and "
+          "Unsupported file system. Now only supports local file system and "
           "HDFS."));
   }
 
@@ -543,7 +543,7 @@ std::string fs_tail(const std::string& path) {
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system and "
+          "Unsupported file system. Now only supports local file system and "
           "HDFS."));
   }
 
@@ -560,7 +560,7 @@ bool fs_exists(const std::string& path) {
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system and "
+          "Unsupported file system. Now only supports local file system and "
           "HDFS."));
   }
 
@@ -577,7 +577,7 @@ void fs_mkdir(const std::string& path) {
 
     default:
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport file system. Now only supports local file system and "
+          "Unsupported file system. Now only supports local file system and "
           "HDFS."));
   }
 }
diff --git a/paddle/fluid/framework/ir/coalesce_grad_tensor_pass.cc b/paddle/fluid/framework/ir/coalesce_grad_tensor_pass.cc
index dc8da2e2d0b4f..84d1474477e40 100644
--- a/paddle/fluid/framework/ir/coalesce_grad_tensor_pass.cc
+++ b/paddle/fluid/framework/ir/coalesce_grad_tensor_pass.cc
@@ -230,7 +230,7 @@ class CoalesceGradTensorPass : public ir::Pass {
     // params_grads.begin()->second.
     auto fused_grad_var_name = std::string(details::kFusedVarNamePrefix) +
                                "@GRAD@" + params_grads.begin()->second;
-    // what a pity, visual c++ unsupport {.type_ = type}
+    // what a pity, visual c++ unsupported {.type_ = type}
     details::VariableInfo var_info;
     var_info.name_ = fused_grad_var_name;
     var_info.type_ = type;
diff --git a/paddle/fluid/framework/ir/quant_linear_fuse_pass.cc b/paddle/fluid/framework/ir/quant_linear_fuse_pass.cc
index 8d2e466d68b9b..0963ec1a24073 100644
--- a/paddle/fluid/framework/ir/quant_linear_fuse_pass.cc
+++ b/paddle/fluid/framework/ir/quant_linear_fuse_pass.cc
@@ -209,7 +209,7 @@ int QuantLinearFusePass::ApplyQuantLinearFusePattern(Graph* graph,
       input_scale = static_cast<float>(input_scale_data[0]);
     } else {
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport type. The type of 'Scale' in quantize_linear op is "
+          "Unsupported type. The type of 'Scale' in quantize_linear op is "
           "expected to be float32 or float16, but the current type is %d",
           input_scale_tensor.dtype()));
     }
diff --git a/paddle/fluid/framework/operator.cc b/paddle/fluid/framework/operator.cc
index 539a425e9d156..71ede3b01f11c 100644
--- a/paddle/fluid/framework/operator.cc
+++ b/paddle/fluid/framework/operator.cc
@@ -1924,7 +1924,7 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
 // If not, use the kernel registered in fluid. And if the fluid do not
 // contains the related heterogeneous kernel, use phi CPU kernel.
 #if defined(PADDLE_WITH_XPU)
-    bool is_xpu_unsupport =
+    bool is_xpu_unsupported =
         phi::is_xpu_place(kernel_type_->place_) &&
         !paddle::platform::is_xpu_support_op(
             type_, phi::TransToPhiDataType(kernel_type_->data_type_));
@@ -1947,10 +1947,10 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
 #endif
     if (phi_kernel_->IsValid() && !in_custom_back_list
 #if defined(PADDLE_WITH_XPU) && !defined(PADDLE_WITH_XPU_KP)
-        && !is_xpu_unsupport
+        && !is_xpu_unsupported
 #endif
 #if defined(PADDLE_WITH_XPU_KP)
-        && (!is_xpu_unsupport || use_phi_xpu_kp)
+        && (!is_xpu_unsupported || use_phi_xpu_kp)
 #endif
     ) {
       run_phi_kernel_ = true;
@@ -1970,10 +1970,10 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
           kernels_iter->second.find(*kernel_type_.get()) ==
               kernels_iter->second.end()
 #if defined(PADDLE_WITH_XPU) && !defined(PADDLE_WITH_XPU_KP)
-          || is_xpu_unsupport
+          || is_xpu_unsupported
 #endif
 #if defined(PADDLE_WITH_XPU_KP)
-          || (is_xpu_unsupport && !is_xpu_kp_support)
+          || (is_xpu_unsupported && !is_xpu_kp_support)
 #endif
 #if defined(PADDLE_WITH_CUSTOM_DEVICE)
           || in_custom_back_list
@@ -2403,10 +2403,10 @@ void OperatorWithKernel::ChooseKernel(const ExecutionContext& ctx) const {
                 << ", using_kernel_key:" << expected_kernel_key;
       }
     }
-    bool is_xpu_unsupport = (!paddle::platform::is_xpu_support_op(
+    bool is_xpu_unsupported = (!paddle::platform::is_xpu_support_op(
         type_, phi::TransToPhiDataType(expected_kernel_key.data_type_)));
     if (!is_xpu_kp_support &&
-        (kernel_iter == kernels.end() || is_xpu_unsupport)) {
+        (kernel_iter == kernels.end() || is_xpu_unsupported)) {
       VLOG(3) << "fluid missing XPU kernel: " << type_
               << ", expected_kernel_key:" << expected_kernel_key
               << ", fallbacking to CPU one!";
diff --git a/paddle/fluid/framework/phi_utils.cc b/paddle/fluid/framework/phi_utils.cc
index bbdde2dc9a396..e30afd8b0f5b9 100644
--- a/paddle/fluid/framework/phi_utils.cc
+++ b/paddle/fluid/framework/phi_utils.cc
@@ -284,7 +284,7 @@ phi::Scalar MakePhiScalarFromVar(const framework::Variable& variable) {
     }
   } else {
     PADDLE_THROW(common::errors::Unimplemented(
-        "Unsupport casting input `%s` type to Scalar when call pt "
+        "Unsupported casting input `%s` type to Scalar when call pt "
         "kernel.",
         framework::ToTypeName(variable.Type())));
   }
@@ -296,7 +296,7 @@ phi::IntArray MakePhiIntArrayFromVar(const framework::Variable& variable) {
     return phi::IntArray(tensor);
   } else {
     PADDLE_THROW(common::errors::Unimplemented(
-        "Unsupport casting input `%s` type to IntArray when call pt "
+        "Unsupported casting input `%s` type to IntArray when call pt "
         "kernel.",
         framework::ToTypeName(variable.Type())));
   }
@@ -347,7 +347,7 @@ phi::IntArray MakePhiIntArrayFromVarList(
       }
     } else {
       PADDLE_THROW(common::errors::Unimplemented(
-          "Unsupport casting input `%s` type to VectorTensor when call pt "
+          "Unsupported casting input `%s` type to VectorTensor when call pt "
           "kernel.",
           framework::ToTypeName(var->Type())));
     }
diff --git a/test/collective/fleet/test_imperative_auto_mixed_precision_for_eager.py b/test/collective/fleet/test_imperative_auto_mixed_precision_for_eager.py
index 21b3f6d62d693..fa957c247d37f 100644
--- a/test/collective/fleet/test_imperative_auto_mixed_precision_for_eager.py
+++ b/test/collective/fleet/test_imperative_auto_mixed_precision_for_eager.py
@@ -148,7 +148,7 @@ def func():
     def test_custom_op_list_exception(self):
         self.custom_op_list_exception()
 
-    def amp_guard_upsupported_fp16_op(self):
+    def amp_guard_unsupported_fp16_op(self):
         data = np.random.uniform(-1, 1, [10, 3, 32, 32]).astype('float32')
         with base.dygraph.guard():
             conv2d = paddle.nn.Conv2D(3, 2, 3, bias_attr=False)
@@ -170,8 +170,8 @@ def amp_guard_upsupported_fp16_op(self):
         self.assertTrue(out_purefp16_fp16.dtype == paddle.float16)
         self.assertTrue(out_purefp16_fp32.dtype == paddle.float32)
 
-    def test_amp_guard_upsupported_fp16_op(self):
-        self.amp_guard_upsupported_fp16_op()
+    def test_amp_guard_unsupported_fp16_op(self):
+        self.amp_guard_unsupported_fp16_op()
 
     def mode_exception(self):
         def func():