Merge pull request #5543 from xmake-io/package

improve linker for package #5542

8 files changed, 124 insertions, 140 deletions

diff --git a/tests/projects/c++/snippet_runtimes/xmake.lua b/tests/projects/c++/snippet_runtimes/xmake.lua
index 1e5436ba4..8ef59ed4f 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 fe22a2e8b..c837b5bdc 100644
--- a/xmake/core/package/package.lua
+++ b/xmake/core/package/package.lua
@@ -1281,9 +1281,9 @@ function _instance:toolconfig(name)
     end
 end
 
--- get the target compiler
+-- 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,11 +1293,28 @@ 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():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():set3("linker", targetkind, sourcekinds, linkerinst)
+    end
+    return linkerinst
+end
+
 -- has the given tool for the current package?
 --
 -- e.g.
@@ -2357,22 +2374,24 @@ 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"
-        local tool, name = self:tool("ld")
-        local linker, errors = linker.load("binary", sourcekind, {target = package})
-        if not linker then
-            os.raise(errors)
+        self.sourcekinds = function (self)
+            return sourcekind
         end
-        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)
+        self.sourcekinds = nil
     end
     if self:config("lto") then
         local configs_lto = self:_generate_lto_configs(opt.sourcekind or "cxx")
diff --git a/xmake/modules/core/tools/clang.lua b/xmake/modules/core/tools/clang.lua
index 76a1f773b..879bdb628 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 8600d7334..b84ac87e4 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_for_package(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_for_package(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_for_package(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_for_package(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_for_package(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_for_package(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_for_package(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_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")
@@ -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_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 9784033b4..8e103959d 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_for_package(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_for_package(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_for_package(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_for_package(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_for_package(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_for_package(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_for_package(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_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"))
@@ -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_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"))
@@ -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_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
@@ -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_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
@@ -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_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
@@ -881,15 +869,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)]             = 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 bb7a8124f..9399fa900 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_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 fddf32999..21ab6faf1 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_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
@@ -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_for_package(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_for_package(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_for_package(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_for_package(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_for_package(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_for_package(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_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 1513a01d6..855e063d0 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 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]
+        return sourcekind
+    end
+    local flags = compiler.map_flags(langkind, name, values, {target = package})
+    package.sourcekinds = nil
+    return flags
+end
+
+-- 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
+    end
+    local flags = linker.map_flags(targetkind, sourcekinds, name, values, {target = package})
+    package.sourcekinds = nil
+    return flags
+end
+