build: add clang-tidy restriction for Enum case

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

shared/offline_compiler/source/decoder/zebin_manipulator.cpp

@@ -149,7 +149,7 @@ BinaryFormats getBinaryFormatForDisassemble(OclocArgHelper *argHelper, const std
 
 template ZebinDecoder<Elf::EI_CLASS_32>::ZebinDecoder(OclocArgHelper *argHelper);
 template ZebinDecoder<Elf::EI_CLASS_64>::ZebinDecoder(OclocArgHelper *argHelper);
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ZebinDecoder<numBits>::ZebinDecoder(OclocArgHelper *argHelper) : argHelper(argHelper),
                                                                  iga(new IgaWrapper) {
     iga->setMessagePrinter(argHelper->getPrinterRef());
@@ -157,12 +157,12 @@ ZebinDecoder<numBits>::ZebinDecoder(OclocArgHelper *argHelper) : argHelper(argHe
 
 template ZebinDecoder<Elf::EI_CLASS_32>::~ZebinDecoder();
 template ZebinDecoder<Elf::EI_CLASS_64>::~ZebinDecoder();
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ZebinDecoder<numBits>::~ZebinDecoder() {}
 
 template ErrorCode ZebinDecoder<Elf::EI_CLASS_32>::decode();
 template ErrorCode ZebinDecoder<Elf::EI_CLASS_64>::decode();
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinDecoder<numBits>::decode() {
     auto zebinBinary = argHelper->readBinaryFile(this->arguments.binaryFile);
     ArrayRef<const uint8_t> zebinBinaryRef = {reinterpret_cast<const uint8_t *>(zebinBinary.data()),
@@ -202,14 +202,14 @@ ErrorCode ZebinDecoder<numBits>::decode() {
 
 template ErrorCode ZebinDecoder<Elf::EI_CLASS_32>::validateInput(const std::vector<std::string> &args);
 template ErrorCode ZebinDecoder<Elf::EI_CLASS_64>::validateInput(const std::vector<std::string> &args);
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinDecoder<numBits>::validateInput(const std::vector<std::string> &args) {
     return Manipulator::validateInput(args, iga.get(), argHelper, arguments);
 }
 
 template void ZebinDecoder<Elf::EI_CLASS_32>::printHelp();
 template void ZebinDecoder<Elf::EI_CLASS_64>::printHelp();
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 void ZebinDecoder<numBits>::printHelp() {
     argHelper->printf(R"===(Disassembles Zebin.
 Output of such operation is a set of files that can be later used to reassemble back.
@@ -230,13 +230,13 @@ Usage: ocloc disasm -file <file> [-dump <dump_dir>] [-device <device_type>] [-sk
 )===");
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 void ZebinDecoder<numBits>::dump(ConstStringRef name, ArrayRef<const uint8_t> data) {
     auto outPath = arguments.pathToDump + name.str();
     argHelper->saveOutput(outPath, data.begin(), data.size());
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 void ZebinDecoder<numBits>::dumpKernelData(ConstStringRef name, ArrayRef<const uint8_t> data) {
     std::string disassembledKernel;
     if (false == arguments.skipIGAdisassembly &&
@@ -247,7 +247,7 @@ void ZebinDecoder<numBits>::dumpKernelData(ConstStringRef name, ArrayRef<const u
     }
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 void ZebinDecoder<numBits>::dumpSymtab(ElfT &elf, ArrayRef<const uint8_t> symtabData) {
     ArrayRef<const ElfSymT> symbols(reinterpret_cast<const ElfSymT *>(symtabData.begin()),
                                     symtabData.size() / sizeof(ElfSymT));
@@ -277,7 +277,7 @@ void ZebinDecoder<numBits>::dumpSymtab(ElfT &elf, ArrayRef<const uint8_t> symtab
     dump(Zebin::Elf::SectionNames::symtab, ArrayRef<const uint8_t>::fromAny(symbolsFileStr.data(), symbolsFileStr.size()));
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::vector<SectionInfo> ZebinDecoder<numBits>::dumpElfSections(ElfT &elf) {
     std::vector<SectionInfo> sectionInfos;
     for (size_t secId = 1U; secId < elf.sectionHeaders.size(); secId++) {
@@ -302,7 +302,7 @@ std::vector<SectionInfo> ZebinDecoder<numBits>::dumpElfSections(ElfT &elf) {
     return sectionInfos;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 void ZebinDecoder<numBits>::dumpSectionInfo(const std::vector<SectionInfo> &sectionInfos) {
     std::stringstream sectionsInfoStr;
     sectionsInfoStr << "ElfType " << (numBits == Elf::EI_CLASS_64 ? "64b" : "32b") << std::endl;
@@ -314,7 +314,7 @@ void ZebinDecoder<numBits>::dumpSectionInfo(const std::vector<SectionInfo> &sect
     dump(sectionsInfoFilename, ArrayRef<const uint8_t>::fromAny(sectionInfoStr.data(), sectionInfoStr.size()));
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinDecoder<numBits>::decodeZebin(ArrayRef<const uint8_t> zebin, ElfT &outElf) {
     std::string errors, warnings;
     outElf = Elf::decodeElf<numBits>(zebin, errors, warnings);
@@ -327,7 +327,7 @@ ErrorCode ZebinDecoder<numBits>::decodeZebin(ArrayRef<const uint8_t> zebin, ElfT
     return OCLOC_SUCCESS;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::vector<NEO::Zebin::Elf::IntelGTNote> ZebinDecoder<numBits>::getIntelGTNotes(ElfT &elf) {
     std::vector<Zebin::Elf::IntelGTNote> intelGTNotes;
     std::string errors, warnings;
@@ -338,7 +338,7 @@ std::vector<NEO::Zebin::Elf::IntelGTNote> ZebinDecoder<numBits>::getIntelGTNotes
     return intelGTNotes;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 void ZebinDecoder<numBits>::dumpRel(ConstStringRef name, ArrayRef<const uint8_t> data) {
     ArrayRef<const ElfRelT> relocs = {reinterpret_cast<const ElfRelT *>(data.begin()),
                                       data.size() / sizeof(ElfRelT)};
@@ -353,7 +353,7 @@ void ZebinDecoder<numBits>::dumpRel(ConstStringRef name, ArrayRef<const uint8_t>
     dump(name, ArrayRef<const uint8_t>::fromAny(relocsFileStr.data(), relocsFileStr.length()));
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 void ZebinDecoder<numBits>::dumpRela(ConstStringRef name, ArrayRef<const uint8_t> data) {
     ArrayRef<const ElfRelaT> relocs = {reinterpret_cast<const ElfRelaT *>(data.begin()),
                                        data.size() / sizeof(ElfRelaT)};
@@ -371,19 +371,19 @@ void ZebinDecoder<numBits>::dumpRela(ConstStringRef name, ArrayRef<const uint8_t
 
 template ZebinEncoder<Elf::EI_CLASS_32>::ZebinEncoder(OclocArgHelper *argHelper);
 template ZebinEncoder<Elf::EI_CLASS_64>::ZebinEncoder(OclocArgHelper *argHelper);
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ZebinEncoder<numBits>::ZebinEncoder(OclocArgHelper *argHelper) : argHelper(argHelper), iga(new IgaWrapper) {
     iga->setMessagePrinter(argHelper->getPrinterRef());
 }
 
 template ZebinEncoder<Elf::EI_CLASS_32>::~ZebinEncoder();
 template ZebinEncoder<Elf::EI_CLASS_64>::~ZebinEncoder();
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ZebinEncoder<numBits>::~ZebinEncoder() {}
 
 template ErrorCode ZebinEncoder<Elf::EI_CLASS_32>::encode();
 template ErrorCode ZebinEncoder<Elf::EI_CLASS_64>::encode();
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::encode() {
     ErrorCode retVal = OCLOC_SUCCESS;
 
@@ -409,8 +409,8 @@ ErrorCode ZebinEncoder<numBits>::encode() {
     }
 
     ElfEncoderT elfEncoder;
-    elfEncoder.getElfFileHeader().machine = Elf::ELF_MACHINE::EM_INTELGT;
-    elfEncoder.getElfFileHeader().type = Zebin::Elf::ELF_TYPE_ZEBIN::ET_ZEBIN_EXE;
+    elfEncoder.getElfFileHeader().machine = Elf::ElfMachine::EM_INTELGT;
+    elfEncoder.getElfFileHeader().type = Zebin::Elf::ElfTypeZebin::ET_ZEBIN_EXE;
 
     retVal = appendSections(elfEncoder, sectionInfos);
     if (retVal != OCLOC_SUCCESS) {
@@ -426,14 +426,14 @@ ErrorCode ZebinEncoder<numBits>::encode() {
 
 template ErrorCode ZebinEncoder<Elf::EI_CLASS_32>::validateInput(const std::vector<std::string> &args);
 template ErrorCode ZebinEncoder<Elf::EI_CLASS_64>::validateInput(const std::vector<std::string> &args);
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::validateInput(const std::vector<std::string> &args) {
     return Manipulator::validateInput(args, iga.get(), argHelper, arguments);
 }
 
 template void ZebinEncoder<Elf::EI_CLASS_32>::printHelp();
 template void ZebinEncoder<Elf::EI_CLASS_64>::printHelp();
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 void ZebinEncoder<numBits>::printHelp() {
     argHelper->printf(R"===(Assembles Zebin from input files.
 It's expected that input files were previously generated by 'ocloc disasm'
@@ -452,7 +452,7 @@ Usage: ocloc asm -file <file> [-dump <dump_dir>] [-device <device_type>] [-skip-
 )===");
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::vector<char> ZebinEncoder<numBits>::getIntelGTNotesSection(const std::vector<SectionInfo> &sectionInfos) {
     bool containsIntelGTNoteSection = false;
     for (auto &sectionInfo : sectionInfos) {
@@ -469,7 +469,7 @@ std::vector<char> ZebinEncoder<numBits>::getIntelGTNotesSection(const std::vecto
     return argHelper->readBinaryFile(getFilePath(Zebin::Elf::SectionNames::noteIntelGT.data()));
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::vector<NEO::Zebin::Elf::IntelGTNote> ZebinEncoder<numBits>::getIntelGTNotes(const std::vector<char> &intelGtNotesSection) {
     std::vector<Zebin::Elf::IntelGTNote> intelGTNotes;
     std::string errors, warnings;
@@ -482,7 +482,7 @@ std::vector<NEO::Zebin::Elf::IntelGTNote> ZebinEncoder<numBits>::getIntelGTNotes
     return intelGTNotes;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::loadSectionsInfo(std::vector<SectionInfo> &sectionInfos) {
     std::vector<std::string> sectionsInfoLines;
     argHelper->readFileToVectorOfStrings(getFilePath(sectionsInfoFilename.data()), sectionsInfoLines);
@@ -501,7 +501,7 @@ ErrorCode ZebinEncoder<numBits>::loadSectionsInfo(std::vector<SectionInfo> &sect
     return OCLOC_SUCCESS;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::checkIfAllFilesExist(const std::vector<SectionInfo> &sectionInfos) {
     for (auto &sectionInfo : sectionInfos) {
         bool fileExists = argHelper->fileExists(getFilePath(sectionInfo.name));
@@ -517,7 +517,7 @@ ErrorCode ZebinEncoder<numBits>::checkIfAllFilesExist(const std::vector<SectionI
     return OCLOC_SUCCESS;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::appendSections(ElfEncoderT &encoder, const std::vector<SectionInfo> &sectionInfos) {
     SecNameToIdMapT secNameToId;
     size_t symtabIdx = std::numeric_limits<size_t>::max();
@@ -545,7 +545,7 @@ ErrorCode ZebinEncoder<numBits>::appendSections(ElfEncoderT &encoder, const std:
     return retVal;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::appendRel(ElfEncoderT &encoder, const SectionInfo &section, size_t targetSecId, size_t symtabSecId) {
     std::vector<std::string> relocationLines;
     argHelper->readFileToVectorOfStrings(getFilePath(section.name), relocationLines);
@@ -560,7 +560,7 @@ ErrorCode ZebinEncoder<numBits>::appendRel(ElfEncoderT &encoder, const SectionIn
     return OCLOC_SUCCESS;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::appendRela(ElfEncoderT &encoder, const SectionInfo &section, size_t targetSecId, size_t symtabSecId) {
     std::vector<std::string> relocationLines;
     argHelper->readFileToVectorOfStrings(getFilePath(section.name), relocationLines);
@@ -575,12 +575,12 @@ ErrorCode ZebinEncoder<numBits>::appendRela(ElfEncoderT &encoder, const SectionI
     return OCLOC_SUCCESS;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::string ZebinEncoder<numBits>::getFilePath(const std::string &filename) {
     return arguments.pathToDump + filename;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::string ZebinEncoder<numBits>::parseKernelAssembly(ArrayRef<const char> kernelAssembly) {
     std::string kernelAssemblyString(kernelAssembly.begin(), kernelAssembly.end());
     std::string outBinary;
@@ -590,7 +590,7 @@ std::string ZebinEncoder<numBits>::parseKernelAssembly(ArrayRef<const char> kern
     return {};
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::appendKernel(ElfEncoderT &encoder, const SectionInfo &section) {
     if (argHelper->fileExists(getFilePath(section.name + ".asm"))) {
         auto data = argHelper->readBinaryFile(getFilePath(section.name + ".asm"));
@@ -604,7 +604,7 @@ ErrorCode ZebinEncoder<numBits>::appendKernel(ElfEncoderT &encoder, const Sectio
     return OCLOC_SUCCESS;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::appendSymtab(ElfEncoderT &encoder, const SectionInfo &section, size_t strtabSecId, SecNameToIdMapT secNameToId) {
     std::vector<std::string> symTabLines;
     argHelper->readFileToVectorOfStrings(getFilePath(section.name), symTabLines);
@@ -622,14 +622,14 @@ ErrorCode ZebinEncoder<numBits>::appendSymtab(ElfEncoderT &encoder, const Sectio
     return OCLOC_SUCCESS;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 ErrorCode ZebinEncoder<numBits>::appendOther(ElfEncoderT &encoder, const SectionInfo &section) {
     auto sectionData = argHelper->readBinaryFile(getFilePath(section.name));
     encoder.appendSection(section.type, section.name, ArrayRef<const uint8_t>::fromAny(sectionData.data(), sectionData.size()));
     return OCLOC_SUCCESS;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::vector<std::string> ZebinEncoder<numBits>::parseLine(const std::string &line) {
     std::vector<std::string> out;
     auto ss = std::stringstream(line);
@@ -640,7 +640,7 @@ std::vector<std::string> ZebinEncoder<numBits>::parseLine(const std::string &lin
     return out;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::vector<typename ZebinEncoder<numBits>::ElfRelT> ZebinEncoder<numBits>::parseRel(const std::vector<std::string> &relocationsFile) {
     std::vector<ElfRelT> relocs;
     relocs.resize(relocationsFile.size() - 1);
@@ -658,7 +658,7 @@ std::vector<typename ZebinEncoder<numBits>::ElfRelT> ZebinEncoder<numBits>::pars
     return relocs;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::vector<typename ZebinEncoder<numBits>::ElfRelaT> ZebinEncoder<numBits>::parseRela(const std::vector<std::string> &relocationsFile) {
     std::vector<ElfRelaT> relocs;
     relocs.resize(relocationsFile.size() - 1);
@@ -677,7 +677,7 @@ std::vector<typename ZebinEncoder<numBits>::ElfRelaT> ZebinEncoder<numBits>::par
     return relocs;
 }
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 std::vector<typename ZebinEncoder<numBits>::ElfSymT> ZebinEncoder<numBits>::parseSymbols(const std::vector<std::string> &symbolsFile, ElfEncoderT &encoder, size_t &outNumLocalSymbols, SecNameToIdMapT secNameToId) {
     std::vector<ElfSymT> symbols;
     symbols.resize(symbolsFile.size() - 1);

shared/offline_compiler/source/decoder/zebin_manipulator.h

@@ -23,10 +23,10 @@ namespace NEO {
 namespace Elf {
 struct IntelGTNote;
 
-template <ELF_IDENTIFIER_CLASS numBits>
+template <ElfIdentifierClass numBits>
 struct Elf;
 
-template <ELF_IDENTIFIER_CLASS numBits>
+template <ElfIdentifierClass numBits>
 struct ElfEncoder;
 } // namespace Elf
 
@@ -61,7 +61,7 @@ bool is64BitZebin(OclocArgHelper *argHelper, const std::string &sectionsInfoFile
 
 constexpr ConstStringRef sectionsInfoFilename = "sections.txt";
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 class ZebinDecoder {
   public:
     using ElfT = Elf::Elf<numBits>;
@@ -95,7 +95,7 @@ class ZebinDecoder {
     std::unique_ptr<IgaWrapper> iga;
 };
 
-template <Elf::ELF_IDENTIFIER_CLASS numBits>
+template <Elf::ElfIdentifierClass numBits>
 class ZebinEncoder {
   public:
     using ElfEncoderT = Elf::ElfEncoder<numBits>;