[clang][AIX] Enable LTO and teach the driver to pass options to the plugin

[daltenty]

Summary

This is a follow on to D119107. AIX ld now supports libLTO loaded
as a plugin

This change teaches the clang driver how to pass AIX ld the
libLTO path and the option to pass LTO significant driver options
through to the plugin. Some remarks plugin options are mapped
to their libLTO equivalents when using the AIX ld.

We need also to indicate to the toolchain that we now support
bitcode in the linker, or we run into asserts on some single-step
LTO invocations.

See also https://www.ibm.com/docs/en/aix/7.2?topic=l-ld-command for
the linker interface.

co-authored-by: Ettore Tiotto <[e-mail]>
co-authored-by: Wai Hung Tsang <[e-mail]>

[Whitney]

clang/lib/Driver/ToolChains/CommonArgs.cpp

522

Do you think this can be more clear?

#if defined(_WIN32)
    const char *Suffix = ".dll";
#elif defined(__APPLE__)
    const char *Suffix = ".dylib";
#else
    const char *Suffix = ".so";
#endif
  SmallString<1024> Plugin;
  if (LTOPluginType == ToolChain::LTOPluginType::LTOPT_LLVMlto_AIX) {
    llvm::sys::path::native("-bplugin:" + Twine(D.Dir) +
                                  "/../lib" CLANG_LIBDIR_SUFFIX "/libLTO" +
                                  Suffix,
                              Plugin);
  } else if (LTOPluginType == ToolChain::LTOPluginType::LTOPT_LLVMgold) {
      // Tell the linker to load the plugin. This has to come before
      // AddLinkerInputs as gold requires -plugin to come before any -plugin-opt
      // that -Wl might forward.
      CmdArgs.push_back("-plugin");

      llvm::sys::path::native(
          Twine(D.Dir) + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold" + Suffix,
          Plugin);
  }

[daltenty]

clang/lib/Driver/ToolChains/CommonArgs.cpp

522

Thanks, I like this simplification. I'll update with it.

[daltenty]

• Rebase
• incorporate suggestion from review
• add fuse-ld=ld to debugger tuning test, to make it invariant when running on platforms that might use ldd by default

[daltenty]

Add back in CmdArgs.push_back(Args.MakeArgString(Plugin)) that got accidentally removed

[Whitney]

I don't have any other comments other than those clang-format ones.

[daltenty]

clang-format

[daltenty]

clang-format

[w2yehia]

clang/lib/Driver/ToolChain.cpp

641

instead of having two functions: getLTOPluginType and getLTOPluginTypeImpl, why not just have one: getLTOPluginTypeImpl.
In the base class (ToolChain) implementation it returns LTOPT_LLVMldlld or LTOPT_LLVMgold, and then derived classes that cannot incorporate their logic into the base implementation wud override (so AIX will do that).

Right now the base class's implementation is split between getLTOPluginType and getLTOPluginTypeImpl, but is avoidable.

clang/test/Driver/lto.c

56

we don't expect any prefix other than so, no?

[daltenty]

clang/lib/Driver/ToolChain.cpp

641

Hmm, I was originally thinking the same thing. But I think the reason we need this is there's really two parts to the plugin determination:

• a platform independent part that can determine the proper plugin if we can identify the linker by name (i.e. lld). This should be common for all platforms including AIX (one could legitimately use -fuse-ld=lld even on AIX)
• then if we can't identify the linker by name (i.e. it's just ld), a platform specific fallback

I think we could rename getLTOPluginTypeImpl() to something like getLdLTOPluginType() and add a comment to that effect.

clang/test/Driver/lto.c

56

For the actual plugin on AIX, yes. The test however will still run other platforms, so it may encounter the other cases.

[w2yehia]

LGTM

clang/lib/Driver/ToolChain.cpp

641

makes sense

clang/test/Driver/lto.c

56

Does the -target option affect what toolchain clang uses/assumes? If it assumes the host toolchain, then yes the filetype can be non-so but then the option name -bplugin won't work. If it assumes the target toolchain, then the problem is that host toolchain might have a different interface than the target toolchain.
I realize that cross compiling is hard in general (system headers and libraries), so I'm not sure if clang needs to be spot on here. Disabling the test on non-AIX makes more sense than having a test that asserts invalid behaviour.

