Add AIX Target/ToolChain to Clang Driver

[apaprocki]

Summary

This patch adds Clang driver support for the AIX platform. This allows Clang to be used for compiling code / checking for errors, but does not allow for building executables, as AIX uses XCOFF and not ELF.

After applying this patch and the underlying D18359:

$ clang -v
clang version 3.8.0 (tags/RELEASE_380/final)
Target: powerpc-ibm-aix7.1.0.0
Thread model: posix
InstalledDir: /tmp/llvm-3.8/bin
Found candidate GCC installation: /tmp/gcc-4.8/lib/gcc/powerpc-ibm-aix7.1.0.0/4.8.5
Selected GCC installation: /tmp/gcc-4.8/lib/gcc/powerpc-ibm-aix7.1.0.0/4.8.5
Candidate multilib: .;@maix32
Candidate multilib: ppc64;@maix64
Selected multilib: .;@maix32

[• WuZhao]

Hi , I find one mistake in the lib/Basic/Targets.cpp. On my AIX 7.1 machine /usr/include/sys/inttypes.h, 64 bits wchar_t is unsigned int, not signed int.

#ifndef _WCHAR_T
#define _WCHAR_T
#ifdef __64BIT__
typedef unsigned int    wchar_t;
#else
typedef unsigned short  wchar_t;
#endif
#endif /* _WCHAR_T */

So, the code should be

if (this->PointerWidth == 64) {
  this->WCharType = this->UnsignedInt;
} else {
  this->WCharType = this->UnsignedShort;
}

[apaprocki]

Fixed wchar_t type.

[apaprocki]

(I also re-based the patch on top of trunk)

[majnemer]

lib/Basic/Targets.cpp

718

Are we really supposed to define this macro? Does GCC define this? I cannot find where it does so in the source.

[apaprocki]

lib/Basic/Targets.cpp

718

I defined both _ALL_SOURCE and _REENTRANT because the SolarisTargetInfo defines them (__EXTENSIONS__ is the Solaris equivalent of _ALL_SOURCE). If that is an oversight in the Solaris work, I'll remove _ALL_SOURCE here. GCC does not define it by default.

[majnemer]

lib/Basic/Targets.cpp

718

After a closer examination of the gcc sources, it looks like ALL_SOURCE is defined if gcc is being used for C++ code (via CPLUSPLUS_CPP_SPEC).

I don't see where _REENTRANT is defined for AIX though...

[apaprocki]

lib/Basic/Targets.cpp

718

On AIX, when gcc is passed -pthread, it defines _THREAD_SAFE. I think this should be changed to

if (Opts.POSIXThreads)
  Builder.defineMacro("_THREAD_SAFE");

On Solaris, gcc defines _REENTRANT when -pthread is passed. I think it is a separate bug (and I can file a separate revision) to put the Solaris use of it also on an Opts.POSIXThreads check.

[majnemer]

Could you please attach a diff with additional context?

lib/Driver/ToolChains.cpp

3717–3735

If I am not mistaken, this change seem unrelated.

[apaprocki]

Increased context and removed accidental inclusion of Solaris change.

[majnemer]

LGTM

[• WuZhao]

I wan to point to some issues, because I am also doing AIX support based on your patch and I tested and verified.

Firstly, in the lib/Driver/ToolChains.cpp line 3756

case llvm::Triple::ppc64:
  addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib64", Paths);
  addPathIfExists(D, getDriver().SysRoot + "/usr/lib64", Paths);
  break;

In fact, in AIX there is no /usr/lib64, we only have /usr/lib and crt0.o for 32 bits, crt0_64.o for 64 bits. We also have crti.o / crti_64.o for C++.

Secondly, we should also define _AIX71 for AIX 7.1 in the lib/Basic/Targets.cpp.

Thirdly, the linker construct job has many issues (maybe because you have not supported code generation) in the lib/Driver/Tools.cpp, AIX has much difference with Solaris in fact.

we should code like this:

 if (Args.hasArg(options::OPT_shared)) {
   CmdArgs.push_back("-bM:SRE");
   CmdArgs.push_back("-bnoentry");
 }
 
 if (Args.hasArg(options::OPT_static)) {
   CmdArgs.push_back("-bnso");
   CmdArgs.push_back("-bI:/lib/syscalls.exp");
}

