style(kernel/elf): change code style

Signed-off-by: EnderIce2 <enderice2@protonmail.com>

Kernel/exec/elf/parse/elf_get_dynamic_tag.cpp

@@ -21,42 +21,31 @@
 
 namespace Execute
 {
-	std::vector<Elf64_Dyn> ELFGetDynamicTag_x86_64(FileNode *fd,
-												   DynamicArrayTags Tag)
+	std::vector<Elf_Dyn> ELFGetDynamicTag(FileNode *fd, DynamicArrayTags Tag)
 	{
-#if defined(__amd64__) || defined(__aarch64__)
-		std::vector<Elf64_Dyn> Ret;
+		std::vector<Elf_Dyn> ret;
+		std::vector<Elf_Phdr> phdrs = ELFGetSymbolType(fd, PT_DYNAMIC);
 
-		Elf64_Ehdr ELFHeader{};
-		fd->Read(&ELFHeader, sizeof(Elf64_Ehdr), 0);
-
-		std::vector<Elf64_Phdr> DYNAMICPhdrs = ELFGetSymbolType_x86_64(fd, PT_DYNAMIC);
-
-		if (DYNAMICPhdrs.size() < 1)
+		if (phdrs.size() < 1)
 		{
-			error("No dynamic phdrs found.");
-			return Ret;
+			debug("No dynamic phdrs found.");
+			return ret;
 		}
 
-		for (auto Phdr : DYNAMICPhdrs)
+		for (auto phdr : phdrs)
 		{
-			Elf64_Dyn Dynamic{};
-			for (size_t i = 0; i < Phdr.p_filesz / sizeof(Elf64_Dyn); i++)
+			Elf_Dyn dyn{};
+			for (size_t i = 0; i < phdr.p_filesz / sizeof(Elf_Dyn); i++)
 			{
-				fd->Read(&Dynamic, sizeof(Elf64_Dyn), Phdr.p_offset + (i * sizeof(Elf64_Dyn)));
-
-				if (Dynamic.d_tag != Tag)
+				fd->Read(&dyn, sizeof(Elf_Dyn), phdr.p_offset + (i * sizeof(Elf_Dyn)));
+				if (dyn.d_tag != Tag)
 					continue;
 
-				debug("Found dynamic tag %d at %#lx [d_val: %#lx]",
-					  Tag, &Dynamic, Dynamic.d_un.d_val);
-				Ret.push_back(Dynamic);
+				debug("Found dynamic tag %d at %#lx [d_val: %#lx]", Tag, &dyn, dyn.d_un.d_val);
+				ret.push_back(dyn);
 			}
 		}
 
-		return Ret;
-#elif defined(__i386__)
-		return {};
-#endif
+		return ret;
 	}
 }

Kernel/exec/elf/parse/elf_get_sections.cpp

@@ -21,33 +21,28 @@
 
 namespace Execute
 {
-	std::vector<Elf64_Shdr> ELFGetSections_x86_64(FileNode *fd,
-												  const char *SectionName)
+	std::vector<Elf_Shdr> ELFGetSections(FileNode *fd, const char *SectionName)
 	{
-#if defined(__amd64__) || defined(__aarch64__)
-		std::vector<Elf64_Shdr> Ret;
+		std::vector<Elf_Shdr> ret;
 
-		Elf64_Ehdr ELFHeader{};
-		fd->Read(&ELFHeader, sizeof(Elf64_Ehdr), 0);
+		Elf_Ehdr ehdr{};
+		fd->Read(&ehdr, sizeof(Elf_Ehdr), 0);
 
-		Elf64_Shdr *SectionHeaders = new Elf64_Shdr[ELFHeader.e_shnum];
-		fd->Read(SectionHeaders, sizeof(Elf64_Shdr) * ELFHeader.e_shnum, ELFHeader.e_shoff);
+		Elf_Shdr *sections = new Elf_Shdr[ehdr.e_shnum];
+		fd->Read(sections, sizeof(Elf_Shdr) * ehdr.e_shnum, ehdr.e_shoff);
 
-		char *SectionNames = new char[SectionHeaders[ELFHeader.e_shstrndx].sh_size];
-		fd->Read(SectionNames, SectionHeaders[ELFHeader.e_shstrndx].sh_size, SectionHeaders[ELFHeader.e_shstrndx].sh_offset);
+		char *sectionNames = new char[sections[ehdr.e_shstrndx].sh_size];
+		fd->Read(sectionNames, sections[ehdr.e_shstrndx].sh_size, sections[ehdr.e_shstrndx].sh_offset);
 
-		for (Elf64_Half i = 0; i < ELFHeader.e_shnum; ++i)
+		for (Elf_Half i = 0; i < ehdr.e_shnum; ++i)
 		{
-			const char *Name = SectionNames + SectionHeaders[i].sh_name;
+			const char *Name = sectionNames + sections[i].sh_name;
 			if (strcmp(Name, SectionName) == 0)
-				Ret.push_back(SectionHeaders[i]);
+				ret.push_back(sections[i]);
 		}
 
-		delete[] SectionHeaders;
-		delete[] SectionNames;
-		return Ret;
-#elif defined(__i386__)
-		return {};
-#endif
+		delete[] sections;
+		delete[] sectionNames;
+		return ret;
 	}
 }

Kernel/exec/elf/parse/elf_get_symbol_type.cpp

@@ -21,31 +21,26 @@
 
 namespace Execute
 {
-	std::vector<Elf64_Phdr> ELFGetSymbolType_x86_64(FileNode *fd,
-													SegmentTypes Tag)
+	std::vector<Elf_Phdr> ELFGetSymbolType(FileNode *fd, SegmentTypes Tag)
 	{
-#if defined(__amd64__) || defined(__aarch64__)
-		std::vector<Elf64_Phdr> Ret;
+		std::vector<Elf_Phdr> ret;
 
-		Elf64_Ehdr ELFHeader{};
-		fd->Read(&ELFHeader, sizeof(Elf64_Ehdr), 0);
+		Elf_Ehdr ehdr{};
+		fd->Read(&ehdr, sizeof(Elf_Ehdr), 0);
 
-		Elf64_Phdr ProgramHeaders{};
-		fd->Read(&ProgramHeaders, sizeof(Elf64_Phdr), ELFHeader.e_phoff);
+		Elf_Phdr phdr{};
+		fd->Read(&phdr, sizeof(Elf_Phdr), ehdr.e_phoff);
 
-		off_t currentOffset = ELFHeader.e_phoff;
-		for (Elf64_Half i = 0; i < ELFHeader.e_phnum; i++)
+		off_t off = ehdr.e_phoff;
+		for (Elf_Half i = 0; i < ehdr.e_phnum; i++)
 		{
-			if (ProgramHeaders.p_type == Tag)
-				Ret.push_back(ProgramHeaders);
+			if (phdr.p_type == Tag)
+				ret.push_back(phdr);
 
-			currentOffset += sizeof(Elf64_Phdr);
-			fd->Read(&ProgramHeaders, sizeof(Elf64_Phdr), currentOffset);
+			off += sizeof(Elf_Phdr);
+			fd->Read(&phdr, sizeof(Elf_Phdr), off);
 		}
 
-		return Ret;
-#elif defined(__i386__)
-		return {};
-#endif
+		return ret;
 	}
 }