[amyk]

Thanks for adding this David, I think this makes sense and LGTM, too.

[daltenty]

We've rolled the tests added by this into https://reviews.llvm.org/D135885 instead, so abandoning this.

clang/include/clang/Driver/ToolChain.h

struct BitCodeLibraryInfo {
     bool ShouldInternalize;
     BitCodeLibraryInfo(StringRef Path, bool ShouldInternalize = true)
         : Path(Path), ShouldInternalize(ShouldInternalize) {}
   };
 
   enum FileType { FT_Object, FT_Static, FT_Shared };
 
   enum LTOPluginType {
-    LTOPT_LLVMgold, // LTO plugin used by toolchains that use the GNU linker.
-    LTOPT_LLVMldlld // LTO plugin used by toolchains that use the ld.lld.
+    LTOPT_LLVMgold,   // LTO plugin used by toolchains that use the GNU linker.
+    LTOPT_LLVMldlld,  // LTO plugin used by toolchains that use the ld.lld.
+    LTOPT_LLVMlto_AIX // LTO plugin used by the AIX toolchain.
   };
 
 private:
   friend class RegisterEffectiveTriple;
 
   const Driver &D;
   llvm::Triple Triple;
   const llvm::opt::ArgList &Args;

clang/lib/Driver/ToolChain.cpp