.......

I will try my best to complete linker work and so on based on your patch.

I notice that one thing, you define _THREAD_SAFE for posix thread, it is right. In AIX, we do not have _REENTRANT.

Lastly, you should be careful one thing: In AIX, when we use -pthread option, gcc standard headers directory and linker directory is changed. You should consider this. You can try gcc -pthread -v to see the output.

In collusion, this patch has some work to do in AIX from the view of my point.

[hubert.reinterpretcast]

@apaprocki, as mentioned in our recent RFC ( http://lists.llvm.org/pipermail/llvm-dev/2019-February/130175.html ), IBM is working on AIX support for Clang and LLVM. We would like to continue the work on this patch; however, as you may be aware, LLVM is undergoing relicensing ( https://llvm.org/docs/DeveloperPolicy.html#relicensing ). As such, we would like to know whether this patch is available under the terms of the Apache 2.0 License with LLVM exceptions. Thanks.

[apaprocki]

@hubert.reinterpretcast Yes, this patch is available under the new license.

[hubert.reinterpretcast]

In D18360#1406455, @apaprocki wrote:

@hubert.reinterpretcast Yes, this patch is available under the new license.

Thank you, @apaprocki. We will be splitting this into updated and more granular patches.

[hubert.reinterpretcast]

D59048 has been posted with some initial OSTargetInfo changes. Noticeable differences include not defining _ALL_SOURCE and focus on 64-bit long double. This is consistent with the invocation provided with the recent v16.1 release of the IBM XL C/C++ compiler for AIX that incorporates Clang-based technology.

[shafik]

@hubert.reinterpretcast is this still relevant? It looks like portions of this have landed, can we close it?

lib/Basic/Targets.cpp

     Builder.defineMacro("_REENTRANT");
   }
 public:
   SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : OSTargetInfo<Target>(Triple, Opts) {
     this->WCharType = this->SignedInt;
     // FIXME: WIntType should be SignedLong
   }
 };
 
+// AIX Target
+template <typename Target>
+class AIXTargetInfo : public OSTargetInfo<Target> {
+protected:
+  void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
+                    MacroBuilder &Builder) const override {
+    DefineStd(Builder, "unix", Opts);
+    Builder.defineMacro("_IBMR2");
+    Builder.defineMacro("_POWER");
+    Builder.defineMacro("_AIX");
+    Builder.defineMacro("_AIX32");
+    Builder.defineMacro("_AIX41");
+    Builder.defineMacro("_AIX43");
+    Builder.defineMacro("_AIX51");
+    Builder.defineMacro("_AIX52");
+    Builder.defineMacro("_AIX53");
+    Builder.defineMacro("_AIX61");
+    Builder.defineMacro("_LONG_LONG");
+    // GCC only defines this when compiling C++ code.
+    if (Opts.CPlusPlus) {
+      Builder.defineMacro("_ALL_SOURCE");
+    }
+    if (Opts.POSIXThreads) {
+      Builder.defineMacro("_THREAD_SAFE");
+    }
+    if (this->PointerWidth == 64) {
+      Builder.defineMacro("__64BIT__");
+    }
+  }
+
+public:
+  AIXTargetInfo(const llvm::Triple &Triple)
+      : OSTargetInfo<Target>(Triple) {
+    this->UserLabelPrefix = "";
+    if (this->PointerWidth == 64) {
+      this->WCharType = this->UnsignedInt;
+    } else {
+      this->WCharType = this->UnsignedShort;
+    }
+  }
+};
+
 // Windows target
 template<typename Target>
 class WindowsTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     Builder.defineMacro("_WIN32");
   }
   void getVisualStudioDefines(const LangOptions &Opts,
                               MacroBuilder &Builder) const {

   if (ABI == "elfv1" || ABI == "elfv1-qpx")
     Builder.defineMacro("_CALL_ELF", "1");
   if (ABI == "elfv2")
     Builder.defineMacro("_CALL_ELF", "2");
 
   // Subtarget options.
   Builder.defineMacro("__NATURAL_ALIGNMENT__");
   Builder.defineMacro("__REGISTER_PREFIX__", "");
 
   // FIXME: Should be controlled by command line option.
-  if (LongDoubleWidth == 128)
+  if (LongDoubleWidth == 128) {
     Builder.defineMacro("__LONG_DOUBLE_128__");
+    Builder.defineMacro("__LONGDOUBLE128");
+  }
 
   if (Opts.AltiVec) {
     Builder.defineMacro("__VEC__", "10206");
     Builder.defineMacro("__ALTIVEC__");
   }
 
   // CPU identification.
   ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
     .Case("440",   ArchDefineName)
     .Case("450",   ArchDefineName | ArchDefine440)

     resetDataLayout("E-m:e-p:32:32-i64:64-n32");
 
     switch (getTriple().getOS()) {
     case llvm::Triple::Linux:
     case llvm::Triple::FreeBSD:
     case llvm::Triple::NetBSD:
       SizeType = UnsignedInt;
       PtrDiffType = SignedInt;
       IntPtrType = SignedInt;
       break;
+    case llvm::Triple::AIX:
+      SizeType = UnsignedLong;
+      PtrDiffType = SignedLong;
+      IntPtrType = SignedLong;
     default:
       break;
     }
 
     if (getTriple().getOS() == llvm::Triple::FreeBSD) {
       LongDoubleWidth = LongDoubleAlign = 64;
       LongDoubleFormat = &llvm::APFloat::IEEEdouble;
     }
 
     // PPC32 supports atomics up to 4 bytes.

     case llvm::Triple::Linux:
       return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
     case llvm::Triple::OpenBSD:
       return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
     case llvm::Triple::RTEMS:
       return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts);
