Skip to content

Commit 15d0fee

Browse files
JablonskiMateuszCompute-Runtime-Automation
JablonskiMateusz
authored and
Compute-Runtime-Automation
committed
fix: improve propagating external functions info to kernel
When relocation points to symbol that is not defined within module mark it as optional. When symbol is available at dynamic linking time then info from the function is retrieved but when the symbol is not available then ignore the dependency. Any unresolved symbol needed for module linking is already handled in a separate place. Related-To: NEO-16243, NEO-16263, NEO-16262, NEO-16268 Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
1 parent a440a3e commit 15d0fee

File tree

8 files changed

+127
-29
lines changed

8 files changed

+127
-29
lines changed

‎shared/source/compiler_interface/external_functions.cpp‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,9 @@ uint32_t getExtFuncDependencies(const FuncNameToIdMapT &funcNameToId, const Func
3737
auto funcDep = funcDependencies[i];
3838
if (funcNameToId.count(funcDep->callerFuncName) == 0 ||
3939
funcNameToId.count(funcDep->usedFuncName) == 0) {
40+
if (funcDep->optional) {
41+
continue;
42+
}
4043
return ERROR_EXTERNAL_FUNCTION_INFO_MISSING;
4144
}
4245
size_t callerId = funcNameToId.at(funcDep->callerFuncName);
@@ -75,6 +78,9 @@ uint32_t resolveExtFuncDependencies(const ExternalFunctionInfosT &externalFuncti
7578
uint32_t resolveKernelDependencies(const ExternalFunctionInfosT &externalFunctionInfos, const FuncNameToIdMapT &funcNameToId, const KernelDependenciesT &kernelDependencies, const KernelDescriptorMapT &nameToKernelDescriptor) {
7679
for (auto &kernelDep : kernelDependencies) {
7780
if (funcNameToId.count(kernelDep->usedFuncName) == 0) {
81+
if (kernelDep->optional) {
82+
continue;
83+
}
7884
return ERROR_EXTERNAL_FUNCTION_INFO_MISSING;
7985
} else if (nameToKernelDescriptor.count(kernelDep->kernelName) == 0) {
8086
return ERROR_KERNEL_DESCRIPTOR_MISSING;

‎shared/source/compiler_interface/external_functions.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35,11 +35,13 @@ struct ExternalFunctionInfo {
3535
struct ExternalFunctionUsageKernel {
3636
std::string usedFuncName;
3737
std::string kernelName;
38+
bool optional = false;
3839
};
3940

4041
struct ExternalFunctionUsageExtFunc {
4142
std::string usedFuncName;
4243
std::string callerFuncName;
44+
bool optional = false;
4345
};
4446

4547
using ExternalFunctionInfosT = std::vector<ExternalFunctionInfo *>;

‎shared/source/compiler_interface/linker.cpp‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -232,6 +232,7 @@ bool LinkerInput::addSymbol(Elf::Elf<numBits> &elf, const SectionNameToSegmentId
232232
auto symbolSectionName = elf.getSectionName(elfSymbol.shndx);
233233
auto segment = getSegmentForSection(symbolSectionName);
234234
if (segment == SegmentType::unknown) {
235+
externalSymbols.push_back(symbolName);
235236
return false;
236237
}
237238

@@ -298,6 +299,7 @@ void LinkerInput::decodeElfSymbolTableAndRelocations(Elf::Elf<numBits> &elf, con
298299

299300
void LinkerInput::parseRelocationForExtFuncUsage(const RelocationInfo &relocInfo, const std::string &kernelName) {
300301

302+
bool isExternalSymbol = false;
301303
auto shouldIgnoreRelocation = [&](const RelocationInfo &relocInfo) {
302304
if (relocInfo.symbolName.empty()) {
303305
return true;
@@ -311,10 +313,8 @@ void LinkerInput::parseRelocationForExtFuncUsage(const RelocationInfo &relocInfo
311313
return true;
312314
}
313315

314-
for (auto specialRelocationName : {implicitArgsRelocationSymbolName, Linker::perThreadOff, Linker::subDeviceID}) {
315-
if (relocInfo.symbolName == specialRelocationName) {
316-
return true;
317-
}
316+
if (std::ranges::find(externalSymbols, relocInfo.symbolName) != externalSymbols.end()) {
317+
isExternalSymbol = true;
318318
}
319319
return false;
320320
};
@@ -328,10 +328,10 @@ void LinkerInput::parseRelocationForExtFuncUsage(const RelocationInfo &relocInfo
328328
return relocInfo.offset >= symbol.offset && relocInfo.offset < symbol.offset + symbol.size;
329329
});
330330
if (callerIt != extFuncSymbols.end()) {
331-
extFunDependencies.push_back({relocInfo.symbolName, callerIt->first});
331+
extFunDependencies.push_back({relocInfo.symbolName, callerIt->first, isExternalSymbol});
332332
}
333333
} else {
334-
kernelDependencies.push_back({relocInfo.symbolName, kernelName});
334+
kernelDependencies.push_back({relocInfo.symbolName, kernelName, isExternalSymbol});
335335
}
336336
}
337337

‎shared/source/compiler_interface/linker.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -183,6 +183,7 @@ struct LinkerInput : NEO::NonCopyableAndNonMovableClass {
183183

184184
Traits traits;
185185
SymbolMap symbols;
186+
std::vector<std::string> externalSymbols;
186187
std::vector<std::pair<std::string, SymbolInfo>> extFuncSymbols;
187188
Relocations dataRelocations;
188189
RelocationsPerInstSegment textRelocations;

‎shared/test/common/compiler_interface/linker_mock.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@ struct WhiteBox<NEO::LinkerInput> : NEO::LinkerInput {
2424

2525
using BaseClass::dataRelocations;
2626
using BaseClass::exportedFunctionsSegmentId;
27+
using BaseClass::externalSymbols;
2728
using BaseClass::extFuncSymbols;
2829
using BaseClass::extFunDependencies;
2930
using BaseClass::kernelDependencies;

‎shared/test/common/mocks/mock_elf.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ struct MockElf : public NEO::Elf::Elf<numBits> {
5757
relocations.emplace_back(reloc);
5858
}
5959

60-
void setupSecionNames(std::unordered_map<uint32_t, std::string> map) {
60+
void setupSectionNames(std::unordered_map<uint32_t, std::string> map) {
6161
sectionNames = map;
6262
overrideSectionNames = true;
6363
}

‎shared/test/unit_test/compiler_interface/external_functions_tests.cpp‎

Lines changed: 61 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -97,10 +97,16 @@ struct ExternalFunctionsTests : public ::testing::Test {
9797
nameToKernelDescriptor[kernelName] = kd.get();
9898
}
9999
void addFuncDependency(const std::string &calleeName, const std::string &callerName) {
100-
funcDependenciesStorage.push_back({calleeName, callerName});
100+
funcDependenciesStorage.push_back({calleeName, callerName, false});
101101
}
102102
void addKernelDependency(const std::string &calleeName, const std::string &kernelCallerName) {
103-
kernelDependenciesStorage.push_back({calleeName, kernelCallerName});
103+
kernelDependenciesStorage.push_back({calleeName, kernelCallerName, false});
104+
}
105+
void addOptionalFuncDependency(const std::string &calleeName, const std::string &callerName) {
106+
funcDependenciesStorage.push_back({calleeName, callerName, true});
107+
}
108+
void addOptionalKernelDependency(const std::string &calleeName, const std::string &kernelCallerName) {
109+
kernelDependenciesStorage.push_back({calleeName, kernelCallerName, true});
104110
}
105111

106112
void clear() {
@@ -157,13 +163,41 @@ TEST_F(ExternalFunctionsTests, GivenMissingExtFuncInLookupMapWhenResolvingExtFun
157163
EXPECT_EQ(ERROR_EXTERNAL_FUNCTION_INFO_MISSING, error);
158164
}
159165

166+
TEST_F(ExternalFunctionsTests, GivenMissingOptionalExtFuncInLookupMapWhenResolvingExtFuncDependenciesThenReturnSuccess) {
167+
addOptionalFuncDependency("fun1", "fun0");
168+
set();
169+
auto error = resolveExtFuncDependencies(extFuncInfo, funcNameToId, functionDependencies);
170+
EXPECT_EQ(RESOLVE_SUCCESS, error);
171+
clear();
172+
173+
addOptionalFuncDependency("fun1", "fun0");
174+
addExternalFunction("fun1", {});
175+
set();
176+
error = resolveExtFuncDependencies(extFuncInfo, funcNameToId, functionDependencies);
177+
EXPECT_EQ(RESOLVE_SUCCESS, error);
178+
clear();
179+
180+
addOptionalFuncDependency("fun1", "fun0");
181+
addExternalFunction("fun0", {});
182+
set();
183+
error = resolveExtFuncDependencies(extFuncInfo, funcNameToId, functionDependencies);
184+
EXPECT_EQ(RESOLVE_SUCCESS, error);
185+
}
186+
160187
TEST_F(ExternalFunctionsTests, GivenMissingExtFuncInLookupMapWhenResolvingKernelDependenciesThenReturnError) {
161188
addKernel("kernel");
162189
addKernelDependency("fun0", "kernel");
163190
set();
164191
auto error = resolveKernelDependencies(extFuncInfo, funcNameToId, kernelDependencies, nameToKernelDescriptor);
165192
EXPECT_EQ(ERROR_EXTERNAL_FUNCTION_INFO_MISSING, error);
166193
}
194+
TEST_F(ExternalFunctionsTests, GivenMissingOptionalExtFuncInLookupMapWhenResolvingKernelDependenciesThenReturnSuccess) {
195+
addKernel("kernel");
196+
addOptionalKernelDependency("fun0", "kernel");
197+
set();
198+
auto error = resolveKernelDependencies(extFuncInfo, funcNameToId, kernelDependencies, nameToKernelDescriptor);
199+
EXPECT_EQ(RESOLVE_SUCCESS, error);
200+
}
167201

168202
TEST_F(ExternalFunctionsTests, GivenMissingKernelInLookupMapWhenResolvingKernelDependenciesThenReturnError) {
169203
addExternalFunction("fun0", {});
@@ -294,3 +328,28 @@ TEST_F(ExternalFunctionsTests, GivenValidFunctionAndKernelDependenciesWhenResolv
294328
EXPECT_FALSE(nameToKernelDescriptor["kernel1"]->kernelAttributes.flags.hasIndirectCalls);
295329
EXPECT_TRUE(nameToKernelDescriptor["kernel2"]->kernelAttributes.flags.hasIndirectCalls);
296330
}
331+
332+
TEST_F(ExternalFunctionsTests, GivenValidFunctionAndKernelOptionalDependenciesWhenResolvingDependenciesThenSetAppropriateHasIndirectfCallsAndReturnSuccess) {
333+
addKernel("kernel0");
334+
addKernel("kernel1");
335+
addKernel("kernel2");
336+
addExternalFunction("fun0", {.hasIndirectCalls = false});
337+
addExternalFunction("fun1", {.hasIndirectCalls = true});
338+
addExternalFunction("fun2", {.hasIndirectCalls = false});
339+
340+
addOptionalFuncDependency("fun1", "fun0");
341+
addOptionalKernelDependency("fun0", "kernel0");
342+
addOptionalKernelDependency("fun2", "kernel1");
343+
addOptionalKernelDependency("fun2", "kernel2");
344+
set();
345+
346+
nameToKernelDescriptor["kernel2"]->kernelAttributes.flags.hasIndirectCalls = true;
347+
auto error = resolveExternalDependencies(extFuncInfo, kernelDependencies, functionDependencies, nameToKernelDescriptor);
348+
EXPECT_EQ(RESOLVE_SUCCESS, error);
349+
EXPECT_TRUE(extFuncInfo[funcNameToId["fun0"]]->hasIndirectCalls);
350+
EXPECT_TRUE(extFuncInfo[funcNameToId["fun1"]]->hasIndirectCalls);
351+
EXPECT_FALSE(extFuncInfo[funcNameToId["fun2"]]->hasIndirectCalls);
352+
EXPECT_TRUE(nameToKernelDescriptor["kernel0"]->kernelAttributes.flags.hasIndirectCalls);
353+
EXPECT_FALSE(nameToKernelDescriptor["kernel1"]->kernelAttributes.flags.hasIndirectCalls);
354+
EXPECT_TRUE(nameToKernelDescriptor["kernel2"]->kernelAttributes.flags.hasIndirectCalls);
355+
}

‎shared/test/unit_test/compiler_interface/linker_tests.cpp‎

Lines changed: 49 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -388,7 +388,7 @@ TEST(LinkerInputTests, GivenTwoGlobalSymbolsOfTypeFunctionEachPointingToDifferen
388388
sectionNames[1] = ".data.const";
389389
sectionNames[2] = ".text.hello";
390390

391-
elf64.setupSecionNames(std::move(sectionNames));
391+
elf64.setupSectionNames(std::move(sectionNames));
392392
elf64.overrideSymbolName = true;
393393

394394
elf64.addSymbol(0, 0x1234000, 8, 0, Elf::STT_FUNC, Elf::STB_GLOBAL);
@@ -405,7 +405,7 @@ TEST(LinkerInputTests, GivenGlobalSymbolOfTypeObjectPointingToDataGlobalSectionW
405405
std::unordered_map<uint32_t, std::string> sectionNames;
406406
sectionNames[0] = ".text.abc";
407407
sectionNames[1] = ".data.global";
408-
elf64.setupSecionNames(std::move(sectionNames));
408+
elf64.setupSectionNames(std::move(sectionNames));
409409
elf64.overrideSymbolName = true;
410410

411411
elf64.addSymbol(0, 0x20, 8, 1, Elf::STT_OBJECT, Elf::STB_GLOBAL);
@@ -428,7 +428,7 @@ TEST(LinkerInputTests, GivenGlobalSymbolOfTypeObjectPointingToDataConstSectionWh
428428
std::unordered_map<uint32_t, std::string> sectionNames;
429429
sectionNames[0] = ".text.abc";
430430
sectionNames[1] = ".data.const";
431-
elf64.setupSecionNames(std::move(sectionNames));
431+
elf64.setupSectionNames(std::move(sectionNames));
432432
elf64.overrideSymbolName = true;
433433

434434
elf64.addSymbol(0, 0, 8, 1, Elf::STT_OBJECT, Elf::STB_GLOBAL);
@@ -452,7 +452,7 @@ TEST(LinkerInputTests, GivenGlobalSymbolOfTypeFuncPointingToFunctionsSectionWhen
452452
std::unordered_map<uint32_t, std::string> sectionNames;
453453
sectionNames[0] = ".text.abc";
454454
sectionNames[1] = functionsSectionName.str();
455-
elf64.setupSecionNames(std::move(sectionNames));
455+
elf64.setupSectionNames(std::move(sectionNames));
456456
elf64.overrideSymbolName = true;
457457

458458
elf64.addSymbol(0, 0, 32, 1, Elf::STT_FUNC, Elf::STB_GLOBAL);
@@ -479,7 +479,7 @@ TEST(LinkerInputTests, GivenGlobalSymbolOfTypeDifferentThantObjectOrFuncWhenDeco
479479
std::unordered_map<uint32_t, std::string> sectionNames;
480480
sectionNames[0] = ".text.abc";
481481
sectionNames[1] = ".data.const";
482-
elf64.setupSecionNames(std::move(sectionNames));
482+
elf64.setupSectionNames(std::move(sectionNames));
483483
elf64.overrideSymbolName = true;
484484

485485
elf64.addSymbol(0, 0, 8, 0, Elf::STT_NOTYPE, Elf::STB_GLOBAL);
@@ -490,21 +490,24 @@ TEST(LinkerInputTests, GivenGlobalSymbolOfTypeDifferentThantObjectOrFuncWhenDeco
490490
EXPECT_EQ(0U, linkerInput.getSymbols().size());
491491
}
492492

493-
TEST(LinkerInputTests, GivenGlobalSymbolPointingToSectionDifferentThanInstructionsOrDataWhenDecodingElfThenItIsIgnored) {
493+
TEST(LinkerInputTests, GivenGlobalSymbolPointingToSectionDifferentThanInstructionsOrDataWhenDecodingElfThenItIsIgnoredAndAddedToExternalSymbols) {
494494
MockElf<NEO::Elf::EI_CLASS_64> elf64;
495495

496496
std::unordered_map<uint32_t, std::string> sectionNames;
497497
sectionNames[0] = ""; // UNDEF section
498498
sectionNames[1] = ".text.abc";
499-
elf64.setupSecionNames(std::move(sectionNames));
499+
elf64.setupSectionNames(std::move(sectionNames));
500500
elf64.overrideSymbolName = true;
501501

502-
elf64.addSymbol(0, 0, 8, 0, Elf::STT_OBJECT, Elf::STB_GLOBAL);
502+
constexpr uint32_t externalSymbol = 3;
503+
elf64.addSymbol(externalSymbol, 0, 8, 0, Elf::STT_OBJECT, Elf::STB_GLOBAL);
504+
WhiteBox<NEO::LinkerInput> linkerInput;
503505
NEO::LinkerInput::SectionNameToSegmentIdMap nameToKernelId = {{"abc", 0}};
504-
NEO::LinkerInput linkerInput = {};
505506
linkerInput.decodeElfSymbolTableAndRelocations(elf64, nameToKernelId);
506507
EXPECT_TRUE(linkerInput.isValid());
507508
EXPECT_EQ(0U, linkerInput.getSymbols().size());
509+
EXPECT_EQ(1U, linkerInput.externalSymbols.size());
510+
EXPECT_EQ(std::to_string(externalSymbol), linkerInput.externalSymbols[0]);
508511
}
509512

510513
TEST(LInkerInputTests, GivenSymbolPointingToInstructionSegmentAndInvalidInstructionSectionNameMappingWhenDecodingElfThenLinkerInputIsInvalid) {
@@ -513,7 +516,7 @@ TEST(LInkerInputTests, GivenSymbolPointingToInstructionSegmentAndInvalidInstruct
513516

514517
std::unordered_map<uint32_t, std::string> sectionNames;
515518
sectionNames[0] = ".text.abc";
516-
elf64.setupSecionNames(std::move(sectionNames));
519+
elf64.setupSectionNames(std::move(sectionNames));
517520
elf64.overrideSymbolName = true;
518521

519522
elf64.addSymbol(0, 0, 8, 0, Elf::STT_FUNC, Elf::STB_GLOBAL);
@@ -532,7 +535,7 @@ TEST(LinkerInputTests, GivenInstructionRelocationAndInvalidInstructionSectionNam
532535
sectionNames[0] = ".text.abc";
533536
sectionNames[1] = ".data.const";
534537

535-
elf64.setupSecionNames(std::move(sectionNames));
538+
elf64.setupSectionNames(std::move(sectionNames));
536539
elf64.addReloc(64, 0, Zebin::Elf::R_ZE_SYM_ADDR, 0, 0, "0");
537540

538541
elf64.overrideSymbolName = true;
@@ -548,7 +551,7 @@ TEST(LinkerInputTests, GivenRelocationWithSymbolIdOutOfBoundsOfSymbolTableWhenDe
548551
MockElf<NEO::Elf::EI_CLASS_64> elf64;
549552

550553
std::unordered_map<uint32_t, std::string> sectionNames = {{0, ".text.abc"}};
551-
elf64.setupSecionNames(std::move(sectionNames));
554+
elf64.setupSectionNames(std::move(sectionNames));
552555

553556
elf64.addReloc(64, 0, Zebin::Elf::R_ZE_SYM_ADDR, 0, 2, "symbol");
554557

@@ -564,7 +567,7 @@ TEST(LinkerInputTests, GivenRelocationToSectionDifferentThanDataOrInstructionsWh
564567

565568
std::unordered_map<uint32_t, std::string> sectionNames = {{0, ".text.abc"},
566569
{1, "unknown.section"}};
567-
elf64.setupSecionNames(std::move(sectionNames));
570+
elf64.setupSectionNames(std::move(sectionNames));
568571
elf64.addReloc(64, 0, Zebin::Elf::R_ZE_SYM_ADDR, 1, 2, "symbol");
569572

570573
NEO::LinkerInput::SectionNameToSegmentIdMap nameToKernelId;
@@ -584,7 +587,7 @@ TEST(LinkerInputTests, GivenGlobalDataRelocationWithLocalSymbolPointingToConstDa
584587
sectionNames[1] = ".data.const";
585588
sectionNames[2] = ".data.global";
586589

587-
elf64.setupSecionNames(std::move(sectionNames));
590+
elf64.setupSectionNames(std::move(sectionNames));
588591
elf64.addReloc(64, 10, Zebin::Elf::R_ZE_SYM_ADDR, 2, 0, "0");
589592

590593
elf64.overrideSymbolName = true;
@@ -617,7 +620,7 @@ TEST(LinkerInputTests, GivenInstructionRelocationWithLocalSymbolPointingToFuncti
617620
sectionNames[0] = ".text.abc";
618621
sectionNames[1] = functionsSectionName.str();
619622

620-
elf64.setupSecionNames(std::move(sectionNames));
623+
elf64.setupSectionNames(std::move(sectionNames));
621624
elf64.addReloc(64, 10, Zebin::Elf::R_ZE_SYM_ADDR, 0, 0, "0");
622625

623626
elf64.overrideSymbolName = true;
@@ -791,7 +794,7 @@ TEST(LinkerInputTests, GivenExternalFunctionsSymbolsUsedInKernelRelocationsWhenP
791794
EXPECT_EQ(kernelName, mockLinkerInput.kernelDependencies[0].kernelName);
792795
}
793796

794-
TEST(LinkerInputTests, GivenNonFunctionRelocationInKernelRelocationsWhenParsingRelocationsForExtFuncUsageForKernelThenDoNotAddKernelDependency) {
797+
TEST(LinkerInputTests, GivenNonFunctionSymbolRelocationInKernelRelocationsWhenParsingRelocationsForExtFuncUsageForKernelThenDoNotAddKernelDependency) {
795798
WhiteBox<NEO::LinkerInput> mockLinkerInput;
796799

797800
auto &symbols = mockLinkerInput.symbols;
@@ -806,11 +809,8 @@ TEST(LinkerInputTests, GivenNonFunctionRelocationInKernelRelocationsWhenParsingR
806809
symbols.emplace("fun", symbol2);
807810

808811
for (auto nonFuncRelocationName : {
809-
implicitArgsRelocationSymbolName,
810812
std::string_view(".str"),
811813
std::string_view("globalVar"),
812-
Linker::perThreadOff,
813-
Linker::subDeviceID,
814814
std::string_view("")}) {
815815

816816
NEO::LinkerInput::RelocationInfo relocInfo{};
@@ -822,6 +822,35 @@ TEST(LinkerInputTests, GivenNonFunctionRelocationInKernelRelocationsWhenParsingR
822822
EXPECT_EQ(0u, mockLinkerInput.kernelDependencies.size());
823823
}
824824
}
825+
826+
TEST(LinkerInputTests, GivenExternalSymbolRelocationInKernelRelocationsWhenParsingRelocationsForExtFuncUsageForKernelThenAddOptionalKernelDependency) {
827+
WhiteBox<NEO::LinkerInput> mockLinkerInput;
828+
829+
auto &externalSymbols = mockLinkerInput.externalSymbols;
830+
831+
externalSymbols.push_back(std::string(implicitArgsRelocationSymbolName));
832+
externalSymbols.push_back(std::string(Linker::perThreadOff));
833+
externalSymbols.push_back(std::string(Linker::subDeviceID));
834+
835+
for (auto relocationName : {
836+
implicitArgsRelocationSymbolName,
837+
Linker::perThreadOff,
838+
Linker::subDeviceID}) {
839+
840+
NEO::LinkerInput::RelocationInfo relocInfo{};
841+
relocInfo.symbolName = relocationName;
842+
843+
std::string kernelName = "kernel";
844+
mockLinkerInput.parseRelocationForExtFuncUsage(relocInfo, kernelName);
845+
EXPECT_TRUE(mockLinkerInput.extFunDependencies.empty());
846+
}
847+
848+
EXPECT_EQ(3u, mockLinkerInput.kernelDependencies.size());
849+
for (auto &kernelDependency : mockLinkerInput.kernelDependencies) {
850+
EXPECT_TRUE(kernelDependency.optional);
851+
}
852+
}
853+
825854
HWTEST_F(LinkerTests, givenEmptyLinkerInputThenLinkerOutputIsEmpty) {
826855
NEO::LinkerInput linkerInput;
827856
NEO::Linker linker(linkerInput);
@@ -2140,7 +2169,7 @@ TEST_F(LinkerTests, GivenDebugDataWhenApplyingDebugDataRelocationsThenRelocation
21402169
sectionNames[4] = ".debug_line";
21412170
sectionNames[5] = ".data.const";
21422171

2143-
elf64.setupSecionNames(std::move(sectionNames));
2172+
elf64.setupSectionNames(std::move(sectionNames));
21442173

21452174
NEO::Elf::Elf<NEO::Elf::EI_CLASS_64>::RelocationInfo reloc0 = {};
21462175
reloc0.offset = 64;

0 commit comments

Comments
 (0)