remove fake_target

6 files changed, 94 insertions, 124 deletions

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..630bd9dbc 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 938d96dad..10ca6cbe6 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 bb7a8124f..99e813c4a 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 fddf32999..641a57eb2 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 1513a01d6..634169dac 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
+