+    case llvm::Triple::AIX:
+      return new AIXTargetInfo<PPC32TargetInfo>(Triple);
     default:
       return new PPC32TargetInfo(Triple, Opts);
     }
 
   case llvm::Triple::ppc64:
     if (Triple.isOSDarwin())
       return new DarwinPPC64TargetInfo(Triple, Opts);
     switch (os) {
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
     case llvm::Triple::Lv2:
       return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts);
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
+    case llvm::Triple::AIX:
+      return new AIXTargetInfo<PPC64TargetInfo>(Triple);
     default:
       return new PPC64TargetInfo(Triple, Opts);
     }
 
   case llvm::Triple::ppc64le:
     switch (os) {
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);

lib/Driver/Driver.cpp

         TC = new toolchains::MipsLLVMToolChain(*this, Target, Args);
       else
         TC = new toolchains::Linux(*this, Target, Args);
       break;
     case llvm::Triple::NaCl:
       TC = new toolchains::NaClToolChain(*this, Target, Args);
       break;
     case llvm::Triple::Solaris:
       TC = new toolchains::Solaris(*this, Target, Args);
       break;
+    case llvm::Triple::AIX:
+      TC = new toolchains::AIX(*this, Target, Args);
+      break;
     case llvm::Triple::AMDHSA:
       TC = new toolchains::AMDGPUToolChain(*this, Target, Args);
       break;
     case llvm::Triple::Win32:
       switch (Target.getEnvironment()) {
       default:
         if (Target.isOSBinFormatELF())
           TC = new toolchains::Generic_ELF(*this, Target, Args);
         else if (Target.isOSBinFormatMachO())
           TC = new toolchains::MachO(*this, Target, Args);

lib/Driver/ToolChains.h

       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
 
   unsigned GetDefaultDwarfVersion() const override { return 2; }
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 };
 