std::string ToolChain::GetLinkerPath(bool *LinkerIsLLD) const {
   }
 
   if (A)
     getDriver().Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
 
   return GetProgramPath(getDefaultLinker());
 }
 
 ToolChain::LTOPluginType ToolChain::getLTOPluginType() const {
   std::string Linker = GetLinkerPath();
 
   // The LLVM linker doesn't require an LTO plugin.
   if (llvm::sys::path::filename(Linker) == "ld.lld" ||
       llvm::sys::path::stem(Linker) == "ld.lld")
     return LTOPluginType::LTOPT_LLVMldlld;
 
   return getLTOPluginTypeImpl();
 }
 
 ToolChain::LTOPluginType ToolChain::getLTOPluginTypeImpl() const {
   return LTOPluginType::LTOPT_LLVMgold;
 }
 
 StringRef ToolChain::getLTOPluginPrefix() const {
   switch (getLTOPluginType()) {
   case LTOPluginType::LTOPT_LLVMgold:
   case LTOPluginType::LTOPT_LLVMldlld:
     return "-plugin-opt=";
+  case LTOPluginType::LTOPT_LLVMlto_AIX:
+    return "-bplugin_opt:";
   }
   llvm_unreachable("Unexpected LTO plugin type");
 }
 
 std::string ToolChain::GetStaticLibToolPath() const {
   // TODO: Add support for static lib archiving on Windows
   if (Triple.isOSDarwin())
     return GetProgramPath("libtool");

clang/lib/Driver/ToolChains/AIX.h

public:
   bool parseInlineAsmUsingAsmParser() const override {
     return ParseInlineAsmUsingAsmParser;
   }
   bool isPICDefault() const override { return true; }
   bool isPIEDefault(const llvm::opt::ArgList &Args) const override {
     return false;
   }
   bool isPICDefaultForced() const override { return true; }
+  bool HasNativeLLVMSupport() const override { return true; }
 
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
 
   void AddClangCXXStdlibIncludeArgs(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
 
   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const override;
 
   CXXStdlibType GetDefaultCXXStdlibType() const override;
 
   RuntimeLibType GetDefaultRuntimeLibType() const override;
 
   // Set default DWARF version to 3 for now as latest AIX OS supports version 3.
   unsigned GetDefaultDwarfVersion() const override { return 3; }
 
   llvm::DebuggerKind getDefaultDebuggerTuning() const override {
     return llvm::DebuggerKind::DBX;
   }
 
+  LTOPluginType getLTOPluginTypeImpl() const override;
+
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 
 private:
   llvm::StringRef GetHeaderSysroot(const llvm::opt::ArgList &DriverArgs) const;
   bool ParseInlineAsmUsingAsmParser;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AIX_H

clang/lib/Driver/ToolChains/AIX.cpp

void aix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   }
 
   // Collect all static constructor and destructor functions in both C and CXX
   // language link invocations. This has to come before AddLinkerInputs as the
   // implied option needs to precede any other '-bcdtors' settings or
   // '-bnocdtors' that '-Wl' might forward.
   CmdArgs.push_back("-bcdtors:all:0:s");
 
+  if (D.isUsingLTO()) {
+    assert(!Inputs.empty() && "Must have at least one input.");
+    addLTOOptions(ToolChain, Args, CmdArgs, Output, Inputs[0],
+                  D.getLTOMode() == LTOK_Thin);
+  }
+
   // Specify linker input file(s).
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
 
   // Add directory to library search path.
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   ToolChain.AddFilePathLibArgs(Args, CmdArgs);
   ToolChain.addProfileRTLibs(Args, CmdArgs);
 

 ToolChain::CXXStdlibType AIX::GetDefaultCXXStdlibType() const {
   return ToolChain::CST_Libcxx;
 }
 
 ToolChain::RuntimeLibType AIX::GetDefaultRuntimeLibType() const {
   return ToolChain::RLT_CompilerRT;
 }
 
+ToolChain::LTOPluginType AIX::getLTOPluginTypeImpl() const {
+  return LTOPluginType::LTOPT_LLVMlto_AIX;
+}
+
 auto AIX::buildAssembler() const -> Tool * { return new aix::Assembler(*this); }
 
 auto AIX::buildLinker() const -> Tool * { return new aix::Linker(*this); }

clang/lib/Driver/ToolChains/CommonArgs.cpp

 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 static void MakePluginOpt(const ToolChain &ToolChain, const ArgList &Args,
                           ArgStringList &CmdArgs, const llvm::Twine &opt,
                           bool Seperator = false) {
+  // AIX libLTO opts always require a dash.
+  if (ToolChain.getLTOPluginType() ==
+      ToolChain::LTOPluginType::LTOPT_LLVMlto_AIX)
+    Seperator = true;
   CmdArgs.push_back(Args.MakeArgString(Twine(ToolChain.getLTOPluginPrefix()) +
                                        (Seperator ? Twine("-") : Twine("")) +
                                        opt));
 }
 
 static void renderRpassOptions(const ToolChain &ToolChain, const ArgList &Args,
                                ArgStringList &CmdArgs) {
   if (const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))
static void renderRemarksOptions(const ToolChain &ToolChain,
   SmallString<128> F;
   const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
   if (A)
     F = A->getValue();
   else if (Output.isFilename())
     F = Output.getFilename();
 
   assert(!F.empty() && "Cannot determine remarks output name.");
+  const bool IsLTOPluginTypeAIX = ToolChain.getLTOPluginType() ==
+                                  ToolChain::LTOPluginType::LTOPT_LLVMlto_AIX;
+  const char *remarksFileOpt =
+      IsLTOPluginTypeAIX ? "lto-pass-remarks-output=" : "opt-remarks-filename=";
   // Append "opt.ld.<format>" to the end of the file name.
   MakePluginOpt(ToolChain, Args, CmdArgs,
-                "opt-remarks-filename=" + F + Twine(".opt.ld.") + Format);
+                remarksFileOpt + F + Twine(".opt.ld.") + Format);
 
+  const char *remarksPassesOpt =
+      IsLTOPluginTypeAIX ? "lto-pass-remarks-filter=" : "opt-remarks-passes=";
   if (const Arg *A =
           Args.getLastArg(options::OPT_foptimization_record_passes_EQ))
     MakePluginOpt(ToolChain, Args, CmdArgs,
-                  Twine("opt-remarks-passes=") + A->getValue());
+                  Twine(remarksPassesOpt) + A->getValue());
 
+  const char *remarksFormatOpt =
+      IsLTOPluginTypeAIX ? "lto-pass-remarks-format=" : "opt-remarks-format=";
   MakePluginOpt(ToolChain, Args, CmdArgs,
-                Twine("opt-remarks-format=") + Format.data());
+                Twine(remarksFormatOpt) + Format.data());
 }
 
 static void renderRemarksHotnessOptions(const ToolChain &ToolChain,
                                         const ArgList &Args,
                                         ArgStringList &CmdArgs) {
+  const bool IsLTOPluginTypeAIX = ToolChain.getLTOPluginType() ==
+                                  ToolChain::LTOPluginType::LTOPT_LLVMlto_AIX;
+  const char *remarksWithHotnessOpt = IsLTOPluginTypeAIX
+                                          ? "lto-pass-remarks-with-hotness"
+                                          : "opt-remarks-with-hotness";
   if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,
                    options::OPT_fno_diagnostics_show_hotness, false))
