[Flang][OpenMP] Add frontend support for -fopenmp-targets

This patch adds support for the `-fopenmp-targets` option to the `bbc` and
`flang -fc1` tools. It adds an `OMPTargetTriples` property to the `LangOptions`
structure, which is filled with the triples represented by the compiler option.

This is used to initialize the `omp.target_triples` module attribute for later
use by lowering stages.

Author: skatrak

flang/include/flang/Frontend/LangOptions.h

@@ -16,6 +16,9 @@
 #define FORTRAN_FRONTEND_LANGOPTIONS_H
 
 #include <string>
+#include <vector>
+
+#include "llvm/TargetParser/Triple.h"
 
 namespace Fortran::frontend {
 
@@ -58,6 +61,9 @@ class LangOptions : public LangOptionsBase {
   /// host code generation.
   std::string OMPHostIRFile;
 
+  /// List of triples passed in using -fopenmp-targets.
+  std::vector<llvm::Triple> OMPTargetTriples;
+
   LangOptions();
 };
 

flang/include/flang/Tools/CrossToolHelpers.h

@@ -131,15 +131,19 @@ struct OffloadModuleOpts {
       bool OpenMPThreadSubscription, bool OpenMPNoThreadState,
       bool OpenMPNoNestedParallelism, bool OpenMPIsTargetDevice,
       bool OpenMPIsGPU, bool OpenMPForceUSM, uint32_t OpenMPVersion,
-      std::string OMPHostIRFile = {}, bool NoGPULib = false)
+      std::string OMPHostIRFile = {},
+      const std::vector<llvm::Triple> &OMPTargetTriples = {},
+      bool NoGPULib = false)
       : OpenMPTargetDebug(OpenMPTargetDebug),
         OpenMPTeamSubscription(OpenMPTeamSubscription),
         OpenMPThreadSubscription(OpenMPThreadSubscription),
         OpenMPNoThreadState(OpenMPNoThreadState),
         OpenMPNoNestedParallelism(OpenMPNoNestedParallelism),
         OpenMPIsTargetDevice(OpenMPIsTargetDevice), OpenMPIsGPU(OpenMPIsGPU),
         OpenMPForceUSM(OpenMPForceUSM), OpenMPVersion(OpenMPVersion),
-        OMPHostIRFile(OMPHostIRFile), NoGPULib(NoGPULib) {}
+        OMPHostIRFile(OMPHostIRFile),
+        OMPTargetTriples(OMPTargetTriples.begin(), OMPTargetTriples.end()),
+        NoGPULib(NoGPULib) {}
 
   OffloadModuleOpts(Fortran::frontend::LangOptions &Opts)
       : OpenMPTargetDebug(Opts.OpenMPTargetDebug),
@@ -150,7 +154,7 @@ struct OffloadModuleOpts {
         OpenMPIsTargetDevice(Opts.OpenMPIsTargetDevice),
         OpenMPIsGPU(Opts.OpenMPIsGPU), OpenMPForceUSM(Opts.OpenMPForceUSM),
         OpenMPVersion(Opts.OpenMPVersion), OMPHostIRFile(Opts.OMPHostIRFile),
-        NoGPULib(Opts.NoGPULib) {}
+        OMPTargetTriples(Opts.OMPTargetTriples), NoGPULib(Opts.NoGPULib) {}
 
   uint32_t OpenMPTargetDebug = 0;
   bool OpenMPTeamSubscription = false;
@@ -162,6 +166,7 @@ struct OffloadModuleOpts {
   bool OpenMPForceUSM = false;
   uint32_t OpenMPVersion = 11;
   std::string OMPHostIRFile = {};
+  std::vector<llvm::Triple> OMPTargetTriples = {};
   bool NoGPULib = false;
 };
 
@@ -185,6 +190,9 @@ struct OffloadModuleOpts {
       if (!Opts.OMPHostIRFile.empty())
         offloadMod.setHostIRFilePath(Opts.OMPHostIRFile);
     }
+    auto strTriples = llvm::to_vector(llvm::map_range(Opts.OMPTargetTriples,
+        [](llvm::Triple triple) { return triple.normalize(); }));
+    offloadMod.setTargetTriples(strTriples);
   }
 }
 

flang/lib/Frontend/CompilerInvocation.cpp