+class LLVM_LIBRARY_VISIBILITY AIX : public Generic_GCC {
+public:
+  AIX(const Driver &D, const llvm::Triple &Triple,
+      const llvm::opt::ArgList &Args);
+
+  bool IsIntegratedAssemblerDefault() const override { return true; }
+
+  void AddClangCXXStdlibIncludeArgs(
+      const llvm::opt::ArgList &DriverArgs,
+      llvm::opt::ArgStringList &CC1Args) const override;
+
+  unsigned GetDefaultDwarfVersion() const override { return 2; }
+
+protected:
+  Tool *buildAssembler() const override;
+  Tool *buildLinker() const override;
+};
+
 class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain {
 public:
   MinGW(const Driver &D, const llvm::Triple &Triple,
         const llvm::opt::ArgList &Args);
 
   bool IsIntegratedAssemblerDefault() const override;
   bool IsUnwindTablesDefault() const override;
   bool isPICDefault() const override;
   bool isPIEDefault() const override;
   bool isPICDefaultForced() const override;

lib/Driver/ToolChains.cpp

   bool IsArmV7Mode = (IsArmArch || IsThumbArch) &&
       (llvm::ARM::parseArchVersion(Arch) == 7 ||
        (IsArmArch && Arch == "" && IsV7SubArch));
   addMultilibFlag(IsArmV7Mode, "armv7", Flags);
   addMultilibFlag(IsThumbMode, "thumb", Flags);
 
   if (AndroidArmMultilibs.select(Flags, Result.SelectedMultilib))
     Result.Multilibs = AndroidArmMultilibs;
 }
 
+static bool findAIXBiarchMultilibs(const Driver &D,
+                                   const llvm::Triple &TargetTriple,
+                                   StringRef Path, const ArgList &Args,
+                                   bool NeedsBiarchSuffix,
+                                   DetectedMultilibs &Result) {
+  Multilib Default = Multilib()
+                       .flag("+maix32")
+                       .flag("-maix64");
+  Multilib Alt64 = Multilib()
+                       .gccSuffix("/ppc64")
+                       .includeSuffix("/ppc64")
+                       .flag("-maix32")
+                       .flag("+maix64");
+
+  FilterNonExistent NonExistent(Path, "/crtcxa.o", D.getVFS());
+
+  Result.Multilibs.push_back(Default);
+  Result.Multilibs.push_back(Alt64);
+
+  Result.Multilibs.FilterOut(NonExistent);
+
+  Multilib::flags_list Flags;
+  addMultilibFlag(TargetTriple.isArch64Bit(), "maix64", Flags);
+  addMultilibFlag(TargetTriple.isArch32Bit(), "maix32", Flags);
+
+  if (!Result.Multilibs.select(Flags, Result.SelectedMultilib))
+    return false;
+
+  if (Result.SelectedMultilib == Alt64)
+    Result.BiarchSibling = Default;
+
+  return true;
+}
+
 static bool findBiarchMultilibs(const Driver &D,
                                 const llvm::Triple &TargetTriple,
                                 StringRef Path, const ArgList &Args,
                                 bool NeedsBiarchSuffix,
                                 DetectedMultilibs &Result) {
   // Some versions of SUSE and Fedora on ppc64 put 32-bit libs
   // in what would normally be GCCInstallPath and put the 64-bit
   // libs in a subdirectory named 64. The simple logic we follow is that
   // *if* there is a subdirectory of the right name with crtbegin.o in it,
   // we use that. If not, and if not a biarch triple alias, we look for

 
       // Android standalone toolchain could have multilibs for ARM and Thumb.
       // Debian mips multilibs behave more like the rest of the biarch ones,
       // so handle them there
       if (isArmOrThumbArch(TargetArch) && TargetTriple.isAndroid()) {
         // It should also work without multilibs in a simplified toolchain.
         findAndroidArmMultilibs(D, TargetTriple, LI->getName(), Args, Detected);
       } else if (isMipsArch(TargetArch)) {
         if (!findMIPSMultilibs(D, TargetTriple, LI->getName(), Args, Detected))
           continue;
+      } else if (TargetTriple.getOS() == llvm::Triple::AIX) {
+        if (!findAIXBiarchMultilibs(D, TargetTriple, LI->getName(), Args,
+                                    NeedsBiarchSuffix, Detected))
+          continue;
       } else if (!findBiarchMultilibs(D, TargetTriple, LI->getName(), Args,
                                       NeedsBiarchSuffix, Detected)) {
         continue;
       }
 
       Multilibs = Detected.Multilibs;
       SelectedMultilib = Detected.SelectedMultilib;
       BiarchSibling = Detected.BiarchSibling;
       Version = CandidateVersion;
       GCCTriple.setTriple(CandidateTriple);

                      Version.MinorStr +
                      "/include/c++/" + Version.Text);
     addSystemInclude(DriverArgs, CC1Args,
                      getDriver().SysRoot + "/usr/gcc/" + Version.MajorStr +
                      "." + Version.MinorStr + "/include/c++/" +
                      Version.Text + "/" +
                      GCCInstallation.getTriple().str());
   }
 }
 
