void FreeBSD::AddClangSystemIncludeArgs(const ArgList &DriverArgs,

                                      ArgStringList &CC1Args) const {

  const Driver &D = getDriver();

  if (DriverArgs.hasArg(options::OPT_nostdinc))

    return;

  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))

    addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include");

  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {

    llvm::sys::Path P(D.ResourceDir);

    P.appendComponent("include");

    addSystemInclude(DriverArgs, CC1Args, P.str());

  }

  if (DriverArgs.hasArg(options::OPT_nostdlibinc))

    return;

  // Check for configure-time C include directories.

  StringRef CIncludeDirs(C_INCLUDE_DIRS);

  if (CIncludeDirs != "") {

    SmallVector<StringRef, 5> dirs;

    CIncludeDirs.split(dirs, ":");

    for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end();

         I != E; ++I) {

      StringRef Prefix = llvm::sys::path::is_absolute(*I) ? D.SysRoot : "";

      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I);

    }

    return;

  }

  // Lacking those, try to detect the correct set of system includes for the

  // target triple.

  // Implement generic Debian multiarch support.

  const StringRef X86_64MultiarchIncludeDirs[] = {

    "/usr/include/x86_64-linux-gnu",

    // FIXME: These are older forms of multiarch. It's not clear that they're

    // in use in any released version of Debian, so we should consider

    // removing them.

    "/usr/include/i686-linux-gnu/64",

    "/usr/include/i486-linux-gnu/64"

  };

  const StringRef X86MultiarchIncludeDirs[] = {

    "/usr/include/i386-linux-gnu",

    // FIXME: These are older forms of multiarch. It's not clear that they're

    // in use in any released version of Debian, so we should consider

    // removing them.

    "/usr/include/x86_64-linux-gnu/32",

    "/usr/include/i686-linux-gnu",

    "/usr/include/i486-linux-gnu"

  };

  const StringRef ARMMultiarchIncludeDirs[] = {

    "/usr/include/arm-linux-gnueabi"

  };

  const StringRef MIPSMultiarchIncludeDirs[] = {

    "/usr/include/mips-linux-gnu"

  };

  const StringRef MIPSELMultiarchIncludeDirs[] = {

    "/usr/include/mipsel-linux-gnu"

  };

  const StringRef PPCMultiarchIncludeDirs[] = {

    "/usr/include/powerpc-linux-gnu"

  };

  const StringRef PPC64MultiarchIncludeDirs[] = {

    "/usr/include/powerpc64-linux-gnu"

  };

  ArrayRef<StringRef> MultiarchIncludeDirs;

  if (getTriple().getArch() == llvm::Triple::x86_64) {

    MultiarchIncludeDirs = X86_64MultiarchIncludeDirs;

  } else if (getTriple().getArch() == llvm::Triple::x86) {

    MultiarchIncludeDirs = X86MultiarchIncludeDirs;

  } else if (getTriple().getArch() == llvm::Triple::arm) {

    MultiarchIncludeDirs = ARMMultiarchIncludeDirs;

  } else if (getTriple().getArch() == llvm::Triple::mips) {

    MultiarchIncludeDirs = MIPSMultiarchIncludeDirs;

  } else if (getTriple().getArch() == llvm::Triple::mipsel) {

    MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs;

  } else if (getTriple().getArch() == llvm::Triple::ppc) {

    MultiarchIncludeDirs = PPCMultiarchIncludeDirs;

  } else if (getTriple().getArch() == llvm::Triple::ppc64) {

    MultiarchIncludeDirs = PPC64MultiarchIncludeDirs;

  }

  for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(),

                                     E = MultiarchIncludeDirs.end();

       I != E; ++I) {

    if (llvm::sys::fs::exists(D.SysRoot + *I)) {

      addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + *I);

      break;

    }

  }

  if (getTriple().getOS() == llvm::Triple::RTEMS)

    return;

  // Add an include of '/include' directly. This isn't provided by default by

  // system GCCs, but is often used with cross-compiling GCCs, and harmless to

  // add even when Clang is acting as-if it were a system compiler.

  addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/include");

  addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");

}

/// \brief Helper to add the thre variant paths for a libstdc++ installation.

/*static*/ bool FreeBSD::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,

                                                const ArgList &DriverArgs,

                                                ArgStringList &CC1Args) {

  if (!llvm::sys::fs::exists(Base))

    return false;

  addSystemInclude(DriverArgs, CC1Args, Base);

  addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir);

  addSystemInclude(DriverArgs, CC1Args, Base + "/backward");

  return true;

}

void FreeBSD::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,

                                         ArgStringList &CC1Args) const {

  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||

      DriverArgs.hasArg(options::OPT_nostdincxx))

    return;

  // Check if libc++ has been enabled and provide its include paths if so.

  if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {

    // libc++ is always installed at a fixed path on Linux currently.

    addSystemInclude(DriverArgs, CC1Args,

                     getDriver().SysRoot + "/usr/include/c++/v1");

    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 InstallDir = GCCInstallation.getInstallPath();

  StringRef Version = GCCInstallation.getVersion();

  if (!addLibStdCXXIncludePaths(LibDir + "/../include/c++/" + Version,

                                (GCCInstallation.getTriple().str() +

                                 GCCInstallation.getMultiarchSuffix()),

                                DriverArgs, CC1Args)) {

    // Gentoo is weird and places its headers inside the GCC install, so if the

    // first attempt to find the headers fails, try this pattern.

    addLibStdCXXIncludePaths(InstallDir + "/include/g++-v4",

                             getDriver().DefaultTargetTriple,

                             DriverArgs, CC1Args);

  }

}

  virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,

                                         ArgStringList &CC1Args) const;

  virtual void AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,

                                            ArgStringList &CC1Args) const;

private:

  static bool addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir,

                                       const ArgList &DriverArgs,

                                       ArgStringList &CC1Args);