@@ -894,6 +894,7 @@ static bool parseDiagArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
 /// options accordingly. Returns false if new errors are generated.
 static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
                              clang::DiagnosticsEngine &diags) {
+  llvm::Triple t(res.getTargetOpts().triple);
   unsigned numErrorsBefore = diags.getNumErrors();
 
   // -fdefault* family
@@ -1012,6 +1013,40 @@ static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
       res.getLangOpts().OpenMPIsGPU = 0;
       break;
     }
+
+    // Get the OpenMP target triples if any.
+    if (auto *arg =
+            args.getLastArg(clang::driver::options::OPT_fopenmp_targets_EQ)) {
+      enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
+      auto getArchPtrSize = [](const llvm::Triple &triple) {
+        if (triple.isArch16Bit())
+          return Arch16Bit;
+        if (triple.isArch32Bit())
+          return Arch32Bit;
+        assert(triple.isArch64Bit() && "Expected 64-bit architecture");
+        return Arch64Bit;
+      };
+
+      for (unsigned i = 0; i < arg->getNumValues(); ++i) {
+        llvm::Triple tt(arg->getValue(i));
+
+        if (tt.getArch() == llvm::Triple::UnknownArch ||
+            !(tt.getArch() == llvm::Triple::aarch64 || tt.isPPC() ||
+              tt.getArch() == llvm::Triple::systemz ||
+              tt.getArch() == llvm::Triple::nvptx ||
+              tt.getArch() == llvm::Triple::nvptx64 ||
+              tt.getArch() == llvm::Triple::amdgcn ||
+              tt.getArch() == llvm::Triple::x86 ||
+              tt.getArch() == llvm::Triple::x86_64))
+          diags.Report(clang::diag::err_drv_invalid_omp_target)
+              << arg->getValue(i);
+        else if (getArchPtrSize(t) != getArchPtrSize(tt))
+          diags.Report(clang::diag::err_drv_incompatible_omp_arch)
+              << arg->getValue(i) << t.str();
+        else
+          res.getLangOpts().OMPTargetTriples.push_back(tt);
+      }
+    }
   }
 
   // -pedantic

flang/test/Lower/OpenMP/offload-targets.f90

@@ -0,0 +1,10 @@
+! RUN: %flang_fc1 -emit-hlfir -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa,nvptx64-nvidia-cuda %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir -fopenmp -fopenmp-targets=amdgcn-amd-amdhsa,nvptx64-nvidia-cuda %s -o - | FileCheck %s
+
+! This test checks the addition of the omp.target_triples attribute when the
+! -fopenmp-targets option is set
+
+!CHECK:      module attributes {
+!CHECK-SAME: omp.target_triples = ["amdgcn-amd-amdhsa", "nvptx64-nvidia-cuda"]
+program targets
+end program targets

flang/tools/bbc/bbc.cpp

@@ -149,6 +149,11 @@ static llvm::cl::opt<bool> enableOpenMPForceUSM(
     llvm::cl::desc("force openmp unified shared memory mode"),
     llvm::cl::init(false));
 
+static llvm::cl::list<std::string> targetTriplesOpenMP(
+    "fopenmp-targets",
+    llvm::cl::desc("comma-separated list of OpenMP offloading triples"),
+    llvm::cl::CommaSeparated);
+
 // A simplified subset of the OpenMP RTL Flags from Flang, only the primary
 // positive options are available, no negative options e.g. fopen_assume* vs
 // fno_open_assume*
@@ -380,11 +385,17 @@ static llvm::LogicalResult convertFortranSourceToMLIR(
                       "-fopenmp-is-target-device is also set";
       return mlir::failure();
     }
+    // Construct offloading target triples vector.
+    std::vector<llvm::Triple> targetTriples;
+    targetTriples.reserve(targetTriplesOpenMP.size());
+    for (llvm::StringRef s : targetTriplesOpenMP)
+      targetTriples.emplace_back(s);
+
     auto offloadModuleOpts = OffloadModuleOpts(
         setOpenMPTargetDebug, setOpenMPTeamSubscription,
         setOpenMPThreadSubscription, setOpenMPNoThreadState,
         setOpenMPNoNestedParallelism, enableOpenMPDevice, enableOpenMPGPU,
-        enableOpenMPForceUSM, setOpenMPVersion, "", setNoGPULib);
+        enableOpenMPForceUSM, setOpenMPVersion, "", targetTriples, setNoGPULib);
     setOffloadModuleInterfaceAttributes(mlirModule, offloadModuleOpts);
     setOpenMPVersionAttribute(mlirModule, setOpenMPVersion);
   }