+/// AIX - AIX tool chain which can call as(1) and ld(1) directly.
+
+AIX::AIX(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
+    : Generic_GCC(D, Triple, Args) {
+
+  GCCInstallation.init(Triple, Args);
+
+  path_list &Paths = getFilePaths();
+  if (GCCInstallation.isValid()) {
+    addPathIfExists(D, GCCInstallation.getInstallPath(), Paths);
+    addPathIfExists(D, GCCInstallation.getParentLibPath(), Paths);
+  }
+
+  addPathIfExists(D, getDriver().getInstalledDir(), Paths);
+  if (getDriver().getInstalledDir() != getDriver().Dir)
+    addPathIfExists(D, getDriver().Dir, Paths);
+
+  switch (Triple.getArch()) {
+  case llvm::Triple::ppc:
+    addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib", Paths);
+    addPathIfExists(D, getDriver().SysRoot + "/usr/lib", Paths);
+    break;
+  case llvm::Triple::ppc64:
+    addPathIfExists(D, getDriver().SysRoot + getDriver().Dir + "/../lib64", Paths);
+    addPathIfExists(D, getDriver().SysRoot + "/usr/lib64", Paths);
+    break;
+  default:
+    llvm_unreachable("Unsupported architecture");
+  }
+}
+
+Tool *AIX::buildAssembler() const { return new tools::aix::Assembler(*this); }
+
+Tool *AIX::buildLinker() const { return new tools::aix::Linker(*this); }
+
+void AIX::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
+                                       ArgStringList &CC1Args) const {
+  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+      DriverArgs.hasArg(options::OPT_nostdincxx))
+    return;
+
+  // We need a detected GCC installation on Linux to provide libstdc++'s
+  // headers. We handled the libc++ case above.
+  if (!GCCInstallation.isValid())
+    return;
+
+  // By default, look for the C++ headers in an include directory adjacent to
+  // the lib directory of the GCC installation. Note that this is expect to be
+  // equivalent to '/usr/include/c++/X.Y' in almost all cases.
+  StringRef LibDir = GCCInstallation.getParentLibPath();
+  StringRef TripleStr = GCCInstallation.getTriple().str();
+  const Multilib &Multilib = GCCInstallation.getMultilib();
+  const GCCVersion &Version = GCCInstallation.getVersion();
+
+  // The primary search for libstdc++ supports multiarch variants.
+  addLibStdCXXIncludePaths(LibDir.str() + "/../include",
+                           "/c++/" + Version.Text, TripleStr,
+                           /*GCCMultiarchTriple*/ "",
+                           /*TargetMultiarchTriple*/ "",
+                           Multilib.includeSuffix(), DriverArgs, CC1Args);
+}
+
 /// Distribution (very bare-bones at the moment).
 
 enum Distro {
   // NB: Releases of a particular Linux distro should be kept together
   // in this enum, because some tests are done by integer comparison against
   // the first and last known member in the family, e.g. IsRedHat().
   ArchLinux,
   DebianLenny,
   DebianSqueeze,
   DebianWheezy,

lib/Driver/Tools.h

   bool hasIntegratedCPP() const override { return false; }
   bool isLinkJob() const override { return true; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,
                     const char *LinkingOutput) const override;
 };
 } // end namespace solaris
 
