[Driver] Add -print-multiarch-triple

[phosek]

Summary

This is useful in runtimes build for example which currently try to
guess the correct triple where to place libraries in the multiarch
layout. Using this flag, the build system can get the correct triple
directly by querying Clang.

[MaskRay]

gcc has --print-multiarch. Just use --print-multiarch? I think our semantics are compatible.

It seems odd to have print-runtime-dir tests in immediate-options.c. The tests should be moved to a print-* file.

[phosek]

In D101400#2720954, @MaskRay wrote:

gcc has --print-multiarch. Just use --print-multiarch? I think our semantics are compatible.

I wasn't aware that GCC already has this option but using the same spelling definitely makes sense.

It seems odd to have print-runtime-dir tests in immediate-options.c. The tests should be moved to a print-* file.

I can move it in a separate change.

[MaskRay]

LG

clang/test/Driver/print-multiarch.c

5 ↗

(On Diff #341001)

--match-full-lines --strict-whitespace or use {{^}}x86_64-linux-gnu{{$}}

[jrtc27]

This includes the version number, at least for FreeBSD, in its output, which doesn't make a huge deal of sense to me. This then breaks the build of Python because it generates a module with a name like _sysconfigdata__freebsd14_x86_64-unknown-freebsd14.0.py, and when it comes to import that as _sysconfigdata__freebsd14_x86_64-unknown-freebsd14.0 which breaks because that gets parsed as something like "import 0 from _sysconfigdata__freebsd14_x86_64-unknown-freebsd14". Of course, the Python code is bad here, it shouldn't be failing like that, but given the use case for --print-multiarch it seems to me that the version number shouldn't be included? Does GCC take a stance on this?

[jrtc27]

Answering the last part myself: GCC only has MULTIARCH_DIRNAME definitions for various linux-gnu*, linux-musl, linux-uclibc, kfreebsd-gnu and -gnu (as an OS, for GNU/Hurd) targets, everything else prints a blank string here. So either we need to decide what the right behaviour is for other OSes, or we should similarly leave it as undefined for non-GNUish (including musl and uclibc) targets?

[MaskRay]

In D101400#2990254, @jrtc27 wrote:

Answering the last part myself: GCC only has MULTIARCH_DIRNAME definitions for various linux-gnu*, linux-musl, linux-uclibc, kfreebsd-gnu and -gnu (as an OS, for GNU/Hurd) targets, everything else prints a blank string here. So either we need to decide what the right behaviour is for other OSes, or we should similarly leave it as undefined for non-GNUish (including musl and uclibc) targets?

Looks like --print-multiarch is not used in llvm-project. I created D133170 to unsupport the option.

clang/include/clang/Driver/Options.td

 def print_multi_directory : Flag<["-", "--"], "print-multi-directory">;
 def print_multi_lib : Flag<["-", "--"], "print-multi-lib">;
 def print_multi_os_directory : Flag<["-", "--"], "print-multi-os-directory">,
   Flags<[Unsupported]>;
 def print_target_triple : Flag<["-", "--"], "print-target-triple">,
   HelpText<"Print the normalized target triple">;
 def print_effective_triple : Flag<["-", "--"], "print-effective-triple">,
   HelpText<"Print the effective target triple">;
+def print_multiarch_triple : Flag<["-", "--"], "print-multiarch-triple">,
+  HelpText<"Print the multiarch target triple">;
 def print_prog_name_EQ : Joined<["-", "--"], "print-prog-name=">,
   HelpText<"Print the full program path of <name>">, MetaVarName<"<name>">;
 def print_resource_dir : Flag<["-", "--"], "print-resource-dir">,
   HelpText<"Print the resource directory pathname">;
 def print_search_dirs : Flag<["-", "--"], "print-search-dirs">,
   HelpText<"Print the paths used for finding libraries and programs">;
 def print_targets : Flag<["-", "--"], "print-targets">,
   HelpText<"Print the registered targets">;

clang/include/clang/Driver/ToolChain.h

protected:
 
   void setTripleEnvironment(llvm::Triple::EnvironmentType Env);
 
   virtual Tool *buildAssembler() const;
   virtual Tool *buildLinker() const;
   virtual Tool *buildStaticLibTool() const;
   virtual Tool *getTool(Action::ActionClass AC) const;
 
-  virtual std::string getMultiarchTriple(const Driver &D,
-                                         const llvm::Triple &TargetTriple,
-                                         StringRef SysRoot) const {
-    return TargetTriple.str();
-  }
-
   virtual std::string buildCompilerRTBasename(const llvm::opt::ArgList &Args,
                                               StringRef Component,
                                               FileType Type,
                                               bool AddArch) const;
 
   /// \name Utilities for implementing subclasses.
   ///@{
   static void addSystemInclude(const llvm::opt::ArgList &DriverArgs,
public:
   virtual bool SupportsEmbeddedBitcode() const { return false; }
 
   /// getThreadModel() - Which thread model does this target use?
   virtual std::string getThreadModel() const { return "posix"; }
 
   /// isThreadModelSupported() - Does this target support a thread model?
   virtual bool isThreadModelSupported(const StringRef Model) const;
 
+  virtual std::string getMultiarchTriple(const Driver &D,
+                                         const llvm::Triple &TargetTriple,
+                                         StringRef SysRoot) const {
+    return TargetTriple.str();
+  }
+
   /// ComputeLLVMTriple - Return the LLVM target triple to use, after taking
   /// command line arguments into account.
   virtual std::string
   ComputeLLVMTriple(const llvm::opt::ArgList &Args,
                     types::ID InputType = types::TY_INVALID) const;
 
   /// ComputeEffectiveClangTriple - Return the Clang triple to use for this
   /// target, which may take into account the command line arguments. For

clang/lib/Driver/Driver.cpp

bool Driver::HandleImmediateArgs(const Compilation &C) {
   }
 
   if (C.getArgs().hasArg(options::OPT_print_effective_triple)) {
     const llvm::Triple Triple(TC.ComputeEffectiveClangTriple(C.getArgs()));
     llvm::outs() << Triple.getTriple() << "\n";
     return false;
   }
 
+  if (C.getArgs().hasArg(options::OPT_print_multiarch_triple)) {
+    llvm::outs() << TC.getMultiarchTriple(*this, TC.getTriple(), SysRoot)
+                 << "\n";
+    return false;
+  }
+
   if (C.getArgs().hasArg(options::OPT_print_targets)) {
     llvm::TargetRegistry::printRegisteredTargetsForVersion(llvm::outs());
     return false;
   }
 
   return true;
 }
 

clang/lib/Driver/ToolChains/Fuchsia.h

llvm::DebuggerKind getDefaultDebuggerTuning() const override {
     return llvm::DebuggerKind::GDB;
   }
 
   LangOptions::StackProtectorMode
   GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
     return LangOptions::SSPStrong;
   }
 
