[OpenMP] Fix memory leak when translating arguments

[Hahnfeld]

Summary

Parsing the argument after -Xopenmp-target allocates memory that needs
to be freed. Associate it with the final DerivedArgList after we know
which one will be used.

[gtbercea]

LGTM

include/clang/Driver/ToolChain.h

public:
 
   /// TranslateOpenMPTargetArgs - Create a new derived argument list for
   /// that contains the OpenMP target specific flags passed via
   /// -Xopenmp-target -opt=val OR -Xopenmp-target=<triple> -opt=val
   /// Translation occurs only when the \p DeviceOffloadKind is specified.
   ///
   /// \param DeviceOffloadKind - The device offload kind used for the
   /// translation.
-  virtual llvm::opt::DerivedArgList *
-  TranslateOpenMPTargetArgs(const llvm::opt::DerivedArgList &Args,
-      Action::OffloadKind DeviceOffloadKind) const;
+  virtual llvm::opt::DerivedArgList *TranslateOpenMPTargetArgs(
+      const llvm::opt::DerivedArgList &Args,
+      Action::OffloadKind DeviceOffloadKind,
+      SmallVector<llvm::opt::Arg *, 4> &AllocatedArgs) const;
 
   /// Choose a tool to use to handle the action \p JA.
   ///
   /// This can be overridden when a particular ToolChain needs to use
   /// a compiler other than Clang.
   virtual Tool *SelectTool(const JobAction &JA) const;
 
   // Helper methods

lib/Driver/Compilation.cpp

 const DerivedArgList &
 Compilation::getArgsForToolChain(const ToolChain *TC, StringRef BoundArch,
                                  Action::OffloadKind DeviceOffloadKind) {
   if (!TC)
     TC = &DefaultToolChain;
 
   DerivedArgList *&Entry = TCArgs[{TC, BoundArch, DeviceOffloadKind}];
   if (!Entry) {
+    SmallVector<Arg *, 4> AllocatedArgs;
     // Translate OpenMP toolchain arguments provided via the -Xopenmp-target flags.
-    DerivedArgList *OpenMPArgs = TC->TranslateOpenMPTargetArgs(*TranslatedArgs,
-        DeviceOffloadKind);
+    DerivedArgList *OpenMPArgs = TC->TranslateOpenMPTargetArgs(
+        *TranslatedArgs, DeviceOffloadKind, AllocatedArgs);
     if (!OpenMPArgs) {
       Entry = TC->TranslateArgs(*TranslatedArgs, BoundArch, DeviceOffloadKind);
     } else {
       Entry = TC->TranslateArgs(*OpenMPArgs, BoundArch, DeviceOffloadKind);
       delete OpenMPArgs;
     }
 
     if (!Entry)
       Entry = TranslatedArgs;
+
+    // Add allocated arguments to the final DAL.
+    for (auto ArgPtr : AllocatedArgs) {
+      Entry->AddSynthesizedArg(ArgPtr);
+    }
   }
 
   return *Entry;
 }
 
 bool Compilation::CleanupFile(const char *File, bool IssueErrors) const {
   // FIXME: Why are we trying to remove files that we have not created? For
   // example we should only try to remove a temporary assembly file if

lib/Driver/ToolChain.cpp

if (MSCVersion) {
     } else {
       return separateMSVCFullVersion(Version);
     }
   }
 
   return VersionTuple();
 }
 
-llvm::opt::DerivedArgList *
-ToolChain::TranslateOpenMPTargetArgs(const llvm::opt::DerivedArgList &Args,
-    Action::OffloadKind DeviceOffloadKind) const {
+llvm::opt::DerivedArgList *ToolChain::TranslateOpenMPTargetArgs(
+    const llvm::opt::DerivedArgList &Args,
+    Action::OffloadKind DeviceOffloadKind,
+    SmallVector<llvm::opt::Arg *, 4> &AllocatedArgs) const {
   if (DeviceOffloadKind == Action::OFK_OpenMP) {
     DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
     const OptTable &Opts = getDriver().getOpts();
     bool NewArgAdded = false;
 
     // Handle -Xopenmp-target flags
     for (Arg *A : Args) {
       // Exclude flags which may only apply to the host toolchain.
for (Arg *A : Args) {
       if (XOpenMPTargetNoTriple && XOpenMPTargetArg &&
           Args.getAllArgValues(
               options::OPT_fopenmp_targets_EQ).size() != 1) {
         getDriver().Diag(diag::err_drv_Xopenmp_target_missing_triple);
         continue;
       }
       XOpenMPTargetArg->setBaseArg(A);
       A = XOpenMPTargetArg.release();
+      AllocatedArgs.push_back(A);
       DAL->append(A);
       NewArgAdded = true;
     }
 
     if (NewArgAdded) {
       return DAL;
     } else {
       delete DAL;
     }
   }
 
   return nullptr;
 }

test/Driver/openmp-offload-gpu.c

 ///
 /// Perform several driver tests for OpenMP offloading
 ///
 
-// Until this test is stabilized on all local configurations.
-// UNSUPPORTED: linux
-
 // REQUIRES: clang-driver
 // REQUIRES: x86-registered-target
 // REQUIRES: powerpc-registered-target
 // REQUIRES: nvptx-registered-target
 
 /// ###########################################################################
 
 /// Check -Xopenmp-target=powerpc64le-ibm-linux-gnu -march=pwr7 is passed when compiling for the device.