+/// aix -- Directly call AIX assembler and linker
+namespace aix {
+class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+public:
+  Assembler(const ToolChain &TC) : Tool("aix::Assembler", "assembler", TC) {}
+
+  bool hasIntegratedCPP() const override { return false; }
+
+  void ConstructJob(Compilation &C, const JobAction &JA,
+                    const InputInfo &Output, const InputInfoList &Inputs,
+                    const llvm::opt::ArgList &TCArgs,
+                    const char *LinkingOutput) const override;
+};
+
+class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+public:
+  Linker(const ToolChain &TC) : Tool("aix::Linker", "linker", TC) {}
+
+  bool hasIntegratedCPP() const override { return false; }
+  bool isLinkJob() const override { return true; }
+
+  void ConstructJob(Compilation &C, const JobAction &JA,
+                    const InputInfo &Output, const InputInfoList &Inputs,
+                    const llvm::opt::ArgList &TCArgs,
+                    const char *LinkingOutput) const override;
+};
+}  // end namespace aix
+
 /// dragonfly -- Directly call GNU Binutils assembler and linker
 namespace dragonfly {
 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
 public:
   Assembler(const ToolChain &TC)
       : GnuTool("dragonfly::Assembler", "assembler", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
 
   void ConstructJob(Compilation &C, const JobAction &JA,

lib/Driver/Tools.cpp

     }
   } else if (!isSignedCharDefault(getToolChain().getTriple())) {
     CmdArgs.push_back("-fno-signed-char");
   }
 
   // -fuse-cxa-atexit is default.
   if (!Args.hasFlag(
           options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
           !IsWindowsCygnus && !IsWindowsGNU &&
               getToolChain().getTriple().getOS() != llvm::Triple::Solaris &&
+              getToolChain().getTriple().getOS() != llvm::Triple::AIX &&
               getToolChain().getArch() != llvm::Triple::hexagon &&
               getToolChain().getArch() != llvm::Triple::xcore &&
               ((getToolChain().getTriple().getVendor() !=
                 llvm::Triple::MipsTechnologies) ||
                getToolChain().getTriple().hasEnvironment())) ||
       KernelOrKext)
     CmdArgs.push_back("-fno-use-cxa-atexit");
 
   // -fms-extensions=0 is default.
   if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions,

         Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
   }
   CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
 
   getToolChain().addProfileRTLibs(Args, CmdArgs);
 
   const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
