Do not resolve external functions when none passed

This commit adds check in Linker::resolveExternalFunctions checking
if external functions are present before trying to resolve dependencies
and adds default values for ExternalFunctionInfo.

Signed-off-by: Krystian Chmielewski <[email protected]>

Author: KrystianChmielewski

shared/source/compiler_interface/external_functions.h

@@ -22,10 +22,10 @@ enum ExternalFunctionResolveError : uint32_t {
 };
 
 struct ExternalFunctionInfo {
-    std::string functionName;
-    uint8_t barrierCount;
-    uint16_t numGrfRequired;
-    uint8_t simdSize;
+    std::string functionName = "";
+    uint8_t barrierCount = 0U;
+    uint16_t numGrfRequired = 0U;
+    uint8_t simdSize = 0U;
 };
 
 struct ExternalFunctionUsageKernel {

shared/source/compiler_interface/linker.cpp

@@ -504,6 +504,10 @@ void Linker::applyDebugDataRelocations(const NEO::Elf::Elf<NEO::Elf::EI_CLASS_64
 }
 
 bool Linker::resolveExternalFunctions(const KernelDescriptorsT &kernelDescriptors, std::vector<ExternalFunctionInfo> &externalFunctions) {
+    if (externalFunctions.size() == 0U) {
+        return true;
+    }
+
     ExternalFunctionInfosT externalFunctionsPtrs;
     FunctionDependenciesT functionDependenciesPtrs;
     KernelDependenciesT kernelDependenciesPtrs;

shared/test/unit_test/compiler_interface/linker_tests.cpp

@@ -2357,10 +2357,28 @@ TEST(LinkerTests, givenDependencyOnMissingExternalFunctionWhenLinkingThenFail) {
     NEO::Linker::PatchableSegments patchableInstructionSegments;
     NEO::Linker::UnresolvedExternals unresolvedExternals;
     NEO::Linker::KernelDescriptorsT kernelDescriptors;
-    NEO::Linker::ExternalFunctionsT externalFunctions;
+    NEO::Linker::ExternalFunctionsT externalFunctions = {{"fun1", 0U, 128U, 8U}};
     auto linkResult = linker.link(
         globalVar, globalConst, exportedFunc, {},
         patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
         unresolvedExternals, nullptr, nullptr, nullptr, kernelDescriptors, externalFunctions);
     EXPECT_EQ(LinkingStatus::Error, linkResult);
 }
+
+TEST(LinkerTests, givenDependencyOnMissingExternalFunctionAndNoExternalFunctionInfosWhenLinkingThenDoNotResolveDependenciesAndReturnSuccess) {
+    WhiteBox<NEO::LinkerInput> linkerInput;
+    linkerInput.extFunDependencies.push_back({"fun0", "fun1"});
+    NEO::Linker linker(linkerInput);
+    NEO::Linker::SegmentInfo globalVar, globalConst, exportedFunc;
+    NEO::GraphicsAllocation *patchableGlobalVarSeg = nullptr;
+    NEO::GraphicsAllocation *patchableConstVarSeg = nullptr;
+    NEO::Linker::PatchableSegments patchableInstructionSegments;
+    NEO::Linker::UnresolvedExternals unresolvedExternals;
+    NEO::Linker::KernelDescriptorsT kernelDescriptors;
+    NEO::Linker::ExternalFunctionsT externalFunctions;
+    auto linkResult = linker.link(
+        globalVar, globalConst, exportedFunc, {},
+        patchableGlobalVarSeg, patchableConstVarSeg, patchableInstructionSegments,
+        unresolvedExternals, nullptr, nullptr, nullptr, kernelDescriptors, externalFunctions);
+    EXPECT_EQ(LinkingStatus::LinkedFully, linkResult);
+}