diff --git a/flang/lib/Lower/OpenMP.cpp b/flang/lib/Lower/OpenMP.cpp
--- a/flang/lib/Lower/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP.cpp
@@ -549,15 +549,27 @@
                       llvm::SmallVectorImpl<const Fortran::semantics::Symbol *>
                           &useDeviceSymbols) const;
 
+  // Call this method for these clauses that should be supported but are not
+  // implemented yet. It triggers a compilation error if the given clauses are
+  // found.
+  template <typename... Ts>
+  void processTODO(mlir::Location currentLocation,
+                   llvm::omp::Directive directive) const;
+
 private:
   using ClauseIterator = std::list<ClauseTy>::const_iterator;
 
-  /// Utility to find a clause within a range in the clause list.
-  template <typename T>
+  /// Utility to find one of the given clauses within a range in the clause
+  /// list.
+  template <typename... Ts>
   static ClauseIterator findClause(ClauseIterator begin, ClauseIterator end) {
-    for (ClauseIterator it = begin; it != end; ++it)
-      if (std::get_if<T>(&it->u))
-        return it;
+    for (ClauseIterator it = begin; it != end; ++it) {
+      bool found[sizeof...(Ts)] = {
+          static_cast<bool>(std::get_if<Ts>(&it->u))...};
+      for (bool v : found)
+        if (v)
+          return it;
+    }
 
     return end;
   }
@@ -1764,6 +1776,18 @@
       });
 }
 