+  std::string getMultiarchTriple(const Driver &D,
+                                 const llvm::Triple &TargetTriple,
+                                 StringRef SysRoot) const override;
+
   std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args,
                                           types::ID InputType) const override;
 
   SanitizerMask getSupportedSanitizers() const override;
   SanitizerMask getDefaultSanitizers() const override;
 
   void addProfileRTLibs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const override;
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const override;
 
   const char *getDefaultLinker() const override {
     return "ld.lld";
   }
 
 protected:
   Tool *buildLinker() const override;
-
-  std::string getMultiarchTriple(const Driver &D,
-                                 const llvm::Triple &TargetTriple,
-                                 StringRef SysRoot) const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_FUCHSIA_H

clang/lib/Driver/ToolChains/Linux.h

 
 class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
 public:
   Linux(const Driver &D, const llvm::Triple &Triple,
         const llvm::opt::ArgList &Args);
 
   bool HasNativeLLVMSupport() const override;
 
+  std::string getMultiarchTriple(const Driver &D,
+                                 const llvm::Triple &TargetTriple,
+                                 StringRef SysRoot) const override;
+
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
   void addLibStdCxxIncludePaths(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                           llvm::opt::ArgStringList &CC1Args) const override;
public:
   llvm::DenormalMode getDefaultDenormalModeForType(
       const llvm::opt::ArgList &DriverArgs, const JobAction &JA,
       const llvm::fltSemantics *FPType = nullptr) const override;
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
   Tool *buildStaticLibTool() const override;
-
-  std::string getMultiarchTriple(const Driver &D,
-                                 const llvm::Triple &TargetTriple,
-                                 StringRef SysRoot) const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_LINUX_H

clang/test/Driver/immediate-options.c

 // RUN:      | FileCheck --check-prefix=PRINT-RUNTIME-DIR %s
 // PRINT-RUNTIME-DIR: lib{{/|\\}}windows
 
 // Per target dir layout
 // RUN: %clang -print-runtime-dir --target=x86_64-pc-windows-msvc \
 // RUN:        -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir \
 // RUN:      | FileCheck --check-prefix=PRINT-RUNTIME-DIR-PER-TARGET %s
 // PRINT-RUNTIME-DIR-PER-TARGET: lib{{/|\\}}x86_64-pc-windows-msvc
+
+// RUN: %clang -print-multiarch-triple --target=x86_64-unknown-linux-gnu \
+// RUN:        -resource-dir=%S/Inputs/resource_dir \
+// RUN:      | FileCheck --check-prefix=PRINT-MULTIARCH-TRIPLE %s
+// PRINT-MULTIARCH-TRIPLE: x86_64-linux-gnu