From d1b64e63ff0e39badc4bd03b65033149af66c5f8 Mon Sep 17 00:00:00 2001 From: ruki Date: Fri, 30 Aug 2024 00:58:10 +0800 Subject: [PATCH 1/5] improve linker for package #5542 --- xmake/core/package/package.lua | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/xmake/core/package/package.lua b/xmake/core/package/package.lua index fe22a2e8ba1..a833a2f0b93 100644 --- a/xmake/core/package/package.lua +++ b/xmake/core/package/package.lua @@ -1281,7 +1281,7 @@ function _instance:toolconfig(name) end end --- get the target compiler +-- get the package compiler function _instance:compiler(sourcekind) local compilerinst = self:_memcache():get("compiler") if not compilerinst then @@ -1298,6 +1298,20 @@ function _instance:compiler(sourcekind) return compilerinst end +-- get the package linker +function _instance:linker(targetkind, sourcekinds) + local linkerinst = self:_memcache():get("linker") + if not linkerinst then + local instance, errors = linker.load(targetkind, sourcekinds, self) + if not instance then + os.raise(errors) + end + linkerinst = instance + self:_memcache():set("linker", linkerinst) + end + return linkerinst +end + -- has the given tool for the current package? -- -- e.g. @@ -2358,11 +2372,7 @@ function _instance:_generate_build_configs(configs, opt) end if runtimes then local sourcekind = opt.sourcekind or "cxx" - local tool, name = self:tool("ld") - local linker, errors = linker.load("binary", sourcekind, {target = package}) - if not linker then - os.raise(errors) - end + local linker = self:linker("binary", sourcekind) local fake_target = {is_shared = function(_) return false end, sourcekinds = function(_) return sourcekind end} local compiler = self:compiler(sourcekind) From 456eedcebb5adac9063d9417f68a47ebe0cddb49 Mon Sep 17 00:00:00 2001 From: ruki Date: Fri, 30 Aug 2024 22:49:47 +0800 Subject: [PATCH 2/5] fix map runtime flags --- xmake/core/package/package.lua | 11 ++++++----- xmake/modules/package/tools/cmake.lua | 14 +++++--------- 2 files changed, 11 insertions(+), 14 deletions(-) diff --git a/xmake/core/package/package.lua b/xmake/core/package/package.lua index a833a2f0b93..22a8dfb2b62 100644 --- a/xmake/core/package/package.lua +++ b/xmake/core/package/package.lua @@ -2372,17 +2372,18 @@ function _instance:_generate_build_configs(configs, opt) end if runtimes then local sourcekind = opt.sourcekind or "cxx" - local linker = self:linker("binary", sourcekind) - local fake_target = {is_shared = function(_) return false end, - sourcekinds = function(_) return sourcekind end} local compiler = self:compiler(sourcekind) - local cxflags = compiler:map_flags("runtime", runtimes, {target = fake_target}) + local cxflags = compiler:map_flags("runtime", runtimes, {target = self}) configs.cxflags = table.wrap(configs.cxflags) table.join2(configs.cxflags, cxflags) - local ldflags = linker:map_flags("runtime", runtimes, {target = fake_target}) + local ldflags = self:linker("binary", sourcekind):map_flags("runtime", runtimes, {target = self}) configs.ldflags = table.wrap(configs.ldflags) table.join2(configs.ldflags, ldflags) + + local shflags = self:linker("shared", sourcekind):map_flags("runtime", runtimes, {target = self}) + configs.shflags = table.wrap(configs.shflags) + table.join2(configs.shflags, shflags) end if self:config("lto") then local configs_lto = self:_generate_lto_configs(opt.sourcekind or "cxx") diff --git a/xmake/modules/package/tools/cmake.lua b/xmake/modules/package/tools/cmake.lua index 7d5550390e0..938d96daddf 100644 --- a/xmake/modules/package/tools/cmake.lua +++ b/xmake/modules/package/tools/cmake.lua @@ -881,15 +881,11 @@ function _get_envs_for_runtime_flags(package, configs, opt) local envs = {} local runtimes = package:runtimes() if runtimes then - local fake_target = {is_shared = function(_) return false end, - sourcekinds = function(_) return "cc" end} - envs[format("CMAKE_C_FLAGS_%s", buildtype)] = _map_compflags(fake_target, "c", "runtime", runtimes) - fake_target.sourcekinds = function(_) return "cxx" end - envs[format("CMAKE_CXX_FLAGS_%s", buildtype)] = _map_compflags(fake_target, "cxx", "runtime", runtimes) - envs[format("CMAKE_EXE_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(fake_target, "binary", {"cxx"}, "runtime", runtimes) - envs[format("CMAKE_STATIC_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(fake_target, "static", {"cxx"}, "runtime", runtimes) - fake_target.is_shared = function(_) return true end - envs[format("CMAKE_SHARED_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(fake_target, "shared", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_C_FLAGS_%s", buildtype)] = _map_compflags(package, "c", "runtime", runtimes) + envs[format("CMAKE_CXX_FLAGS_%s", buildtype)] = _map_compflags(package, "cxx", "runtime", runtimes) + envs[format("CMAKE_EXE_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(package, "binary", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_STATIC_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(package, "static", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_SHARED_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(package, "shared", {"cxx"}, "runtime", runtimes) end return envs end From a50553989fd578547255c34616fff4e18ba84784 Mon Sep 17 00:00:00 2001 From: ruki Date: Sat, 31 Aug 2024 00:39:10 +0800 Subject: [PATCH 3/5] fix map flags for package runtimes --- tests/projects/c++/snippet_runtimes/xmake.lua | 1 - xmake/core/package/package.lua | 16 ++++++++++++---- 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/tests/projects/c++/snippet_runtimes/xmake.lua b/tests/projects/c++/snippet_runtimes/xmake.lua index 1e5436ba40f..8ef59ed4f73 100644 --- a/tests/projects/c++/snippet_runtimes/xmake.lua +++ b/tests/projects/c++/snippet_runtimes/xmake.lua @@ -4,7 +4,6 @@ add_requires("bar") target("foo") set_kind("binary") add_files("src/*.cpp") - add_packages("bar") on_config(function(target) diff --git a/xmake/core/package/package.lua b/xmake/core/package/package.lua index 22a8dfb2b62..c837b5bdcbc 100644 --- a/xmake/core/package/package.lua +++ b/xmake/core/package/package.lua @@ -1283,7 +1283,7 @@ end -- get the package compiler function _instance:compiler(sourcekind) - local compilerinst = self:_memcache():get("compiler") + local compilerinst = self:_memcache():get2("compiler", sourcekind) if not compilerinst then if not sourcekind then os.raise("please pass sourcekind to the first argument of package:compiler(), e.g. cc, cxx, as") @@ -1293,21 +1293,24 @@ function _instance:compiler(sourcekind) os.raise(errors) end compilerinst = instance - self:_memcache():set("compiler", compilerinst) + self:_memcache():set2("compiler", sourcekind, compilerinst) end return compilerinst end -- get the package linker function _instance:linker(targetkind, sourcekinds) - local linkerinst = self:_memcache():get("linker") + local linkerinst = self:_memcache():get3("linker", targetkind, sourcekinds) if not linkerinst then + if not sourcekinds then + os.raise("please pass sourcekinds to the second argument of package:linker(), e.g. cc, cxx, as") + end local instance, errors = linker.load(targetkind, sourcekinds, self) if not instance then os.raise(errors) end linkerinst = instance - self:_memcache():set("linker", linkerinst) + self:_memcache():set3("linker", targetkind, sourcekinds, linkerinst) end return linkerinst end @@ -2371,7 +2374,11 @@ function _instance:_generate_build_configs(configs, opt) end end if runtimes then + -- @note we need to patch package:sourcekinds(), because it wiil be called nf_runtime for gcc/clang local sourcekind = opt.sourcekind or "cxx" + self.sourcekinds = function (self) + return sourcekind + end local compiler = self:compiler(sourcekind) local cxflags = compiler:map_flags("runtime", runtimes, {target = self}) configs.cxflags = table.wrap(configs.cxflags) @@ -2384,6 +2391,7 @@ function _instance:_generate_build_configs(configs, opt) local shflags = self:linker("shared", sourcekind):map_flags("runtime", runtimes, {target = self}) configs.shflags = table.wrap(configs.shflags) table.join2(configs.shflags, shflags) + self.sourcekinds = nil end if self:config("lto") then local configs_lto = self:_generate_lto_configs(opt.sourcekind or "cxx") From 8317c6570c5abcd0e054741f58770b7eb57ec744 Mon Sep 17 00:00:00 2001 From: ruki Date: Sat, 31 Aug 2024 00:41:43 +0800 Subject: [PATCH 4/5] remove fake_target --- xmake/modules/core/tools/clang.lua | 2 +- xmake/modules/package/tools/autoconf.lua | 67 +++++++++-------------- xmake/modules/package/tools/cmake.lua | 66 +++++++++------------- xmake/modules/package/tools/make.lua | 21 ++----- xmake/modules/package/tools/meson.lua | 36 ++++-------- xmake/modules/private/utils/toolchain.lua | 26 +++++++++ 6 files changed, 94 insertions(+), 124 deletions(-) diff --git a/xmake/modules/core/tools/clang.lua b/xmake/modules/core/tools/clang.lua index 76a1f773bcc..879bdb62830 100644 --- a/xmake/modules/core/tools/clang.lua +++ b/xmake/modules/core/tools/clang.lua @@ -296,7 +296,7 @@ function nf_runtime(self, runtime, opt) if triple_libdir then maps["c++_shared"] = table.join(maps["c++_shared"], nf_rpathdir(self, triple_libdir)) end - if target:is_shared() and self:is_plat("macosx", "iphoneos", "watchos") then + if target:is_shared() and target.filename and self:is_plat("macosx", "iphoneos", "watchos") then maps["c++_shared"] = table.join(maps["c++_shared"], "-install_name") maps["c++_shared"] = table.join(maps["c++_shared"], "@rpath/" .. target:filename()) end diff --git a/xmake/modules/package/tools/autoconf.lua b/xmake/modules/package/tools/autoconf.lua index 8600d7334a9..630bd9dbc4f 100644 --- a/xmake/modules/package/tools/autoconf.lua +++ b/xmake/modules/package/tools/autoconf.lua @@ -21,11 +21,10 @@ -- imports import("core.base.option") import("core.project.config") -import("core.tool.linker") -import("core.tool.compiler") import("core.tool.toolchain") import("core.cache.memcache") import("lib.detect.find_tool") +import("private.utils.toolchain", {alias = "toolchain_utils"}) -- translate paths function _translate_paths(paths) @@ -78,16 +77,6 @@ function _get_msvc_runenvs(package) return os.joinenvs(_get_msvc(package):runenvs()) end --- map compiler flags -function _map_compflags(package, langkind, name, values) - return compiler.map_flags(langkind, name, values, {target = package}) -end - --- map linker flags -function _map_linkflags(package, targetkind, sourcekinds, name, values) - return linker.map_flags(targetkind, sourcekinds, name, values, {target = package}) -end - -- is cross compilation? function _is_cross_compilation(package) if not package:is_plat(os.subhost()) then @@ -199,13 +188,13 @@ function _get_cflags_from_packagedeps(package, opt) local result = {} if values then if values.defines then - table.join2(result, _map_compflags(package, "cxx", "define", values.defines)) + table.join2(result, toolchain_utils.map_compflags(package, "cxx", "define", values.defines)) end if values.includedirs then - table.join2(result, _translate_paths(_map_compflags(package, "cxx", "includedir", values.includedirs))) + table.join2(result, _translate_paths(toolchain_utils.map_compflags(package, "cxx", "includedir", values.includedirs))) end if values.sysincludedirs then - table.join2(result, _translate_paths(_map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs))) + table.join2(result, _translate_paths(toolchain_utils.map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs))) end end return result @@ -230,16 +219,16 @@ function _get_ldflags_from_packagedeps(package, opt) local result = {} if values then if values.linkdirs then - table.join2(result, _translate_paths(_map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs))) + table.join2(result, _translate_paths(toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs))) end if values.links then - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "link", values.links)) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", values.links)) end if values.syslinks then - table.join2(result, _translate_paths(_map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks))) + table.join2(result, _translate_paths(toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks))) end if values.frameworks then - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) end end return result @@ -306,21 +295,21 @@ function buildenvs(package, opt) table.join2(cxxflags, _get_cflags_from_packagedeps(package, opt)) table.join2(cppflags, _get_cflags_from_packagedeps(package, opt)) table.join2(ldflags, _get_ldflags_from_packagedeps(package, opt)) - table.join2(cflags, _map_compflags(package, "c", "define", defines)) - table.join2(cflags, _map_compflags(package, "c", "includedir", includedirs)) - table.join2(cflags, _map_compflags(package, "c", "sysincludedir", sysincludedirs)) - table.join2(asflags, _map_compflags(package, "as", "define", defines)) - table.join2(asflags, _map_compflags(package, "as", "includedir", includedirs)) - table.join2(asflags, _map_compflags(package, "as", "sysincludedir", sysincludedirs)) - table.join2(cxxflags, _map_compflags(package, "cxx", "define", defines)) - table.join2(cxxflags, _map_compflags(package, "cxx", "includedir", includedirs)) - table.join2(cxxflags, _map_compflags(package, "cxx", "sysincludedir", sysincludedirs)) - table.join2(ldflags, _map_linkflags(package, "binary", {"cxx"}, "link", links)) - table.join2(ldflags, _map_linkflags(package, "binary", {"cxx"}, "syslink", syslinks)) - table.join2(ldflags, _map_linkflags(package, "binary", {"cxx"}, "linkdir", linkdirs)) - table.join2(shflags, _map_linkflags(package, "shared", {"cxx"}, "link", links)) - table.join2(shflags, _map_linkflags(package, "shared", {"cxx"}, "syslink", syslinks)) - table.join2(shflags, _map_linkflags(package, "shared", {"cxx"}, "linkdir", linkdirs)) + table.join2(cflags, toolchain_utils.map_compflags(package, "c", "define", defines)) + table.join2(cflags, toolchain_utils.map_compflags(package, "c", "includedir", includedirs)) + table.join2(cflags, toolchain_utils.map_compflags(package, "c", "sysincludedir", sysincludedirs)) + table.join2(asflags, toolchain_utils.map_compflags(package, "as", "define", defines)) + table.join2(asflags, toolchain_utils.map_compflags(package, "as", "includedir", includedirs)) + table.join2(asflags, toolchain_utils.map_compflags(package, "as", "sysincludedir", sysincludedirs)) + table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "define", defines)) + table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "includedir", includedirs)) + table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "sysincludedir", sysincludedirs)) + table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", links)) + table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", syslinks)) + table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", linkdirs)) + table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "link", links)) + table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "syslink", syslinks)) + table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "linkdir", linkdirs)) envs.CC = package:build_getenv("cc") envs.AS = package:build_getenv("as") envs.AR = package:build_getenv("ar") @@ -341,13 +330,9 @@ function buildenvs(package, opt) end local runtimes = package:runtimes() if runtimes then - local fake_target = {is_shared = function(_) return false end, - sourcekinds = function(_) return "cxx" end} - table.join2(cxxflags, _map_compflags(fake_target, "cxx", "runtime", runtimes)) - table.join2(ldflags, _map_linkflags(fake_target, "binary", {"cxx"}, "runtime", runtimes)) - fake_target = {is_shared = function(_) return true end, - sourcekinds = function(_) return "cxx" end} - table.join2(shflags, _map_linkflags(fake_target, "shared", {"cxx"}, "runtime", runtimes)) + table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "runtime", runtimes)) + table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "runtime", runtimes)) + table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "runtime", runtimes)) end if package:config("asan") then table.join2(cflags, package:_generate_sanitizer_configs("address", "cc").cflags) diff --git a/xmake/modules/package/tools/cmake.lua b/xmake/modules/package/tools/cmake.lua index 938d96daddf..10ca6cbe691 100644 --- a/xmake/modules/package/tools/cmake.lua +++ b/xmake/modules/package/tools/cmake.lua @@ -23,8 +23,6 @@ import("core.base.option") import("core.base.semver") import("core.tool.toolchain") import("core.project.config") -import("core.tool.linker") -import("core.tool.compiler") import("core.project.project") import("lib.detect.find_file") import("lib.detect.find_tool") @@ -67,16 +65,6 @@ function _translate_bin_path(bin_path) return bin_path end --- map compiler flags -function _map_compflags(package, langkind, name, values) - return compiler.map_flags(langkind, name, values, {target = package}) -end - --- map linker flags -function _map_linkflags(package, targetkind, sourcekinds, name, values) - return linker.map_flags(targetkind, sourcekinds, name, values, {target = package}) -end - -- get pkg-config, we need force to find it, because package install environments will be changed function _get_pkgconfig(package) -- meson need fullpath pkgconfig @@ -146,13 +134,13 @@ function _get_cflags_from_packagedeps(package, opt) local result = {} if values then if values.defines then - table.join2(result, _map_compflags(package, "cxx", "define", values.defines)) + table.join2(result, toolchain_utils.map_compflags(package, "cxx", "define", values.defines)) end if values.includedirs then - table.join2(result, _translate_paths(_map_compflags(package, "cxx", "includedir", values.includedirs))) + table.join2(result, _translate_paths(toolchain_utils.map_compflags(package, "cxx", "includedir", values.includedirs))) end if values.sysincludedirs then - table.join2(result, _translate_paths(_map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs))) + table.join2(result, _translate_paths(toolchain_utils.map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs))) end end return result @@ -177,16 +165,16 @@ function _get_ldflags_from_packagedeps(package, opt) local result = {} if values then if values.linkdirs then - table.join2(result, _translate_paths(_map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs))) + table.join2(result, _translate_paths(toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs))) end if values.links then - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "link", values.links)) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", values.links)) end if values.syslinks then - table.join2(result, _translate_paths(_map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks))) + table.join2(result, _translate_paths(toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks))) end if values.frameworks then - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) end end return result @@ -199,9 +187,9 @@ function _get_cflags(package, opt) if opt.cross then table.join2(result, package:build_getenv("cflags")) table.join2(result, package:build_getenv("cxflags")) - table.join2(result, _map_compflags(package, "c", "define", package:build_getenv("defines"))) - table.join2(result, _map_compflags(package, "c", "includedir", package:build_getenv("includedirs"))) - table.join2(result, _map_compflags(package, "c", "sysincludedir", package:build_getenv("sysincludedirs"))) + table.join2(result, toolchain_utils.map_compflags(package, "c", "define", package:build_getenv("defines"))) + table.join2(result, toolchain_utils.map_compflags(package, "c", "includedir", package:build_getenv("includedirs"))) + table.join2(result, toolchain_utils.map_compflags(package, "c", "sysincludedir", package:build_getenv("sysincludedirs"))) end table.join2(result, package:config("cflags")) table.join2(result, package:config("cxflags")) @@ -230,9 +218,9 @@ function _get_cxxflags(package, opt) if opt.cross then table.join2(result, package:build_getenv("cxxflags")) table.join2(result, package:build_getenv("cxflags")) - table.join2(result, _map_compflags(package, "cxx", "define", package:build_getenv("defines"))) - table.join2(result, _map_compflags(package, "cxx", "includedir", package:build_getenv("includedirs"))) - table.join2(result, _map_compflags(package, "cxx", "sysincludedir", package:build_getenv("sysincludedirs"))) + table.join2(result, toolchain_utils.map_compflags(package, "cxx", "define", package:build_getenv("defines"))) + table.join2(result, toolchain_utils.map_compflags(package, "cxx", "includedir", package:build_getenv("includedirs"))) + table.join2(result, toolchain_utils.map_compflags(package, "cxx", "sysincludedir", package:build_getenv("sysincludedirs"))) end table.join2(result, package:config("cxxflags")) table.join2(result, package:config("cxflags")) @@ -260,9 +248,9 @@ function _get_asflags(package, opt) local result = {} if opt.cross then table.join2(result, package:build_getenv("asflags")) - table.join2(result, _map_compflags(package, "as", "define", package:build_getenv("defines"))) - table.join2(result, _map_compflags(package, "as", "includedir", package:build_getenv("includedirs"))) - table.join2(result, _map_compflags(package, "as", "sysincludedir", package:build_getenv("sysincludedirs"))) + table.join2(result, toolchain_utils.map_compflags(package, "as", "define", package:build_getenv("defines"))) + table.join2(result, toolchain_utils.map_compflags(package, "as", "includedir", package:build_getenv("includedirs"))) + table.join2(result, toolchain_utils.map_compflags(package, "as", "sysincludedir", package:build_getenv("sysincludedirs"))) end table.join2(result, package:config("asflags")) if opt.asflags then @@ -279,9 +267,9 @@ function _get_ldflags(package, opt) local result = {} if opt.cross then table.join2(result, package:build_getenv("ldflags")) - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "link", package:build_getenv("links"))) - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "syslink", package:build_getenv("syslinks"))) - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "linkdir", package:build_getenv("linkdirs"))) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", package:build_getenv("links"))) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", package:build_getenv("syslinks"))) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", package:build_getenv("linkdirs"))) end table.join2(result, package:config("ldflags")) if package:config("lto") then @@ -305,9 +293,9 @@ function _get_shflags(package, opt) local result = {} if opt.cross then table.join2(result, package:build_getenv("shflags")) - table.join2(result, _map_linkflags(package, "shared", {"cxx"}, "link", package:build_getenv("links"))) - table.join2(result, _map_linkflags(package, "shared", {"cxx"}, "syslink", package:build_getenv("syslinks"))) - table.join2(result, _map_linkflags(package, "shared", {"cxx"}, "linkdir", package:build_getenv("linkdirs"))) + table.join2(result, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "link", package:build_getenv("links"))) + table.join2(result, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "syslink", package:build_getenv("syslinks"))) + table.join2(result, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "linkdir", package:build_getenv("linkdirs"))) end table.join2(result, package:config("shflags")) if package:config("lto") then @@ -881,11 +869,11 @@ function _get_envs_for_runtime_flags(package, configs, opt) local envs = {} local runtimes = package:runtimes() if runtimes then - envs[format("CMAKE_C_FLAGS_%s", buildtype)] = _map_compflags(package, "c", "runtime", runtimes) - envs[format("CMAKE_CXX_FLAGS_%s", buildtype)] = _map_compflags(package, "cxx", "runtime", runtimes) - envs[format("CMAKE_EXE_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(package, "binary", {"cxx"}, "runtime", runtimes) - envs[format("CMAKE_STATIC_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(package, "static", {"cxx"}, "runtime", runtimes) - envs[format("CMAKE_SHARED_LINKER_FLAGS_%s", buildtype)] = _map_linkflags(package, "shared", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_C_FLAGS_%s", buildtype)] = toolchain_utils.map_compflags(package, "c", "runtime", runtimes) + envs[format("CMAKE_CXX_FLAGS_%s", buildtype)] = toolchain_utils.map_compflags(package, "cxx", "runtime", runtimes) + envs[format("CMAKE_EXE_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_STATIC_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags(package, "static", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_SHARED_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "runtime", runtimes) end return envs end diff --git a/xmake/modules/package/tools/make.lua b/xmake/modules/package/tools/make.lua index bb7a8124f3f..99e813c4a7f 100644 --- a/xmake/modules/package/tools/make.lua +++ b/xmake/modules/package/tools/make.lua @@ -22,6 +22,7 @@ import("core.base.option") import("core.project.config") import("lib.detect.find_tool") +import("private.utils.toolchain", {alias = "toolchain_utils"}) -- translate bin path function _translate_bin_path(bin_path) @@ -31,16 +32,6 @@ function _translate_bin_path(bin_path) return bin_path end --- map compiler flags -function _map_compflags(package, langkind, name, values) - return compiler.map_flags(langkind, name, values, {target = package}) -end - --- map linker flags -function _map_linkflags(package, targetkind, sourcekinds, name, values) - return linker.map_flags(targetkind, sourcekinds, name, values, {target = package}) -end - -- get the build environments function buildenvs(package) local envs = {} @@ -51,13 +42,9 @@ function buildenvs(package) local shflags = table.copy(table.wrap(package:config("shflags"))) local runtimes = package:runtimes() if runtimes then - local fake_target = {is_shared = function(_) return false end, - sourcekinds = function(_) return "cxx" end} - table.join2(cxxflags, _map_compflags(fake_target, "cxx", "runtime", runtimes)) - table.join2(ldflags, _map_linkflags(fake_target, "binary", {"cxx"}, "runtime", runtimes)) - fake_target = {is_shared = function(_) return true end, - sourcekinds = function(_) return "cxx" end} - table.join2(shflags, _map_linkflags(fake_target, "shared", {"cxx"}, "runtime", runtimes)) + table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "runtime", runtimes)) + table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "runtime", runtimes)) + table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "runtime", runtimes)) end if package:is_plat(os.host()) then if package:is_plat("linux") and package:is_arch("i386") then diff --git a/xmake/modules/package/tools/meson.lua b/xmake/modules/package/tools/meson.lua index fddf32999d2..641a57eb2c1 100644 --- a/xmake/modules/package/tools/meson.lua +++ b/xmake/modules/package/tools/meson.lua @@ -22,8 +22,6 @@ import("core.base.option") import("core.project.config") import("core.tool.toolchain") -import("core.tool.linker") -import("core.tool.compiler") import("lib.detect.find_tool") import("private.utils.executable_path") import("private.utils.toolchain", {alias = "toolchain_utils"}) @@ -38,16 +36,6 @@ function _get_buildir(package, opt) end end --- map compiler flags -function _map_compflags(package, langkind, name, values) - return compiler.map_flags(langkind, name, values, {target = package}) -end - --- map linker flags -function _map_linkflags(package, targetkind, sourcekinds, name, values) - return linker.map_flags(targetkind, sourcekinds, name, values, {target = package}) -end - -- get pkg-config, we need force to find it, because package install environments will be changed function _get_pkgconfig(package) -- meson need fullpath pkgconfig @@ -303,13 +291,9 @@ function _get_configs_file(package, opt) -- add runtimes flags for _, runtime in ipairs(package:runtimes()) do if not runtime:startswith("M") then - local fake_target = {is_shared = function(_) return false end, - sourcekinds = function(_) return "cxx" end} - table.join2(cxxflags, _map_compflags(fake_target, "cxx", "runtime", {runtime})) - table.join2(ldflags, _map_linkflags(fake_target, "binary", {"cxx"}, "runtime", {runtime})) - fake_target = {is_shared = function(_) return true end, - sourcekinds = function(_) return "cxx" end} - table.join2(shflags, _map_linkflags(fake_target, "shared", {"cxx"}, "runtime", {runtime})) + table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "runtime", {runtime})) + table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "runtime", {runtime})) + table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "runtime", {runtime})) end end if #cflags > 0 then @@ -428,13 +412,13 @@ function _get_cflags_from_packagedeps(package, opt) local result = {} if values then if values.defines then - table.join2(result, _map_compflags(package, "cxx", "define", values.defines)) + table.join2(result, toolchain_utils.map_compflags(package, "cxx", "define", values.defines)) end if values.includedirs then - table.join2(result, _map_compflags(package, "cxx", "includedir", values.includedirs)) + table.join2(result, toolchain_utils.map_compflags(package, "cxx", "includedir", values.includedirs)) end if values.sysincludedirs then - table.join2(result, _map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs)) + table.join2(result, toolchain_utils.map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs)) end end return _translate_flags(package, result) @@ -459,16 +443,16 @@ function _get_ldflags_from_packagedeps(package, opt) local result = {} if values then if values.linkdirs then - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs)) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs)) end if values.links then - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "link", values.links)) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", values.links)) end if values.syslinks then - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks)) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks)) end if values.frameworks then - table.join2(result, _map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) + table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) end end return _translate_flags(package, result) diff --git a/xmake/modules/private/utils/toolchain.lua b/xmake/modules/private/utils/toolchain.lua index 1513a01d6ea..634169dacad 100644 --- a/xmake/modules/private/utils/toolchain.lua +++ b/xmake/modules/private/utils/toolchain.lua @@ -18,6 +18,9 @@ -- @file toolchain.lua -- import("core.base.semver") +import("core.tool.linker") +import("core.tool.compiler") +import("core.language.language") -- is the compatible with the host? function is_compatible_with_host(name) @@ -47,3 +50,26 @@ function get_vs_toolset_ver(vs_toolset) return toolset_ver end +-- map compiler flags +function map_compflags(package, langkind, name, values) + -- @note we need to patch package:sourcekinds(), because it wiil be called nf_runtime for gcc/clang + package.sourcekinds = function (self) + local sourcekind = language.langkinds()[langkind] + return sourcekind + end + local flags = compiler.map_flags(langkind, name, values, {target = package}) + package.sourcekinds = nil + return flags +end + +-- map linker flags +function map_linkflags(package, targetkind, sourcekinds, name, values) + -- @note we need to patch package:sourcekinds(), because it wiil be called nf_runtime for gcc/clang + package.sourcekinds = function (self) + return sourcekinds + end + local flags = linker.map_flags(targetkind, sourcekinds, name, values, {target = package}) + package.sourcekinds = nil + return flags +end + From b7ef860d94d16822e75d56b6f48ad3416913e095 Mon Sep 17 00:00:00 2001 From: ruki Date: Sat, 31 Aug 2024 00:43:21 +0800 Subject: [PATCH 5/5] rename api --- xmake/modules/package/tools/autoconf.lua | 50 ++++++++++----------- xmake/modules/package/tools/cmake.lua | 54 +++++++++++------------ xmake/modules/package/tools/make.lua | 6 +-- xmake/modules/package/tools/meson.lua | 20 ++++----- xmake/modules/private/utils/toolchain.lua | 8 ++-- 5 files changed, 69 insertions(+), 69 deletions(-) diff --git a/xmake/modules/package/tools/autoconf.lua b/xmake/modules/package/tools/autoconf.lua index 630bd9dbc4f..b84ac87e4c2 100644 --- a/xmake/modules/package/tools/autoconf.lua +++ b/xmake/modules/package/tools/autoconf.lua @@ -188,13 +188,13 @@ function _get_cflags_from_packagedeps(package, opt) local result = {} if values then if values.defines then - table.join2(result, toolchain_utils.map_compflags(package, "cxx", "define", values.defines)) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "define", values.defines)) end if values.includedirs then - table.join2(result, _translate_paths(toolchain_utils.map_compflags(package, "cxx", "includedir", values.includedirs))) + table.join2(result, _translate_paths(toolchain_utils.map_compflags_for_package(package, "cxx", "includedir", values.includedirs))) end if values.sysincludedirs then - table.join2(result, _translate_paths(toolchain_utils.map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs))) + table.join2(result, _translate_paths(toolchain_utils.map_compflags_for_package(package, "cxx", "sysincludedir", values.sysincludedirs))) end end return result @@ -219,16 +219,16 @@ function _get_ldflags_from_packagedeps(package, opt) local result = {} if values then if values.linkdirs then - table.join2(result, _translate_paths(toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs))) + table.join2(result, _translate_paths(toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "linkdir", values.linkdirs))) end if values.links then - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", values.links)) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "link", values.links)) end if values.syslinks then - table.join2(result, _translate_paths(toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks))) + table.join2(result, _translate_paths(toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "syslink", values.syslinks))) end if values.frameworks then - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "framework", values.frameworks)) end end return result @@ -295,21 +295,21 @@ function buildenvs(package, opt) table.join2(cxxflags, _get_cflags_from_packagedeps(package, opt)) table.join2(cppflags, _get_cflags_from_packagedeps(package, opt)) table.join2(ldflags, _get_ldflags_from_packagedeps(package, opt)) - table.join2(cflags, toolchain_utils.map_compflags(package, "c", "define", defines)) - table.join2(cflags, toolchain_utils.map_compflags(package, "c", "includedir", includedirs)) - table.join2(cflags, toolchain_utils.map_compflags(package, "c", "sysincludedir", sysincludedirs)) - table.join2(asflags, toolchain_utils.map_compflags(package, "as", "define", defines)) - table.join2(asflags, toolchain_utils.map_compflags(package, "as", "includedir", includedirs)) - table.join2(asflags, toolchain_utils.map_compflags(package, "as", "sysincludedir", sysincludedirs)) - table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "define", defines)) - table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "includedir", includedirs)) - table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "sysincludedir", sysincludedirs)) - table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", links)) - table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", syslinks)) - table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", linkdirs)) - table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "link", links)) - table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "syslink", syslinks)) - table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "linkdir", linkdirs)) + table.join2(cflags, toolchain_utils.map_compflags_for_package(package, "c", "define", defines)) + table.join2(cflags, toolchain_utils.map_compflags_for_package(package, "c", "includedir", includedirs)) + table.join2(cflags, toolchain_utils.map_compflags_for_package(package, "c", "sysincludedir", sysincludedirs)) + table.join2(asflags, toolchain_utils.map_compflags_for_package(package, "as", "define", defines)) + table.join2(asflags, toolchain_utils.map_compflags_for_package(package, "as", "includedir", includedirs)) + table.join2(asflags, toolchain_utils.map_compflags_for_package(package, "as", "sysincludedir", sysincludedirs)) + table.join2(cxxflags, toolchain_utils.map_compflags_for_package(package, "cxx", "define", defines)) + table.join2(cxxflags, toolchain_utils.map_compflags_for_package(package, "cxx", "includedir", includedirs)) + table.join2(cxxflags, toolchain_utils.map_compflags_for_package(package, "cxx", "sysincludedir", sysincludedirs)) + table.join2(ldflags, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "link", links)) + table.join2(ldflags, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "syslink", syslinks)) + table.join2(ldflags, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "linkdir", linkdirs)) + table.join2(shflags, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "link", links)) + table.join2(shflags, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "syslink", syslinks)) + table.join2(shflags, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "linkdir", linkdirs)) envs.CC = package:build_getenv("cc") envs.AS = package:build_getenv("as") envs.AR = package:build_getenv("ar") @@ -330,9 +330,9 @@ function buildenvs(package, opt) end local runtimes = package:runtimes() if runtimes then - table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "runtime", runtimes)) - table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "runtime", runtimes)) - table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "runtime", runtimes)) + table.join2(cxxflags, toolchain_utils.map_compflags_for_package(package, "cxx", "runtime", runtimes)) + table.join2(ldflags, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "runtime", runtimes)) + table.join2(shflags, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "runtime", runtimes)) end if package:config("asan") then table.join2(cflags, package:_generate_sanitizer_configs("address", "cc").cflags) diff --git a/xmake/modules/package/tools/cmake.lua b/xmake/modules/package/tools/cmake.lua index 10ca6cbe691..35d5a3f07b8 100644 --- a/xmake/modules/package/tools/cmake.lua +++ b/xmake/modules/package/tools/cmake.lua @@ -134,13 +134,13 @@ function _get_cflags_from_packagedeps(package, opt) local result = {} if values then if values.defines then - table.join2(result, toolchain_utils.map_compflags(package, "cxx", "define", values.defines)) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "define", values.defines)) end if values.includedirs then - table.join2(result, _translate_paths(toolchain_utils.map_compflags(package, "cxx", "includedir", values.includedirs))) + table.join2(result, _translate_paths(toolchain_utils.map_compflags_for_package(package, "cxx", "includedir", values.includedirs))) end if values.sysincludedirs then - table.join2(result, _translate_paths(toolchain_utils.map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs))) + table.join2(result, _translate_paths(toolchain_utils.map_compflags_for_package(package, "cxx", "sysincludedir", values.sysincludedirs))) end end return result @@ -165,16 +165,16 @@ function _get_ldflags_from_packagedeps(package, opt) local result = {} if values then if values.linkdirs then - table.join2(result, _translate_paths(toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs))) + table.join2(result, _translate_paths(toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "linkdir", values.linkdirs))) end if values.links then - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", values.links)) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "link", values.links)) end if values.syslinks then - table.join2(result, _translate_paths(toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks))) + table.join2(result, _translate_paths(toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "syslink", values.syslinks))) end if values.frameworks then - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "framework", values.frameworks)) end end return result @@ -187,9 +187,9 @@ function _get_cflags(package, opt) if opt.cross then table.join2(result, package:build_getenv("cflags")) table.join2(result, package:build_getenv("cxflags")) - table.join2(result, toolchain_utils.map_compflags(package, "c", "define", package:build_getenv("defines"))) - table.join2(result, toolchain_utils.map_compflags(package, "c", "includedir", package:build_getenv("includedirs"))) - table.join2(result, toolchain_utils.map_compflags(package, "c", "sysincludedir", package:build_getenv("sysincludedirs"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "c", "define", package:build_getenv("defines"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "c", "includedir", package:build_getenv("includedirs"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "c", "sysincludedir", package:build_getenv("sysincludedirs"))) end table.join2(result, package:config("cflags")) table.join2(result, package:config("cxflags")) @@ -218,9 +218,9 @@ function _get_cxxflags(package, opt) if opt.cross then table.join2(result, package:build_getenv("cxxflags")) table.join2(result, package:build_getenv("cxflags")) - table.join2(result, toolchain_utils.map_compflags(package, "cxx", "define", package:build_getenv("defines"))) - table.join2(result, toolchain_utils.map_compflags(package, "cxx", "includedir", package:build_getenv("includedirs"))) - table.join2(result, toolchain_utils.map_compflags(package, "cxx", "sysincludedir", package:build_getenv("sysincludedirs"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "define", package:build_getenv("defines"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "includedir", package:build_getenv("includedirs"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "sysincludedir", package:build_getenv("sysincludedirs"))) end table.join2(result, package:config("cxxflags")) table.join2(result, package:config("cxflags")) @@ -248,9 +248,9 @@ function _get_asflags(package, opt) local result = {} if opt.cross then table.join2(result, package:build_getenv("asflags")) - table.join2(result, toolchain_utils.map_compflags(package, "as", "define", package:build_getenv("defines"))) - table.join2(result, toolchain_utils.map_compflags(package, "as", "includedir", package:build_getenv("includedirs"))) - table.join2(result, toolchain_utils.map_compflags(package, "as", "sysincludedir", package:build_getenv("sysincludedirs"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "as", "define", package:build_getenv("defines"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "as", "includedir", package:build_getenv("includedirs"))) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "as", "sysincludedir", package:build_getenv("sysincludedirs"))) end table.join2(result, package:config("asflags")) if opt.asflags then @@ -267,9 +267,9 @@ function _get_ldflags(package, opt) local result = {} if opt.cross then table.join2(result, package:build_getenv("ldflags")) - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", package:build_getenv("links"))) - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", package:build_getenv("syslinks"))) - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", package:build_getenv("linkdirs"))) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "link", package:build_getenv("links"))) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "syslink", package:build_getenv("syslinks"))) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "linkdir", package:build_getenv("linkdirs"))) end table.join2(result, package:config("ldflags")) if package:config("lto") then @@ -293,9 +293,9 @@ function _get_shflags(package, opt) local result = {} if opt.cross then table.join2(result, package:build_getenv("shflags")) - table.join2(result, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "link", package:build_getenv("links"))) - table.join2(result, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "syslink", package:build_getenv("syslinks"))) - table.join2(result, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "linkdir", package:build_getenv("linkdirs"))) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "link", package:build_getenv("links"))) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "syslink", package:build_getenv("syslinks"))) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "linkdir", package:build_getenv("linkdirs"))) end table.join2(result, package:config("shflags")) if package:config("lto") then @@ -869,11 +869,11 @@ function _get_envs_for_runtime_flags(package, configs, opt) local envs = {} local runtimes = package:runtimes() if runtimes then - envs[format("CMAKE_C_FLAGS_%s", buildtype)] = toolchain_utils.map_compflags(package, "c", "runtime", runtimes) - envs[format("CMAKE_CXX_FLAGS_%s", buildtype)] = toolchain_utils.map_compflags(package, "cxx", "runtime", runtimes) - envs[format("CMAKE_EXE_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "runtime", runtimes) - envs[format("CMAKE_STATIC_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags(package, "static", {"cxx"}, "runtime", runtimes) - envs[format("CMAKE_SHARED_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_C_FLAGS_%s", buildtype)] = toolchain_utils.map_compflags_for_package(package, "c", "runtime", runtimes) + envs[format("CMAKE_CXX_FLAGS_%s", buildtype)] = toolchain_utils.map_compflags_for_package(package, "cxx", "runtime", runtimes) + envs[format("CMAKE_EXE_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_STATIC_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags_for_package(package, "static", {"cxx"}, "runtime", runtimes) + envs[format("CMAKE_SHARED_LINKER_FLAGS_%s", buildtype)] = toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "runtime", runtimes) end return envs end diff --git a/xmake/modules/package/tools/make.lua b/xmake/modules/package/tools/make.lua index 99e813c4a7f..9399fa9007a 100644 --- a/xmake/modules/package/tools/make.lua +++ b/xmake/modules/package/tools/make.lua @@ -42,9 +42,9 @@ function buildenvs(package) local shflags = table.copy(table.wrap(package:config("shflags"))) local runtimes = package:runtimes() if runtimes then - table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "runtime", runtimes)) - table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "runtime", runtimes)) - table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "runtime", runtimes)) + table.join2(cxxflags, toolchain_utils.map_compflags_for_package(package, "cxx", "runtime", runtimes)) + table.join2(ldflags, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "runtime", runtimes)) + table.join2(shflags, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "runtime", runtimes)) end if package:is_plat(os.host()) then if package:is_plat("linux") and package:is_arch("i386") then diff --git a/xmake/modules/package/tools/meson.lua b/xmake/modules/package/tools/meson.lua index 641a57eb2c1..21ab6faf186 100644 --- a/xmake/modules/package/tools/meson.lua +++ b/xmake/modules/package/tools/meson.lua @@ -291,9 +291,9 @@ function _get_configs_file(package, opt) -- add runtimes flags for _, runtime in ipairs(package:runtimes()) do if not runtime:startswith("M") then - table.join2(cxxflags, toolchain_utils.map_compflags(package, "cxx", "runtime", {runtime})) - table.join2(ldflags, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "runtime", {runtime})) - table.join2(shflags, toolchain_utils.map_linkflags(package, "shared", {"cxx"}, "runtime", {runtime})) + table.join2(cxxflags, toolchain_utils.map_compflags_for_package(package, "cxx", "runtime", {runtime})) + table.join2(ldflags, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "runtime", {runtime})) + table.join2(shflags, toolchain_utils.map_linkflags_for_package(package, "shared", {"cxx"}, "runtime", {runtime})) end end if #cflags > 0 then @@ -412,13 +412,13 @@ function _get_cflags_from_packagedeps(package, opt) local result = {} if values then if values.defines then - table.join2(result, toolchain_utils.map_compflags(package, "cxx", "define", values.defines)) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "define", values.defines)) end if values.includedirs then - table.join2(result, toolchain_utils.map_compflags(package, "cxx", "includedir", values.includedirs)) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "includedir", values.includedirs)) end if values.sysincludedirs then - table.join2(result, toolchain_utils.map_compflags(package, "cxx", "sysincludedir", values.sysincludedirs)) + table.join2(result, toolchain_utils.map_compflags_for_package(package, "cxx", "sysincludedir", values.sysincludedirs)) end end return _translate_flags(package, result) @@ -443,16 +443,16 @@ function _get_ldflags_from_packagedeps(package, opt) local result = {} if values then if values.linkdirs then - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "linkdir", values.linkdirs)) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "linkdir", values.linkdirs)) end if values.links then - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "link", values.links)) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "link", values.links)) end if values.syslinks then - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "syslink", values.syslinks)) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "syslink", values.syslinks)) end if values.frameworks then - table.join2(result, toolchain_utils.map_linkflags(package, "binary", {"cxx"}, "framework", values.frameworks)) + table.join2(result, toolchain_utils.map_linkflags_for_package(package, "binary", {"cxx"}, "framework", values.frameworks)) end end return _translate_flags(package, result) diff --git a/xmake/modules/private/utils/toolchain.lua b/xmake/modules/private/utils/toolchain.lua index 634169dacad..855e063d042 100644 --- a/xmake/modules/private/utils/toolchain.lua +++ b/xmake/modules/private/utils/toolchain.lua @@ -50,8 +50,8 @@ function get_vs_toolset_ver(vs_toolset) return toolset_ver end --- map compiler flags -function map_compflags(package, langkind, name, values) +-- map compiler flags for package +function map_compflags_for_package(package, langkind, name, values) -- @note we need to patch package:sourcekinds(), because it wiil be called nf_runtime for gcc/clang package.sourcekinds = function (self) local sourcekind = language.langkinds()[langkind] @@ -62,8 +62,8 @@ function map_compflags(package, langkind, name, values) return flags end --- map linker flags -function map_linkflags(package, targetkind, sourcekinds, name, values) +-- map linker flags for package +function map_linkflags_for_package(package, targetkind, sourcekinds, name, values) -- @note we need to patch package:sourcekinds(), because it wiil be called nf_runtime for gcc/clang package.sourcekinds = function (self) return sourcekinds