+void aix::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
+                                  const InputInfo &Output,
+                                  const InputInfoList &Inputs,
+                                  const ArgList &Args,
+                                  const char *LinkingOutput) const {
+  claimNoWarnArgs(Args);
+  ArgStringList CmdArgs;
+
+  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
+
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Output.getFilename());
+
+  for (const auto &II : Inputs)
+    CmdArgs.push_back(II.getFilename());
+
+  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
+void aix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
+                               const InputInfo &Output,
+                               const InputInfoList &Inputs,
+                               const ArgList &Args,
+                               const char *LinkingOutput) const {
+  ArgStringList CmdArgs;
+
+  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_shared)) {
+    CmdArgs.push_back("-e_start");
+  }
+
+  CmdArgs.push_back("-bsvr4");
+
+  if (Args.hasArg(options::OPT_static)) {
+    CmdArgs.push_back("-dn");
+  } else {
+    CmdArgs.push_back("-dy");
+    if (Args.hasArg(options::OPT_shared)) {
+      CmdArgs.push_back("-G");
+    } else {
+      CmdArgs.push_back("-brtl");
+    }
+  }
+
+  if (Output.isFilename()) {
+    CmdArgs.push_back("-o");
+    CmdArgs.push_back(Output.getFilename());
+  } else {
+    assert(Output.isNothing() && "Invalid output.");
+  }
+
+  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
+    if (Args.hasArg(options::OPT_shared))
+      CmdArgs.push_back(
+          Args.MakeArgString(getToolChain().GetFilePath("crtcxa_s.o")));
+    else
+      CmdArgs.push_back(
+          Args.MakeArgString(getToolChain().GetFilePath("crtcxa.o")));
+  }
+
+  getToolChain().AddFilePathLibArgs(Args, CmdArgs);
+
+  Args.AddAllArgs(CmdArgs, {options::OPT_L, options::OPT_T_Group,
+                            options::OPT_e, options::OPT_r});
+
+  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
+
+  if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
+    if (getToolChain().getDriver().CCCIsCXX())
+      getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
+    CmdArgs.push_back("-lc");
+    if (!Args.hasArg(options::OPT_shared)) {
+      CmdArgs.push_back("-lm");
+    }
+    if (Args.hasArg(options::OPT_shared)) {
+      CmdArgs.push_back("-lgcc_s");
+    } else {
+      CmdArgs.push_back("-lgcc");
+      CmdArgs.push_back("-lgcc_eh");
+    }
+  }
+
+  getToolChain().addProfileRTLibs(Args, CmdArgs);
+
+  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
 void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,
                                       const InputInfoList &Inputs,
                                       const ArgList &Args,
                                       const char *LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   switch (getToolChain().getArch()) {
   case llvm::Triple::x86:

tools/libclang/CIndexer.cpp

 #include <vector>
 
 #ifdef __CYGWIN__
 #include <cygwin/version.h>
 #include <sys/cygwin.h>
 #define LLVM_ON_WIN32 1
 #endif
 
 #ifdef LLVM_ON_WIN32
 #include <windows.h>
+#elif defined(_AIX)
+#include <sys/param.h>
+#include <stdio.h>
+#include <unistd.h>
 #else
 #include <dlfcn.h>
 #endif
 
 using namespace clang;
 
+#ifdef _AIX
+static int
+test_dir(char ret[PATH_MAX], const char *dir, const char *bin)
+{
+  struct stat sb;
+  char fullpath[PATH_MAX];
+
+  snprintf(fullpath, PATH_MAX, "%s/%s", dir, bin);
+  if (!realpath(fullpath, ret))
+    return 1;
+  if (stat(fullpath, &sb) != 0)
+    return 1;
+
+  return 0;
+}
+
+static char *
+getprogpath(char ret[PATH_MAX], const char *bin)
+{
+  char *pv, *s, *t;
+
+  /* First approach: absolute path. */
+  if (bin[0] == '/') {
+    if (test_dir(ret, "/", bin) == 0)
+      return ret;
+    return nullptr;
+  }
+
+  /* Second approach: relative path. */
+  if (strchr(bin, '/')) {
+    char cwd[PATH_MAX];
+    if (!getcwd(cwd, PATH_MAX))
+      return nullptr;
+    if (test_dir(ret, cwd, bin) == 0)
+      return ret;
+    return nullptr;
+  }
+
+  /* Third approach: $PATH */
+  if ((pv = getenv("PATH")) == nullptr)
+    return nullptr;
+  s = pv = strdup(pv);
+  if (!pv)
+    return nullptr;
+  while ((t = strsep(&s, ":")) != nullptr) {
+    if (test_dir(ret, t, bin) == 0) {
+      free(pv);
+      return ret;
+    }
+  }
+  free(pv);
+  return nullptr;
+}
+#endif
+
 const std::string &CIndexer::getClangResourcesPath() {
   // Did we already compute the path?
   if (!ResourcesPath.empty())
     return ResourcesPath;
 
   SmallString<128> LibClangPath;
 
   // Find the location where this library lives (libclang.dylib).
 #ifdef LLVM_ON_WIN32
   MEMORY_BASIC_INFORMATION mbi;

   char w32path[MAX_PATH];
   strcpy(w32path, path);
 #if CYGWIN_VERSION_API_MAJOR > 0 || CYGWIN_VERSION_API_MINOR >= 181
   cygwin_conv_path(CCP_WIN_A_TO_POSIX, w32path, path, MAX_PATH);
 #else
   cygwin_conv_to_full_posix_path(w32path, path);
 #endif
 #endif
 
   LibClangPath += llvm::sys::path::parent_path(path);
+#elif defined(_AIX)
+  extern char **argv;
+  char exe_path[MAXPATHLEN];
+  if (getprogpath(exe_path, argv[0]) != NULL)
+    LibClangPath += llvm::sys::path::parent_path(exe_path);
 #else
   // This silly cast below avoids a C++ warning.
   Dl_info info;
   if (dladdr((void *)(uintptr_t)clang_createTranslationUnit, &info) == 0)
     llvm_unreachable("Call to dladdr() failed");
 
   // We now have the CIndex directory, locate clang relative to it.
   LibClangPath += llvm::sys::path::parent_path(info.dli_fname);
 #endif