-    MakePluginOpt(ToolChain, Args, CmdArgs, "opt-remarks-with-hotness");
+    MakePluginOpt(ToolChain, Args, CmdArgs, remarksWithHotnessOpt);
 
+  const char *remarksHotnessThresholdOpt =
+      IsLTOPluginTypeAIX ? "lto-pass-remarks-hotness-threshold="
+                         : "opt-remarks-hotness-threshold=";
   if (const Arg *A =
           Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ))
     MakePluginOpt(ToolChain, Args, CmdArgs,
-                  Twine("opt-remarks-hotness-threshold=") + A->getValue());
+                  Twine(remarksHotnessThresholdOpt) + A->getValue());
 }
 
 void tools::addPathIfExists(const Driver &D, const Twine &Path,
                             ToolChain::path_list &Paths) {
   if (D.getVFS().exists(Path))
     Paths.push_back(Path.str());
 }
 
bool tools::isUseSeparateSections(const llvm::Triple &Triple) {
   return Triple.getOS() == llvm::Triple::CloudABI;
 }
 
 void tools::addLTOOptions(const ToolChain &ToolChain, const ArgList &Args,
                           ArgStringList &CmdArgs, const InputInfo &Output,
                           const InputInfo &Input, bool IsThinLTO) {
   const ToolChain::LTOPluginType LTOPluginType = ToolChain.getLTOPluginType();
   const Driver &D = ToolChain.getDriver();
-  if (LTOPluginType != ToolChain::LTOPluginType::LTOPT_LLVMldlld) {
-    // Tell the linker to load the plugin. This has to come before
-    // AddLinkerInputs as gold requires -plugin to come before any -plugin-opt
-    // that -Wl might forward.
-    CmdArgs.push_back("-plugin");
-
 #if defined(_WIN32)
-    const char *Suffix = ".dll";
 #elif defined(__APPLE__)
-    const char *Suffix = ".dylib";
 #else
-    const char *Suffix = ".so";
 #endif
-
-    SmallString<1024> Plugin;
+  if (LTOPluginType == ToolChain::LTOPluginType::LTOPT_LLVMlto_AIX) {
+    llvm::sys::path::native("-bplugin:" + Twine(D.Dir) +
+                                "/../lib" CLANG_LIBDIR_SUFFIX "/libLTO" +
+                                Suffix,
+                            Plugin);
+    CmdArgs.push_back(Args.MakeArgString(Plugin));
+  } else if (LTOPluginType == ToolChain::LTOPluginType::LTOPT_LLVMgold) {
+    // Tell the linker to load the plugin. This has to come before
+    // AddLinkerInputs as gold requires -plugin to come before any -plugin-opt
+    // that -Wl might forward.
+    CmdArgs.push_back("-plugin");
+
     llvm::sys::path::native(
         Twine(D.Dir) + "/../lib" CLANG_LIBDIR_SUFFIX "/LLVMgold" + Suffix,
         Plugin);
     CmdArgs.push_back(Args.MakeArgString(Plugin));
   }
 
   // Try to pass driver level flags relevant to LTO code generation down to
   // the plugin.

clang/test/Driver/lto.c

 
 /// lld does not need LLVMgold.
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -### 2>&1 | FileCheck --check-prefix=NO-LLVMGOLD %s
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=gold -flto -fno-lto -### 2>&1 | FileCheck --check-prefix=NO-LLVMGOLD %s
 // NO-LLVMGOLD-NOT: "-plugin" "{{.*}}{{[/\\]}}LLVMgold.{{dll|dylib|so}}"
 
+/// With AIX ld, use libLTO.
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto=full -### 2>&1 | FileCheck --check-prefix=AIXLD %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -fno-lto -flto -### 2>&1 | FileCheck --check-prefix=AIXLD %s
+// AIXLD: "-bplugin:{{.*}}{{[/\\]}}libLTO.{{dll|dylib|so}}"
+
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -O -### 2>&1 | FileCheck --check-prefix=O1 %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto -O -### 2>&1 | FileCheck --check-prefix=O1AIX %s
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -O1 -### 2>&1 | FileCheck --check-prefix=O1 %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto -O1 -### 2>&1 | FileCheck --check-prefix=O1AIX %s
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -Og -### 2>&1 | FileCheck --check-prefix=O1 %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto -Og -### 2>&1 | FileCheck --check-prefix=O1AIX %s
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -O2 -### 2>&1 | FileCheck --check-prefix=O2 %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto -O2 -### 2>&1 | FileCheck --check-prefix=O2AIX %s
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -Os -### 2>&1 | FileCheck --check-prefix=O2 %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto -Os -### 2>&1 | FileCheck --check-prefix=O2AIX %s
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -Oz -### 2>&1 | FileCheck --check-prefix=O2 %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto -Oz -### 2>&1 | FileCheck --check-prefix=O2AIX %s
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -O3 -### 2>&1 | FileCheck --check-prefix=O3 %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto -O3 -### 2>&1 | FileCheck --check-prefix=O3AIX %s
 // RUN: %clang -target x86_64-unknown-linux-gnu --sysroot %S/Inputs/basic_cross_linux_tree %s \
 // RUN:   -fuse-ld=lld -flto -Ofast -### 2>&1 | FileCheck --check-prefix=O3 %s
+// RUN: %clang -target powerpc-ibm-aix --sysroot %S/Inputs/aix_ppc_tree %s \
+// RUN:   -fuse-ld=ld -flto -Ofast -### 2>&1 | FileCheck --check-prefix=O3AIX %s
 
 // O1: -plugin-opt=O1
+// O1AIX: -bplugin_opt:-O1
 // O2: -plugin-opt=O2
+// O2AIX: -bplugin_opt:-O2
 // O3: -plugin-opt=O3
+// O3AIX: -bplugin_opt:-O3
 
 // -flto passes along an explicit debugger tuning argument.
 // RUN: %clang -target x86_64-unknown-linux -### %s -flto -glldb 2> %t
 // RUN: FileCheck -check-prefix=CHECK-TUNING-LLDB < %t %s
 // RUN: %clang -target x86_64-unknown-linux -### %s -flto -g 2> %t
 // RUN: FileCheck -check-prefix=CHECK-NO-TUNING < %t %s
+// RUN: %clang -target powerpc-ibm-aix -### %s -flto -fuse-ld=ld -gdbx 2> %t
+// RUN: FileCheck -check-prefix=CHECK-TUNING-DBX < %t %s
+// RUN: %clang -target powerpc-ibm-aix -### %s -flto -fuse-ld=ld -g 2> %t
+// RUN: FileCheck -check-prefix=CHECK-NO-TUNING < %t %s
 //
 // CHECK-TUNING-LLDB:   "-plugin-opt=-debugger-tune=lldb"
-// CHECK-NO-TUNING-NOT: "-plugin-opt=-debugger-tune
+// CHECK-TUNING-DBX:    "-bplugin_opt:-debugger-tune=dbx"
+// CHECK-NO-TUNING-NOT: "{{-plugin-opt=|-bplugin_opt:}}-debugger-tune
 //
 // -flto=auto and -flto=jobserver pass along -flto=full
 // RUN: %clang -target x86_64-unknown-linux -### %s -flto=auto 2>&1 | FileCheck --check-prefix=FLTO-AUTO %s
 // RUN: %clang -target x86_64-unknown-linux -### %s -flto=jobserver 2>&1 | FileCheck --check-prefix=FLTO-JOBSERVER %s
 //
 // FLTO-AUTO: -flto=full
 // FLTO-JOBSERVER: -flto=full
 //

 // FLTO-FULL-NOT: -flto=thin
 // FLTO-FULL: -flto=full
 // FLTO-FULL-NOT: -flto=thin
 //
 // FLTO-THIN-NOT: -flto=full
 // FLTO-THIN-NOT: "-flto"
 // FLTO-THIN: -flto=thin
 // FLTO-THIN-NOT: "-flto"
-// FLTO-THIN-NOT: -flto=full
+// FLTO-THIN-NOT: -flto=full
 

clang/test/Driver/opt-record.c

 // CHECK-EQ-FORMAT: "-opt-record-file" "FOO.opt.some-format"
 // CHECK-EQ-FORMAT: "-opt-record-format" "some-format"
 
 // CHECK-FOPT-DISABLE-FORMAT-NOT: "-fno-save-optimization-record"
 
 // Test remarks options pass-through
 // No pass-through: lto is disabled
 // RUN: %clang -target x86_64 -### -o FOO -fdiagnostics-hotness-threshold=100 -fsave-optimization-record %s 2>&1 | FileCheck %s -check-prefix=CHECK-NOPASS
+// RUN: %clang -target powerpc-ibm-aix -### -o FOO -fdiagnostics-hotness-threshold=100 -fsave-optimization-record %s 2>&1 | FileCheck %s -check-prefix=CHECK-AIX-NOPASS
 
 // Pass-through:
 // RUN: %clang -target x86_64-linux -### -fuse-ld=lld -flto -fdiagnostics-hotness-threshold=100 -fsave-optimization-record -foptimization-record-passes=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-PASS-A
+// RUN: %clang -target powerpc-ibm-aix -### -fuse-ld=ld -flto -fdiagnostics-hotness-threshold=100 -fsave-optimization-record -foptimization-record-passes=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-AIX-PASS-A
 // RUN: %clang -target x86_64-linux -### -o FOO -fuse-ld=gold -flto -fdiagnostics-hotness-threshold=100 -fsave-optimization-record -foptimization-record-passes=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-PASS
+// RUN: %clang -target powerpc-ibm-aix -### -o FOO -fuse-ld=ld -flto -fdiagnostics-hotness-threshold=100 -fsave-optimization-record -foptimization-record-passes=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-AIX-PASS
 // RUN: %clang -target x86_64-linux -### -o FOO -fuse-ld=lld -flto=thin -fdiagnostics-hotness-threshold=100 -fsave-optimization-record=some-format -foptimization-record-file=FOO.txt %s 2>&1 | FileCheck %s -check-prefix=CHECK-PASS-CUSTOM
+// RUN: %clang -target powerpc-ibm-aix -### -o FOO -fuse-ld=ld -flto=full -fdiagnostics-hotness-threshold=100 -fsave-optimization-record=some-format -foptimization-record-file=FOO.txt %s 2>&1 | FileCheck %s -check-prefix=CHECK-AIX-PASS-CUSTOM
 // RUN: %clang -target x86_64-linux -### -o FOO -fuse-ld=lld -flto=thin -fdiagnostics-hotness-threshold=100 -Rpass=inline -Rpass-missed=inline -Rpass-analysis=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-PASS-RPASS
+// RUN: %clang -target powerpc-ibm-aix -### -o FOO -fuse-ld=ld -flto=full -fdiagnostics-hotness-threshold=100 -Rpass=inline -Rpass-missed=inline -Rpass-analysis=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-AIX-PASS-RPASS
 // RUN: %clang -target x86_64-linux -### -o FOO -fuse-ld=lld -flto=thin -fdiagnostics-hotness-threshold=auto -Rpass=inline -Rpass-missed=inline -Rpass-analysis=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-PASS-AUTO
+// RUN: %clang -target powerpc-ibm-aix -### -o FOO -fuse-ld=ld -flto=full -fdiagnostics-hotness-threshold=auto -Rpass=inline -Rpass-missed=inline -Rpass-analysis=inline %s 2>&1 | FileCheck %s -check-prefix=CHECK-AIX-PASS-AUTO
 
 // CHECK-NOPASS-NOT: "-plugin-opt=opt-remarks-filename="
 // CHECK-NOPASS-NOT: "-plugin-opt=opt-remarks-passes=inline"
 // CHECK-NOPASS-NOT: "-plugin-opt=opt-remarks-format=yaml"
 // CHECK-NOPASS-NOT: "-plugin-opt=opt-remarks-hotness-threshold=100"
 
+// CHECK-AIX-NOPASS-NOT: "-bplugin_opt:-lto-pass-remarks-output="
+// CHECK-AIX-NOPASS-NOT: "-bplugin_opt:-lto-pass-remarks-filter=inline"
+// CHECK-AIX-NOPASS-NOT: "-bplugin_opt:-lto-pass-remarks-format=yaml"
+// CHECK-AIX-NOPASS-NOT: "-bplugin_opt:-lto-pass-remarks-hotness-threshold=100"
+
 // CHECK-PASS-A:      "-plugin-opt=opt-remarks-filename=a.out.opt.ld.yaml"
 // CHECK-PASS-A-SAME: "-plugin-opt=opt-remarks-passes=inline"
 // CHECK-PASS-A-SAME: "-plugin-opt=opt-remarks-format=yaml"
 // CHECK-PASS-A-SAME: "-plugin-opt=opt-remarks-hotness-threshold=100"
 
+// CHECK-AIX-PASS-A:      "-bplugin_opt:-lto-pass-remarks-output=a.out.opt.ld.yaml"
+// CHECK-AIX-PASS-A-SAME: "-bplugin_opt:-lto-pass-remarks-filter=inline"
+// CHECK-AIX-PASS-A-SAME: "-bplugin_opt:-lto-pass-remarks-format=yaml"
+// CHECK-AIX-PASS-A-SAME: "-bplugin_opt:-lto-pass-remarks-hotness-threshold=100"
+
 // CHECK-PASS:      "-plugin-opt=opt-remarks-filename=FOO.opt.ld.yaml"
 // CHECK-PASS-SAME: "-plugin-opt=opt-remarks-passes=inline"
 // CHECK-PASS-SAME: "-plugin-opt=opt-remarks-format=yaml"
 // CHECK-PASS-SAME: "-plugin-opt=opt-remarks-hotness-threshold=100"
 
+// CHECK-AIX-PASS:      "-bplugin_opt:-lto-pass-remarks-output=FOO.opt.ld.yaml"
+// CHECK-AIX-PASS-SAME: "-bplugin_opt:-lto-pass-remarks-filter=inline"
+// CHECK-AIX-PASS-SAME: "-bplugin_opt:-lto-pass-remarks-format=yaml"
+// CHECK-AIX-PASS-SAME: "-bplugin_opt:-lto-pass-remarks-hotness-threshold=100"
+
 // CHECK-PASS-CUSTOM:      "-plugin-opt=opt-remarks-filename=FOO.txt.opt.ld.some-format"
 // CHECK-PASS-CUSTOM-SAME: "-plugin-opt=opt-remarks-format=some-format"
 // CHECK-PASS-CUSTOM-SAME: "-plugin-opt=opt-remarks-hotness-threshold=100"
 
+// CHECK-AIX-PASS-CUSTOM:      "-bplugin_opt:-lto-pass-remarks-output=FOO.txt.opt.ld.some-format"
+// CHECK-AIX-PASS-CUSTOM-SAME: "-bplugin_opt:-lto-pass-remarks-format=some-format"
+// CHECK-AIX-PASS-CUSTOM-SAME: "-bplugin_opt:-lto-pass-remarks-hotness-threshold=100"
+
 // CHECK-PASS-RPASS:      "-plugin-opt=-pass-remarks=inline"
 // CHECK-PASS-RPASS-SAME: "-plugin-opt=-pass-remarks-missed=inline"
 // CHECK-PASS-RPASS-SAME: "-plugin-opt=-pass-remarks-analysis=inline"
 // CHECK-PASS-RPASS-SAME: "-plugin-opt=opt-remarks-hotness-threshold=100"
 
+// CHECK-AIX-PASS-RPASS:      "-bplugin_opt:-pass-remarks=inline"
+// CHECK-AIX-PASS-RPASS-SAME: "-bplugin_opt:-pass-remarks-missed=inline"
+// CHECK-AIX-PASS-RPASS-SAME: "-bplugin_opt:-pass-remarks-analysis=inline"
+// CHECK-AIX-PASS-RPASS-SAME: "-bplugin_opt:-lto-pass-remarks-hotness-threshold=100"
+
 // CHECK-PASS-AUTO:   "-plugin-opt=opt-remarks-hotness-threshold=auto"
+// CHECK-AIX-PASS-AUTO:   "-bplugin_opt:-lto-pass-remarks-hotness-threshold=auto"