diff --git a/gpkg/clang/build.sh b/gpkg/clang/build.sh new file mode 100644 index 000000000..0adcbdc86 --- /dev/null +++ b/gpkg/clang/build.sh @@ -0,0 +1,73 @@ +TERMUX_PKG_HOMEPAGE=https://llvm.org/ +TERMUX_PKG_DESCRIPTION="Compiler infrastructure" +TERMUX_PKG_LICENSE="Apache-2.0, NCSA" +TERMUX_PKG_LICENSE_FILE="LICENSE.TXT" +TERMUX_PKG_MAINTAINER="@termux-pacman" +_GCC_PKG_VERSION=$(. $TERMUX_SCRIPTDIR/gpkg/gcc-libs/build.sh; echo $TERMUX_PKG_VERSION) +TERMUX_PKG_VERSION=17.0.6 +_SOURCE=https://github.com/llvm/llvm-project/releases/download/llvmorg-$TERMUX_PKG_VERSION +TERMUX_PKG_SRCURL=($_SOURCE/clang-$TERMUX_PKG_VERSION.src.tar.xz + $_SOURCE/clang-tools-extra-$TERMUX_PKG_VERSION.src.tar.xz + $_SOURCE/llvm-$TERMUX_PKG_VERSION.src.tar.xz + $_SOURCE/cmake-$TERMUX_PKG_VERSION.src.tar.xz + $_SOURCE/third-party-$TERMUX_PKG_VERSION.src.tar.xz) +TERMUX_PKG_SHA256=(a78f668a726ae1d3d9a7179996d97b12b90fb76ab9442a43110b972ff7ad9029 + aa774642415d338d7b77a66fcbad6fd1f77f382dabcb67422a6230614eff1ab9 + b638167da139126ca11917b6880207cc6e8f9d1cbb1a48d87d017f697ef78188 + 807f069c54dc20cb47b21c1f6acafdd9c649f3ae015609040d6182cab01140f4 + 3054d0a9c9375dab1a4539cc2cc45ab340341c5d71475f9599ba7752e222947b) +TERMUX_PKG_DEPENDS="libllvm-glibc, gcc-glibc, compiler-rt-glibc" +TERMUX_PKG_BUILD_DEPENDS="llvm-glibc, python-glibc" +TERMUX_PKG_NO_STATICSPLIT=true + +termux_step_post_get_source() { + for i in cmake third-party; do + rm -fr $TERMUX_TOPDIR/$TERMUX_PKG_NAME/${i} + mv $TERMUX_PKG_SRCDIR/$i-$TERMUX_PKG_VERSION.src $TERMUX_TOPDIR/$TERMUX_PKG_NAME + mv $TERMUX_TOPDIR/$TERMUX_PKG_NAME/$i-$TERMUX_PKG_VERSION.src $TERMUX_TOPDIR/$TERMUX_PKG_NAME/$i + done + + mv $TERMUX_PKG_SRCDIR/clang-tools-extra-$TERMUX_PKG_VERSION.src $TERMUX_PKG_SRCDIR/tools/extra +} + +termux_step_configure() { + termux_setup_cmake + termux_setup_ninja + + local LLVM_TARGET_ARCH="X86" + if [ $TERMUX_ARCH = "arm" ]; then + LLVM_TARGET_ARCH="ARM" + elif [ $TERMUX_ARCH = "aarch64" ]; then + LLVM_TARGET_ARCH="AArch64" + fi + + export PATH=$TERMUX_PKG_BUILDDIR/bin:$PATH + LDFLAGS+=" -lm" + + cmake ${TERMUX_PKG_SRCDIR} \ + -G Ninja \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_FIND_ROOT_PATH=$TERMUX_PREFIX \ + -DCMAKE_INSTALL_DOCDIR=share/doc \ + -DCMAKE_INSTALL_PREFIX=$TERMUX_PREFIX \ + -DCMAKE_SYSTEM_NAME=Linux \ + -DLLVM_HOST_TRIPLE=$TERMUX_HOST_PLATFORM \ + -DCMAKE_LIBRARY_ARCHITECTURE=$TERMUX_HOST_PLATFORM \ + -DCMAKE_SYSTEM_PROCESSOR=$LLVM_TARGET_ARCH \ + -DLLVM_TARGETS_TO_BUILD=$LLVM_TARGET_ARCH \ + -DCMAKE_SKIP_RPATH=ON \ + -DCLANG_DEFAULT_PIE_ON_LINUX=ON \ + -DCLANG_LINK_CLANG_DYLIB=ON \ + -DENABLE_LINKER_BUILD_ID=ON \ + -DLLVM_BUILD_DOCS=ON \ + -DLLVM_BUILD_TESTS=ON \ + -DLLVM_ENABLE_RTTI=ON \ + -DLLVM_ENABLE_SPHINX=ON \ + -DLLVM_EXTERNAL_LIT=$TERMUX_PREFIX/bin/lit \ + -DGCC_INSTALL_PREFIX=$TERMUX_PREFIX/lib/gcc/$TERMUX_HOST_PLATFORM/${_GCC_PKG_VERSION} \ + -DLLVM_INCLUDE_DOCS=ON \ + -DLLVM_LINK_LLVM_DYLIB=ON \ + -DLLVM_MAIN_SRC_DIR=$TERMUX_PKG_SRCDIR/llvm-$TERMUX_PKG_VERSION.src \ + -DSPHINX_WARNINGS_AS_ERRORS=OFF \ + -DLLVM_INCLUDE_TESTS=OFF +} diff --git a/gpkg/clang/clangd-handle-missing-ending-brace.patch b/gpkg/clang/clangd-handle-missing-ending-brace.patch new file mode 100644 index 000000000..14a48eeff --- /dev/null +++ b/gpkg/clang/clangd-handle-missing-ending-brace.patch @@ -0,0 +1,78 @@ +From 9d1dada57741d204f8a95aa2b0c89a7242e101f1 Mon Sep 17 00:00:00 2001 +From: Nathan Ridge +Date: Thu, 18 Jan 2024 01:51:43 -0500 +Subject: [PATCH] [clangd] Handle an expanded token range that ends in the + `eof` token in TokenBuffer::spelledForExpanded() (#78092) + +Such ranges can legitimately arise in the case of invalid code, such as +a declaration missing an ending brace. + +Fixes https://github.com/clangd/clangd/issues/1559 +--- + clang/tools/extra/clangd/unittests/DumpASTTests.cpp | 11 +++++++++++ + clang/lib/Tooling/Syntax/Tokens.cpp | 6 ++++++ + clang/unittests/Tooling/Syntax/TokensTest.cpp | 12 ++++++++++++ + 3 files changed, 29 insertions(+) + +diff --git a/clang/tools/extra/clangd/unittests/DumpASTTests.cpp b/clang/tools/extra/clangd/unittests/DumpASTTests.cpp +index d1b8f21b82c65a..304682118c871d 100644 +--- clang/tools/extra/clangd/unittests/DumpASTTests.cpp ++++ clang/tools/extra/clangd/unittests/DumpASTTests.cpp +@@ -186,6 +186,17 @@ TEST(DumpASTTests, Arcana) { + EXPECT_THAT(Node.children.front().arcana, testing::StartsWith("QualType ")); + } + ++TEST(DumpASTTests, UnbalancedBraces) { ++ // Test that we don't crash while trying to compute a source range for the ++ // node whose ending brace is missing, and also that the source range is ++ // not empty. ++ Annotations Case("/*error-ok*/ $func[[int main() {]]"); ++ ParsedAST AST = TestTU::withCode(Case.code()).build(); ++ auto Node = dumpAST(DynTypedNode::create(findDecl(AST, "main")), ++ AST.getTokens(), AST.getASTContext()); ++ ASSERT_EQ(Node.range, Case.range("func")); ++} ++ + } // namespace + } // namespace clangd + } // namespace clang +diff --git a/clang/lib/Tooling/Syntax/Tokens.cpp b/clang/lib/Tooling/Syntax/Tokens.cpp +index 2f28b9cf286a63..8d32c45a4a70cf 100644 +--- clang/lib/Tooling/Syntax/Tokens.cpp ++++ clang/lib/Tooling/Syntax/Tokens.cpp +@@ -401,6 +401,12 @@ std::string TokenBuffer::Mapping::str() const { + + std::optional> + TokenBuffer::spelledForExpanded(llvm::ArrayRef Expanded) const { ++ // In cases of invalid code, AST nodes can have source ranges that include ++ // the `eof` token. As there's no spelling for this token, exclude it from ++ // the range. ++ if (!Expanded.empty() && Expanded.back().kind() == tok::eof) { ++ Expanded = Expanded.drop_back(); ++ } + // Mapping an empty range is ambiguous in case of empty mappings at either end + // of the range, bail out in that case. + if (Expanded.empty()) +diff --git a/clang/unittests/Tooling/Syntax/TokensTest.cpp b/clang/unittests/Tooling/Syntax/TokensTest.cpp +index 0c08318a637c0b..42f51697139658 100644 +--- clang/unittests/Tooling/Syntax/TokensTest.cpp ++++ clang/unittests/Tooling/Syntax/TokensTest.cpp +@@ -816,6 +816,18 @@ TEST_F(TokenBufferTest, SpelledByExpanded) { + EXPECT_EQ(Buffer.spelledForExpanded(findExpanded("prev good")), std::nullopt); + } + ++TEST_F(TokenBufferTest, NoCrashForEofToken) { ++ recordTokens(R"cpp( ++ int main() { ++ )cpp"); ++ ASSERT_TRUE(!Buffer.expandedTokens().empty()); ++ ASSERT_EQ(Buffer.expandedTokens().back().kind(), tok::eof); ++ // Expanded range including `eof` is handled gracefully (`eof` is ignored). ++ EXPECT_THAT( ++ Buffer.spelledForExpanded(Buffer.expandedTokens()), ++ ValueIs(SameRange(Buffer.spelledTokens(SourceMgr->getMainFileID())))); ++} ++ + TEST_F(TokenBufferTest, ExpandedTokensForRange) { + recordTokens(R"cpp( + #define SIGN(X) X##_washere diff --git a/gpkg/clang/enable-fstack-protector-strong-by-default.patch b/gpkg/clang/enable-fstack-protector-strong-by-default.patch new file mode 100644 index 000000000..ca48bfbf1 --- /dev/null +++ b/gpkg/clang/enable-fstack-protector-strong-by-default.patch @@ -0,0 +1,72 @@ +From 5346dc41bee9546db1fc649f39f1c44629495cc5 Mon Sep 17 00:00:00 2001 +From: Evangelos Foutras +Date: Fri, 18 Aug 2023 13:31:57 +0000 +Subject: [PATCH] Enable -fstack-protector-strong by default + +--- + clang/lib/Driver/ToolChains/Linux.h | 5 +++++ + clang/test/Driver/fsanitize.c | 6 +++--- + clang/test/Driver/stack-protector.c | 4 ++-- + 3 files changed, 10 insertions(+), 5 deletions(-) + +diff --git a/clang/lib/Driver/ToolChains/Linux.h b/clang/lib/Driver/ToolChains/Linux.h +index 524391743090..0d4e1944118b 100644 +--- clang/lib/Driver/ToolChains/Linux.h ++++ clang/lib/Driver/ToolChains/Linux.h +@@ -10,6 +10,7 @@ + #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_LINUX_H + + #include "Gnu.h" ++#include "clang/Basic/LangOptions.h" + #include "clang/Driver/ToolChain.h" + + namespace clang { +@@ -48,6 +49,10 @@ public: + IsAArch64OutlineAtomicsDefault(const llvm::opt::ArgList &Args) const override; + bool isPIEDefault(const llvm::opt::ArgList &Args) const override; + bool IsMathErrnoDefault() const override; ++ LangOptions::StackProtectorMode ++ GetDefaultStackProtectorLevel(bool KernelOrKext) const override { ++ return LangOptions::SSPStrong; ++ } + SanitizerMask getSupportedSanitizers() const override; + void addProfileRTLibs(const llvm::opt::ArgList &Args, + llvm::opt::ArgStringList &CmdArgs) const override; +diff --git a/clang/test/Driver/fsanitize.c b/clang/test/Driver/fsanitize.c +index 8ad6dc25b4d1..1619b59a40f0 100644 +--- clang/test/Driver/fsanitize.c ++++ clang/test/Driver/fsanitize.c +@@ -695,12 +695,12 @@ + // RUN: %clang -fno-sanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=NOSP + // NOSP-NOT: "-fsanitize=safe-stack" + +-// RUN: %clang --target=x86_64-linux-gnu -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=NO-SP ++// RUN: %clang --target=x86_64-linux-gnu -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=SP + // RUN: %clang --target=x86_64-linux-gnu -fsanitize=address,safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=SP-ASAN + // RUN: %clang --target=x86_64-linux-gnu -fstack-protector -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=SP + // RUN: %clang --target=x86_64-linux-gnu -fsanitize=safe-stack -fstack-protector-all -### %s 2>&1 | FileCheck %s -check-prefix=SP +-// RUN: %clang --target=arm-linux-androideabi -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=NO-SP +-// RUN: %clang --target=aarch64-linux-android -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=NO-SP ++// RUN: %clang --target=arm-linux-androideabi -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=SP ++// RUN: %clang --target=aarch64-linux-android -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=SP + // RUN: %clang --target=i386-contiki-unknown -fsanitize=safe-stack -### %s 2>&1 | FileCheck %s -check-prefix=NO-SP + // NO-SP-NOT: stack-protector + // NO-SP: "-fsanitize=safe-stack" +diff --git a/clang/test/Driver/stack-protector.c b/clang/test/Driver/stack-protector.c +index 169376919a71..2470b7f7e39e 100644 +--- clang/test/Driver/stack-protector.c ++++ clang/test/Driver/stack-protector.c +@@ -3,11 +3,11 @@ + // NOSSP-NOT: "-stack-protector-buffer-size" + + // RUN: %clang -target i386-unknown-linux -fstack-protector -### %s 2>&1 | FileCheck %s -check-prefix=SSP +-// SSP: "-stack-protector" "1" ++// SSP: "-stack-protector" "2" + // SSP-NOT: "-stack-protector-buffer-size" + + // RUN: %clang -target i386-unknown-linux -fstack-protector --param ssp-buffer-size=16 -### %s 2>&1 | FileCheck %s -check-prefix=SSP-BUF +-// SSP-BUF: "-stack-protector" "1" ++// SSP-BUF: "-stack-protector" "2" + // SSP-BUF: "-stack-protector-buffer-size" "16" + + // RUN: %clang -target i386-pc-openbsd -### %s 2>&1 | FileCheck %s -check-prefix=OPENBSD diff --git a/gpkg/clang/setdirs.patch b/gpkg/clang/setdirs.patch new file mode 100644 index 000000000..5caf57334 --- /dev/null +++ b/gpkg/clang/setdirs.patch @@ -0,0 +1,212 @@ +diff --git a/include/clang/Config/config.h.cmake b/include/clang/Config/config.h.cmake +index a54a26cd..cd0fdd28 100644 +--- a/include/clang/Config/config.h.cmake ++++ b/include/clang/Config/config.h.cmake +@@ -1,8 +1,6 @@ + /* This generated file is for internal use. Do not include it from headers. */ + +-#ifdef CLANG_CONFIG_H +-#error config.h can only be included once +-#else ++#ifndef CLANG_CONFIG_H + #define CLANG_CONFIG_H + + /* Bug report URL. */ +diff --git a/lib/Driver/ToolChains/Gnu.cpp b/lib/Driver/ToolChains/Gnu.cpp +index 40038dce..9e3b341e 100644 +--- a/lib/Driver/ToolChains/Gnu.cpp ++++ b/lib/Driver/ToolChains/Gnu.cpp +@@ -2086,7 +2086,7 @@ void Generic_GCC::GCCInstallationDetector::init( + CandidateBiarchTripleAliases); + + // If --gcc-install-dir= is specified, skip filesystem detection. +- if (const Arg *A = ++ /*if (const Arg *A = + Args.getLastArg(clang::driver::options::OPT_gcc_install_dir_EQ); + A && A->getValue()[0]) { + StringRef InstallDir = A->getValue(); +@@ -2105,7 +2105,7 @@ void Generic_GCC::GCCInstallationDetector::init( + IsValid = true; + } + return; +- } ++ }*/ + + // Compute the set of prefixes for our search. + SmallVector Prefixes; +@@ -2295,7 +2295,7 @@ void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes( + // They are not needed when the user has correct LLVM_DEFAULT_TARGET_TRIPLE + // and always uses the full --target (e.g. --target=aarch64-linux-gnu). The + // lists should shrink over time. Please don't add more elements to *Triples. +- static const char *const AArch64LibDirs[] = {"/lib64", "/lib"}; ++ static const char *const AArch64LibDirs[] = {"@TERMUX_PREFIX@/lib"}; + static const char *const AArch64Triples[] = { + "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux", + "aarch64-suse-linux"}; +@@ -2303,13 +2303,13 @@ void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes( + static const char *const AArch64beTriples[] = {"aarch64_be-none-linux-gnu", + "aarch64_be-linux-gnu"}; + +- static const char *const ARMLibDirs[] = {"/lib"}; ++ static const char *const ARMLibDirs[] = {"@TERMUX_PREFIX@/lib"}; + static const char *const ARMTriples[] = {"arm-linux-gnueabi"}; + static const char *const ARMHFTriples[] = {"arm-linux-gnueabihf", + "armv7hl-redhat-linux-gnueabi", + "armv6hl-suse-linux-gnueabi", + "armv7hl-suse-linux-gnueabi"}; +- static const char *const ARMebLibDirs[] = {"/lib"}; ++ static const char *const ARMebLibDirs[] = {"@TERMUX_PREFIX@/lib"}; + static const char *const ARMebTriples[] = {"armeb-linux-gnueabi"}; + static const char *const ARMebHFTriples[] = { + "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi"}; +@@ -2321,7 +2321,7 @@ void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes( + static const char *const CSKYTriples[] = { + "csky-linux-gnuabiv2", "csky-linux-uclibcabiv2", "csky-elf-noneabiv2"}; + +- static const char *const X86_64LibDirs[] = {"/lib64", "/lib"}; ++ static const char *const X86_64LibDirs[] = {"@TERMUX_PREFIX@/lib"}; + static const char *const X86_64Triples[] = { + "x86_64-linux-gnu", "x86_64-unknown-linux-gnu", + "x86_64-pc-linux-gnu", "x86_64-redhat-linux6E", +@@ -2331,8 +2331,8 @@ void Generic_GCC::GCCInstallationDetector::AddDefaultGCCPrefixes( + "x86_64-amazon-linux"}; + static const char *const X32Triples[] = {"x86_64-linux-gnux32", + "x86_64-pc-linux-gnux32"}; +- static const char *const X32LibDirs[] = {"/libx32", "/lib"}; +- static const char *const X86LibDirs[] = {"/lib32", "/lib"}; ++ static const char *const X32LibDirs[] = {"@TERMUX_PREFIX@/lib"}; ++ static const char *const X86LibDirs[] = {"@TERMUX_PREFIX@/lib"}; + static const char *const X86Triples[] = { + "i586-linux-gnu", "i686-linux-gnu", "i686-pc-linux-gnu", + "i386-redhat-linux6E", "i686-redhat-linux", "i386-redhat-linux", +@@ -2851,7 +2851,7 @@ bool Generic_GCC::GCCInstallationDetector::ScanGentooGccConfig( + } + } + // Test the path based on the version in /etc/env.d/gcc/config-{tuple}. +- std::string basePath = "/usr/lib/gcc/" + ActiveVersion.first.str() + "/" ++ std::string basePath = "@TERMUX_PREFIX@/usr/lib/gcc/" + ActiveVersion.first.str() + "/" + + ActiveVersion.second.str(); + GentooScanPaths.push_back(StringRef(basePath)); + +@@ -3127,9 +3127,7 @@ Generic_GCC::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, + // If this is a development, non-installed, clang, libcxx will + // not be found at ../include/c++ but it likely to be found at + // one of the following two locations: +- if (AddIncludePath(concat(SysRoot, "/usr/local/include"))) +- return; +- if (AddIncludePath(concat(SysRoot, "/usr/include"))) ++ if (AddIncludePath(concat(SysRoot, "@TERMUX_PREFIX@/include"))) + return; + } + +diff --git a/lib/Driver/ToolChains/Gnu.h b/lib/Driver/ToolChains/Gnu.h +index 6d335c9e..e1259081 100644 +--- a/lib/Driver/ToolChains/Gnu.h ++++ b/lib/Driver/ToolChains/Gnu.h +@@ -14,6 +14,7 @@ + #include "ROCm.h" + #include "clang/Driver/Tool.h" + #include "clang/Driver/ToolChain.h" ++#include "clang/Config/config.h" // for GCC_INSTALL_PREFIX + #include + + namespace clang { +@@ -195,8 +196,8 @@ public: + const Driver &D; + + // FIXME: These might be better as path objects. +- std::string GCCInstallPath; +- std::string GCCParentLibPath; ++ std::string GCCInstallPath = GCC_INSTALL_PREFIX; ++ std::string GCCParentLibPath = GCCInstallPath + "/../../.."; + + /// The primary multilib appropriate for the given flags. + Multilib SelectedMultilib; +diff --git a/lib/Driver/ToolChains/Linux.cpp b/lib/Driver/ToolChains/Linux.cpp +index 1ba222bf..795cce93 100644 +--- a/lib/Driver/ToolChains/Linux.cpp ++++ b/lib/Driver/ToolChains/Linux.cpp +@@ -301,8 +301,8 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + } + Generic_GCC::AddMultilibPaths(D, SysRoot, OSLibDir, MultiarchTriple, Paths); + +- addPathIfExists(D, concat(SysRoot, "/lib", MultiarchTriple), Paths); +- addPathIfExists(D, concat(SysRoot, "/lib/..", OSLibDir), Paths); ++ addPathIfExists(D, concat(SysRoot, "@TERMUX_PREFIX@/lib", MultiarchTriple), Paths); ++ addPathIfExists(D, concat(SysRoot, "@TERMUX_PREFIX@/lib/..", OSLibDir), Paths); + + if (IsAndroid) { + // Android sysroots contain a library directory for each supported OS +@@ -315,25 +315,23 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) + Paths); + } + +- addPathIfExists(D, concat(SysRoot, "/usr/lib", MultiarchTriple), Paths); ++ addPathIfExists(D, concat(SysRoot, "@TERMUX_PREFIX@/lib", MultiarchTriple), Paths); + // 64-bit OpenEmbedded sysroots may not have a /usr/lib dir. So they cannot + // find /usr/lib64 as it is referenced as /usr/lib/../lib64. So we handle + // this here. + if (Triple.getVendor() == llvm::Triple::OpenEmbedded && + Triple.isArch64Bit()) +- addPathIfExists(D, concat(SysRoot, "/usr", OSLibDir), Paths); ++ addPathIfExists(D, concat(SysRoot, "@TERMUX_PREFIX@/", OSLibDir), Paths); + else +- addPathIfExists(D, concat(SysRoot, "/usr/lib/..", OSLibDir), Paths); ++ addPathIfExists(D, concat(SysRoot, "@TERMUX_PREFIX@/lib/..", OSLibDir), Paths); + if (IsRISCV) { + StringRef ABIName = tools::riscv::getRISCVABI(Args, Triple); +- addPathIfExists(D, concat(SysRoot, "/", OSLibDir, ABIName), Paths); +- addPathIfExists(D, concat(SysRoot, "/usr", OSLibDir, ABIName), Paths); ++ addPathIfExists(D, concat(SysRoot, "@TERMUX_PREFIX@/", OSLibDir, ABIName), Paths); + } + + Generic_GCC::AddMultiarchPaths(D, SysRoot, OSLibDir, Paths); + +- addPathIfExists(D, concat(SysRoot, "/lib"), Paths); +- addPathIfExists(D, concat(SysRoot, "/usr/lib"), Paths); ++ addPathIfExists(D, concat(SysRoot, "@TERMUX_PREFIX@/lib"), Paths); + } + + ToolChain::RuntimeLibType Linux::GetDefaultRuntimeLibType() const { +@@ -605,7 +603,7 @@ std::string Linux::getDynamicLinker(const ArgList &Args) const { + (Triple.getVendor() == llvm::Triple::UnknownVendor || + Triple.getVendor() == llvm::Triple::PC)) + return "/usr/" + Triple.str() + "/lib/" + Loader; +- return "/" + LibDir + "/" + Loader; ++ return "@TERMUX_PREFIX@/" + LibDir + "/" + Loader; + } + + void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, +@@ -630,7 +628,7 @@ void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + return; + + // LOCAL_INCLUDE_DIR +- addSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "/usr/local/include")); ++ addSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "@TERMUX_PREFIX@/include")); + // TOOL_INCLUDE_DIR + AddMultilibIncludeArgs(DriverArgs, CC1Args); + +@@ -651,10 +649,10 @@ void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + // /usr/include. + std::string MultiarchIncludeDir = getMultiarchTriple(D, getTriple(), SysRoot); + if (!MultiarchIncludeDir.empty() && +- D.getVFS().exists(concat(SysRoot, "/usr/include", MultiarchIncludeDir))) ++ D.getVFS().exists(concat(SysRoot, "@TERMUX_PREFIX@/include", MultiarchIncludeDir))) + addExternCSystemInclude( + DriverArgs, CC1Args, +- concat(SysRoot, "/usr/include", MultiarchIncludeDir)); ++ concat(SysRoot, "@TERMUX_PREFIX@/include", MultiarchIncludeDir)); + + if (getTriple().getOS() == llvm::Triple::RTEMS) + return; +@@ -662,9 +660,7 @@ void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, + // 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, concat(SysRoot, "/include")); +- +- addExternCSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "/usr/include")); ++ addExternCSystemInclude(DriverArgs, CC1Args, concat(SysRoot, "@TERMUX_PREFIX@/include")); + + if (!DriverArgs.hasArg(options::OPT_nobuiltininc) && getTriple().isMusl()) + addSystemInclude(DriverArgs, CC1Args, ResourceDirInclude);