+template <typename... Ts>
+void ClauseProcessor::processTODO(mlir::Location currentLocation,
+                                  llvm::omp::Directive directive) const {
+  ClauseIterator it = findClause<Ts...>(clauses.v.begin(), clauses.v.end());
+  if (it != clauses.v.end()) {
+    TODO(currentLocation,
+         "Unhandled clause in " +
+             llvm::omp::getOpenMPDirectiveName(directive).upper() +
+             " directive");
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Code generation helper functions
 //===----------------------------------------------------------------------===//
@@ -2204,8 +2228,11 @@
   llvm::SmallVector<mlir::Value> allocateOperands, allocatorOperands;
   mlir::UnitAttr nowaitAttr;
 
-  ClauseProcessor(converter, beginClauseList)
-      .processAllocate(allocatorOperands, allocateOperands);
+  ClauseProcessor cp(converter, beginClauseList);
+  cp.processAllocate(allocatorOperands, allocateOperands);
+  cp.processTODO<Fortran::parser::OmpClause::Copyprivate>(
+      currentLocation, llvm::omp::Directive::OMPD_single);
+
   ClauseProcessor(converter, endClauseList).processNowait(nowaitAttr);
 
   return genOpWithBody<mlir::omp::SingleOp>(
@@ -2235,6 +2262,10 @@
   cp.processMergeable(mergeableAttr);
   cp.processPriority(stmtCtx, priorityClauseOperand);
   cp.processDepend(dependTypeOperands, dependOperands);
+  cp.processTODO<Fortran::parser::OmpClause::InReduction,
+                 Fortran::parser::OmpClause::Detach,
+                 Fortran::parser::OmpClause::Affinity>(
+      currentLocation, llvm::omp::Directive::OMPD_task);
 
   return genOpWithBody<mlir::omp::TaskOp>(
       converter, eval, currentLocation, /*outerCombined=*/false, &clauseList,
@@ -2254,9 +2285,10 @@
                mlir::Location currentLocation,
                const Fortran::parser::OmpClauseList &clauseList) {
   llvm::SmallVector<mlir::Value> allocateOperands, allocatorOperands;
-  // TODO: Add task_reduction support
-  ClauseProcessor(converter, clauseList)
-      .processAllocate(allocatorOperands, allocateOperands);
+  ClauseProcessor cp(converter, clauseList);
+  cp.processAllocate(allocatorOperands, allocateOperands);
+  cp.processTODO<Fortran::parser::OmpClause::TaskReduction>(
+      currentLocation, llvm::omp::Directive::OMPD_taskgroup);
   return genOpWithBody<mlir::omp::TaskGroupOp>(
       converter, eval, currentLocation, /*outerCombined=*/false, &clauseList,
       /*task_reduction_vars=*/mlir::ValueRange(),
@@ -2314,12 +2346,15 @@
   llvm::SmallVector<mlir::IntegerAttr> mapTypes;
 
   Fortran::parser::OmpIfClause::DirectiveNameModifier directiveName;
+  llvm::omp::Directive directive;
   if constexpr (std::is_same_v<OpTy, mlir::omp::EnterDataOp>) {
     directiveName =
         Fortran::parser::OmpIfClause::DirectiveNameModifier::TargetEnterData;
+    directive = llvm::omp::Directive::OMPD_target_enter_data;
   } else if constexpr (std::is_same_v<OpTy, mlir::omp::ExitDataOp>) {
     directiveName =
         Fortran::parser::OmpIfClause::DirectiveNameModifier::TargetExitData;
+    directive = llvm::omp::Directive::OMPD_target_exit_data;
   } else {
     return nullptr;
   }
@@ -2329,6 +2364,8 @@
   cp.processDevice(stmtCtx, deviceOperand);
   cp.processNowait(nowaitAttr);
   cp.processMap(mapOperands, mapTypes);
+  cp.processTODO<Fortran::parser::OmpClause::Depend>(currentLocation,
+                                                     directive);
 
   llvm::SmallVector<mlir::Attribute> mapTypesAttr(mapTypes.begin(),
                                                   mapTypes.end());
@@ -2361,6 +2398,17 @@
   cp.processThreadLimit(stmtCtx, threadLimitOperand);
   cp.processNowait(nowaitAttr);
   cp.processMap(mapOperands, mapTypes);
+  cp.processTODO<Fortran::parser::OmpClause::Private,
+                 Fortran::parser::OmpClause::Depend,
+                 Fortran::parser::OmpClause::Firstprivate,
+                 Fortran::parser::OmpClause::IsDevicePtr,
+                 Fortran::parser::OmpClause::HasDeviceAddr,
+                 Fortran::parser::OmpClause::Reduction,
+                 Fortran::parser::OmpClause::InReduction,
+                 Fortran::parser::OmpClause::Allocate,
+                 Fortran::parser::OmpClause::UsesAllocators,
+                 Fortran::parser::OmpClause::Defaultmap>(
+      currentLocation, llvm::omp::Directive::OMPD_target);
 
   llvm::SmallVector<mlir::Attribute> mapTypesAttr(mapTypes.begin(),
                                                   mapTypes.end());
@@ -2393,8 +2441,8 @@
   cp.processDefault();
   cp.processNumTeams(stmtCtx, numTeamsClauseOperand);
   cp.processThreadLimit(stmtCtx, threadLimitClauseOperand);
-  if (cp.processReduction(currentLocation, reductionVars, reductionDeclSymbols))
-    TODO(currentLocation, "Reduction of TEAMS directive");
+  cp.processTODO<Fortran::parser::OmpClause::Reduction>(
+      currentLocation, llvm::omp::Directive::OMPD_teams);
 
   return genOpWithBody<mlir::omp::TeamsOp>(
       converter, eval, currentLocation, outerCombined, &clauseList,
@@ -2411,10 +2459,11 @@
 // genOMP() Code generation helper functions
 //===----------------------------------------------------------------------===//
 
-static void genOMP(Fortran::lower::AbstractConverter &converter,
-                   Fortran::lower::pft::Evaluation &eval,
-                   const Fortran::parser::OpenMPSimpleStandaloneConstruct
-                       &simpleStandaloneConstruct) {
+static void
+genOmpSimpleStandalone(Fortran::lower::AbstractConverter &converter,
+                       Fortran::lower::pft::Evaluation &eval,
+                       const Fortran::parser::OpenMPSimpleStandaloneConstruct
+                           &simpleStandaloneConstruct) {
   const auto &directive =
       std::get<Fortran::parser::OmpSimpleStandaloneDirective>(
           simpleStandaloneConstruct.t);
@@ -2430,6 +2479,10 @@
     firOpBuilder.create<mlir::omp::BarrierOp>(currentLocation);
     break;
   case llvm::omp::Directive::OMPD_taskwait:
+    ClauseProcessor(converter, opClauseList)
+        .processTODO<Fortran::parser::OmpClause::Depend,
+                     Fortran::parser::OmpClause::Nowait>(
+            currentLocation, llvm::omp::Directive::OMPD_taskwait);
     firOpBuilder.create<mlir::omp::TaskwaitOp>(currentLocation);
     break;
   case llvm::omp::Directive::OMPD_taskyield:
@@ -2453,6 +2506,24 @@
   }
 }
 
+static void
+genOmpFlush(Fortran::lower::AbstractConverter &converter,
+            Fortran::lower::pft::Evaluation &eval,
+            const Fortran::parser::OpenMPFlushConstruct &flushConstruct) {
+  llvm::SmallVector<mlir::Value, 4> operandRange;
+  if (const auto &ompObjectList =
+          std::get<std::optional<Fortran::parser::OmpObjectList>>(
+              flushConstruct.t))
+    genObjectList(*ompObjectList, converter, operandRange);
+  const auto &memOrderClause =
+      std::get<std::optional<std::list<Fortran::parser::OmpMemoryOrderClause>>>(
+          flushConstruct.t);
+  if (memOrderClause && memOrderClause->size() > 0)
+    TODO(converter.getCurrentLocation(), "Handle OmpMemoryOrderClause");
+  converter.getFirOpBuilder().create<mlir::omp::FlushOp>(
+      converter.getCurrentLocation(), operandRange);
+}
+
 static void
 genOMP(Fortran::lower::AbstractConverter &converter,
        Fortran::lower::pft::Evaluation &eval,
@@ -2461,22 +2532,10 @@
       Fortran::common::visitors{
           [&](const Fortran::parser::OpenMPSimpleStandaloneConstruct
                   &simpleStandaloneConstruct) {
-            genOMP(converter, eval, simpleStandaloneConstruct);
+            genOmpSimpleStandalone(converter, eval, simpleStandaloneConstruct);
           },
           [&](const Fortran::parser::OpenMPFlushConstruct &flushConstruct) {
-            llvm::SmallVector<mlir::Value, 4> operandRange;
-            if (const auto &ompObjectList =
-                    std::get<std::optional<Fortran::parser::OmpObjectList>>(
-                        flushConstruct.t))
-              genObjectList(*ompObjectList, converter, operandRange);
-            const auto &memOrderClause = std::get<std::optional<
-                std::list<Fortran::parser::OmpMemoryOrderClause>>>(
-                flushConstruct.t);
-            if (memOrderClause && memOrderClause->size() > 0)
-              TODO(converter.getCurrentLocation(),
-                   "Handle OmpMemoryOrderClause");
-            converter.getFirOpBuilder().create<mlir::omp::FlushOp>(
-                converter.getCurrentLocation(), operandRange);
+            genOmpFlush(converter, eval, flushConstruct);
           },
           [&](const Fortran::parser::OpenMPCancelConstruct &cancelConstruct) {
             TODO(converter.getCurrentLocation(), "OpenMPCancelConstruct");
@@ -2494,14 +2553,13 @@
                    const Fortran::parser::OpenMPLoopConstruct &loopConstruct) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
   llvm::SmallVector<mlir::Value> lowerBound, upperBound, step, linearVars,
-      linearStepVars, reductionVars, alignedVars, nontemporalVars;
-  mlir::Value scheduleChunkClauseOperand, ifClauseOperand;
+      linearStepVars, reductionVars;
+  mlir::Value scheduleChunkClauseOperand;
   mlir::IntegerAttr orderedClauseOperand;
   mlir::omp::ClauseOrderKindAttr orderClauseOperand;
   mlir::omp::ClauseScheduleKindAttr scheduleValClauseOperand;
   mlir::omp::ScheduleModifierAttr scheduleModClauseOperand;
   mlir::UnitAttr nowaitClauseOperand, scheduleSimdClauseOperand;
-  mlir::IntegerAttr simdlenClauseOperand, safelenClauseOperand;
   llvm::SmallVector<mlir::Attribute> reductionDeclSymbols;
   Fortran::lower::StatementContext stmtCtx;
   std::size_t loopVarTypeSize;
@@ -2561,12 +2619,10 @@
   cp.processCollapse(currentLocation, eval, lowerBound, upperBound, step, iv,
                      loopVarTypeSize);
   cp.processScheduleChunk(stmtCtx, scheduleChunkClauseOperand);
-  cp.processIf(stmtCtx,
-               Fortran::parser::OmpIfClause::DirectiveNameModifier::Simd,
-               ifClauseOperand);
   cp.processReduction(currentLocation, reductionVars, reductionDeclSymbols);
-  cp.processSimdlen(simdlenClauseOperand);
-  cp.processSafelen(safelenClauseOperand);
+  cp.processTODO<Fortran::parser::OmpClause::Linear,
+                 Fortran::parser::OmpClause::Order>(currentLocation,
+                                                    ompDirective);
 
   // The types of lower bound, upper bound, and step are converted into the
   // type of the loop variable if necessary.
@@ -2581,8 +2637,20 @@
   }
 
   // 2.9.3.1 SIMD construct
-  // TODO: Support all the clauses
   if (llvm::omp::allSimdSet.test(ompDirective)) {
+    llvm::SmallVector<mlir::Value> alignedVars, nontemporalVars;
+    mlir::Value ifClauseOperand;
+    mlir::IntegerAttr simdlenClauseOperand, safelenClauseOperand;
+    cp.processIf(stmtCtx,
+                 Fortran::parser::OmpIfClause::DirectiveNameModifier::Simd,
+                 ifClauseOperand);
+    cp.processSimdlen(simdlenClauseOperand);
+    cp.processSafelen(safelenClauseOperand);
+    cp.processTODO<Fortran::parser::OmpClause::Aligned,
+                   Fortran::parser::OmpClause::Allocate,
+                   Fortran::parser::OmpClause::Nontemporal>(currentLocation,
+                                                            ompDirective);
+
     mlir::TypeRange resultType;
     auto simdLoopOp = firOpBuilder.create<mlir::omp::SimdLoopOp>(
         currentLocation, resultType, lowerBound, upperBound, step, alignedVars,
@@ -2595,9 +2663,6 @@
     return;
   }
 
-  // FIXME: Add support for following clauses:
-  // 1. linear
-  // 2. order
   auto wsLoopOp = firOpBuilder.create<mlir::omp::WsLoopOp>(
       currentLocation, lowerBound, upperBound, step, linearVars, linearStepVars,
       reductionVars,
@@ -3331,6 +3396,9 @@
     cp.processTo(symbolAndClause);
     cp.processLink(symbolAndClause);
     cp.processDeviceType(deviceType);
+    cp.processTODO<Fortran::parser::OmpClause::Indirect>(
+        converter.getCurrentLocation(),
+        llvm::omp::Directive::OMPD_declare_target);
   }
 
   for (const DeclareTargetCapturePair &symClause : symbolAndClause) {
diff --git a/flang/test/Lower/OpenMP/Todo/reduction-teams.f90 b/flang/test/Lower/OpenMP/Todo/reduction-teams.f90
--- a/flang/test/Lower/OpenMP/Todo/reduction-teams.f90
+++ b/flang/test/Lower/OpenMP/Todo/reduction-teams.f90
@@ -1,7 +1,7 @@
 ! RUN: %not_todo_cmd bbc -emit-fir -fopenmp -o - %s 2>&1 | FileCheck %s
 ! RUN: %not_todo_cmd %flang_fc1 -emit-fir -fopenmp -o - %s 2>&1 | FileCheck %s
 
-! CHECK: not yet implemented: Reduction of TEAMS directive
+! CHECK: not yet implemented: Unhandled clause in TEAMS directive
 subroutine reduction_teams()
   integer :: i
   i = 0