diff --git a/Kernel/Prekernel/init.cpp b/Kernel/Prekernel/init.cpp
index 73d6ac9d7a..546160209b 100644
--- a/Kernel/Prekernel/init.cpp
+++ b/Kernel/Prekernel/init.cpp
@@ -99,11 +99,11 @@ extern "C" [[noreturn]] void init()
 
     u8* kernel_image = (u8*)(FlatPtr)kernel_module->start;
     // copy the ELF header and program headers because we might end up overwriting them
-    ElfW(Ehdr) kernel_elf_header = *(ElfW(Ehdr)*)kernel_image;
-    ElfW(Phdr) kernel_program_headers[16];
+    Elf_Ehdr kernel_elf_header = *(Elf_Ehdr*)kernel_image;
+    Elf_Phdr kernel_program_headers[16];
     if (kernel_elf_header.e_phnum > array_size(kernel_program_headers))
         halt();
-    __builtin_memcpy(kernel_program_headers, kernel_image + kernel_elf_header.e_phoff, sizeof(ElfW(Phdr)) * kernel_elf_header.e_phnum);
+    __builtin_memcpy(kernel_program_headers, kernel_image + kernel_elf_header.e_phoff, sizeof(Elf_Phdr) * kernel_elf_header.e_phnum);
 
     FlatPtr kernel_physical_base = 0x200000;
     FlatPtr default_kernel_load_base = KERNEL_MAPPING_BASE + 0x200000;
diff --git a/Kernel/Syscalls/execve.cpp b/Kernel/Syscalls/execve.cpp
index d6c8cb5237..0602fa2188 100644
--- a/Kernel/Syscalls/execve.cpp
+++ b/Kernel/Syscalls/execve.cpp
@@ -205,7 +205,7 @@ static ErrorOr<RequiredLoadRange> get_required_load_range(OpenFileDescription& p
     return range;
 }
 
-static ErrorOr<FlatPtr> get_load_offset(const ElfW(Ehdr) & main_program_header, OpenFileDescription& main_program_description, OpenFileDescription* interpreter_description)
+static ErrorOr<FlatPtr> get_load_offset(Elf_Ehdr const& main_program_header, OpenFileDescription& main_program_description, OpenFileDescription* interpreter_description)
 {
     constexpr FlatPtr load_range_start = 0x08000000;
     constexpr FlatPtr load_range_size = 65536 * PAGE_SIZE; // 2**16 * PAGE_SIZE = 256MB
@@ -421,7 +421,7 @@ static ErrorOr<LoadResult> load_elf_object(Memory::AddressSpace& new_space, Open
 
 ErrorOr<LoadResult>
 Process::load(Memory::AddressSpace& new_space, NonnullRefPtr<OpenFileDescription> main_program_description,
-    RefPtr<OpenFileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header, Optional<size_t> minimum_stack_size)
+    RefPtr<OpenFileDescription> interpreter_description, Elf_Ehdr const& main_program_header, Optional<size_t> minimum_stack_size)
 {
     auto load_offset = TRY(get_load_offset(main_program_header, main_program_description, interpreter_description));
 
@@ -463,7 +463,7 @@ void Process::clear_signal_handlers_for_exec()
 }
 
 ErrorOr<void> Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, Vector<NonnullOwnPtr<KString>> arguments, Vector<NonnullOwnPtr<KString>> environment,
-    RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, InterruptsState& previous_interrupts_state, const ElfW(Ehdr) & main_program_header, Optional<size_t> minimum_stack_size)
+    RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, InterruptsState& previous_interrupts_state, Elf_Ehdr const& main_program_header, Optional<size_t> minimum_stack_size)
 {
     VERIFY(is_user_process());
     VERIFY(!Processor::in_critical());
@@ -800,7 +800,7 @@ static ErrorOr<Vector<NonnullOwnPtr<KString>>> find_shebang_interpreter_for_exec
     return ENOEXEC;
 }
 
-ErrorOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size, Optional<size_t>& minimum_stack_size)
+ErrorOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executable(StringView path, Elf_Ehdr const& main_executable_header, size_t main_executable_header_size, size_t file_size, Optional<size_t>& minimum_stack_size)
 {
     // Not using ErrorOr here because we'll want to do the same thing in userspace in the RTLD
     StringBuilder interpreter_path_builder;
@@ -822,17 +822,17 @@ ErrorOr<RefPtr<OpenFileDescription>> Process::find_elf_interpreter_for_executabl
 
         // Validate the program interpreter as a valid elf binary.
         // If your program interpreter is a #! file or something, it's time to stop playing games :)
-        if (interp_metadata.size < (int)sizeof(ElfW(Ehdr)))
+        if (interp_metadata.size < (int)sizeof(Elf_Ehdr))
             return ENOEXEC;
 
         char first_page[PAGE_SIZE] = {};
         auto first_page_buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)&first_page);
         auto nread = TRY(interpreter_description->read(first_page_buffer, sizeof(first_page)));
 
-        if (nread < sizeof(ElfW(Ehdr)))
+        if (nread < sizeof(Elf_Ehdr))
             return ENOEXEC;
 
-        auto* elf_header = (ElfW(Ehdr)*)first_page;
+        auto* elf_header = (Elf_Ehdr*)first_page;
         if (!ELF::validate_elf_header(*elf_header, interp_metadata.size)) {
             dbgln("exec({}): Interpreter ({}) has invalid ELF header", path, interpreter_path);
             return ENOEXEC;
@@ -914,9 +914,9 @@ ErrorOr<void> Process::exec(NonnullOwnPtr<KString> path, Vector<NonnullOwnPtr<KS
 
     // #2) ELF32 for i386
 
-    if (nread < sizeof(ElfW(Ehdr)))
+    if (nread < sizeof(Elf_Ehdr))
         return ENOEXEC;
-    auto const* main_program_header = (ElfW(Ehdr)*)first_page;
+    auto const* main_program_header = (Elf_Ehdr*)first_page;
 
     if (!ELF::validate_elf_header(*main_program_header, metadata.size)) {
         dbgln("exec({}): File has invalid ELF header", path);
diff --git a/Kernel/Syscalls/mmap.cpp b/Kernel/Syscalls/mmap.cpp
index d296da6114..962aa55a3e 100644
--- a/Kernel/Syscalls/mmap.cpp
+++ b/Kernel/Syscalls/mmap.cpp
@@ -56,7 +56,7 @@ static bool should_make_executable_exception_for_dynamic_loader(bool make_readab
     auto const& inode_vm = static_cast<Memory::InodeVMObject const&>(region.vmobject());
     auto const& inode = inode_vm.inode();
 
-    ElfW(Ehdr) header;
+    Elf_Ehdr header;
     auto buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)&header);
     auto result = inode.read_bytes(0, sizeof(header), buffer, nullptr);
     if (result.is_error() || result.value() != sizeof(header))
diff --git a/Kernel/Tasks/Coredump.cpp b/Kernel/Tasks/Coredump.cpp
index 27d7e8213c..46bfda9536 100644
--- a/Kernel/Tasks/Coredump.cpp
+++ b/Kernel/Tasks/Coredump.cpp
@@ -115,7 +115,7 @@ ErrorOr<NonnullRefPtr<OpenFileDescription>> Coredump::try_create_target_file(Pro
 
 ErrorOr<void> Coredump::write_elf_header()
 {
-    ElfW(Ehdr) elf_file_header;
+    Elf_Ehdr elf_file_header;
     elf_file_header.e_ident[EI_MAG0] = 0x7f;
     elf_file_header.e_ident[EI_MAG1] = 'E';
     elf_file_header.e_ident[EI_MAG2] = 'L';
@@ -147,24 +147,24 @@ ErrorOr<void> Coredump::write_elf_header()
 #endif
     elf_file_header.e_version = 1;
     elf_file_header.e_entry = 0;
-    elf_file_header.e_phoff = sizeof(ElfW(Ehdr));
+    elf_file_header.e_phoff = sizeof(Elf_Ehdr);
     elf_file_header.e_shoff = 0;
     elf_file_header.e_flags = 0;
-    elf_file_header.e_ehsize = sizeof(ElfW(Ehdr));
-    elf_file_header.e_shentsize = sizeof(ElfW(Shdr));
-    elf_file_header.e_phentsize = sizeof(ElfW(Phdr));
+    elf_file_header.e_ehsize = sizeof(Elf_Ehdr);
+    elf_file_header.e_shentsize = sizeof(Elf_Shdr);
+    elf_file_header.e_phentsize = sizeof(Elf_Phdr);
     elf_file_header.e_phnum = m_num_program_headers;
     elf_file_header.e_shnum = 0;
     elf_file_header.e_shstrndx = SHN_UNDEF;
 
-    TRY(m_description->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&elf_file_header)), sizeof(ElfW(Ehdr))));
+    TRY(m_description->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&elf_file_header)), sizeof(Elf_Ehdr)));
 
     return {};
 }
 
 ErrorOr<void> Coredump::write_program_headers(size_t notes_size)
 {
-    size_t offset = sizeof(ElfW(Ehdr)) + m_num_program_headers * sizeof(ElfW(Phdr));
+    size_t offset = sizeof(Elf_Ehdr) + m_num_program_headers * sizeof(Elf_Phdr);
     for (auto& region : m_regions) {
 #if !INCLUDE_USERSPACE_HEAP_MEMORY_IN_COREDUMPS
         if (region.looks_like_userspace_heap_region())
@@ -174,7 +174,7 @@ ErrorOr<void> Coredump::write_program_headers(size_t notes_size)
         if (region.access() == Memory::Region::Access::None)
             continue;
 
-        ElfW(Phdr) phdr {};
+        Elf_Phdr phdr {};
 
         phdr.p_type = PT_LOAD;
         phdr.p_offset = offset;
@@ -193,10 +193,10 @@ ErrorOr<void> Coredump::write_program_headers(size_t notes_size)
 
         offset += phdr.p_filesz;
 
-        [[maybe_unused]] auto rc = m_description->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&phdr)), sizeof(ElfW(Phdr)));
+        [[maybe_unused]] auto rc = m_description->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&phdr)), sizeof(Elf_Phdr));
     }
 
-    ElfW(Phdr) notes_pheader {};
+    Elf_Phdr notes_pheader {};
     notes_pheader.p_type = PT_NOTE;
     notes_pheader.p_offset = offset;
     notes_pheader.p_vaddr = 0;
@@ -206,7 +206,7 @@ ErrorOr<void> Coredump::write_program_headers(size_t notes_size)
     notes_pheader.p_align = 0;
     notes_pheader.p_flags = 0;
 
-    TRY(m_description->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&notes_pheader)), sizeof(ElfW(Phdr))));
+    TRY(m_description->write(UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<uint8_t*>(&notes_pheader)), sizeof(Elf_Phdr)));
 
     return {};
 }
diff --git a/Kernel/Tasks/Process.h b/Kernel/Tasks/Process.h
index 3218202bda..e9ec6cd53d 100644
--- a/Kernel/Tasks/Process.h
+++ b/Kernel/Tasks/Process.h
@@ -503,7 +503,7 @@ public:
 
     ErrorOr<void> exec(NonnullOwnPtr<KString> path, Vector<NonnullOwnPtr<KString>> arguments, Vector<NonnullOwnPtr<KString>> environment, Thread*& new_main_thread, InterruptsState& previous_interrupts_state, int recursion_depth = 0);
 
-    ErrorOr<LoadResult> load(Memory::AddressSpace& new_space, NonnullRefPtr<OpenFileDescription> main_program_description, RefPtr<OpenFileDescription> interpreter_description, const ElfW(Ehdr) & main_program_header, Optional<size_t> minimum_stack_size = {});
+    ErrorOr<LoadResult> load(Memory::AddressSpace& new_space, NonnullRefPtr<OpenFileDescription> main_program_description, RefPtr<OpenFileDescription> interpreter_description, Elf_Ehdr const& main_program_header, Optional<size_t> minimum_stack_size = {});
 
     void terminate_due_to_signal(u8 signal);
     ErrorOr<void> send_signal(u8 signal, Process* sender);
@@ -664,12 +664,12 @@ private:
     bool create_perf_events_buffer_if_needed();
     void delete_perf_events_buffer();
 
-    ErrorOr<void> do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, Vector<NonnullOwnPtr<KString>> arguments, Vector<NonnullOwnPtr<KString>> environment, RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, InterruptsState& previous_interrupts_state, const ElfW(Ehdr) & main_program_header, Optional<size_t> minimum_stack_size = {});
+    ErrorOr<void> do_exec(NonnullRefPtr<OpenFileDescription> main_program_description, Vector<NonnullOwnPtr<KString>> arguments, Vector<NonnullOwnPtr<KString>> environment, RefPtr<OpenFileDescription> interpreter_description, Thread*& new_main_thread, InterruptsState& previous_interrupts_state, Elf_Ehdr const& main_program_header, Optional<size_t> minimum_stack_size = {});
     ErrorOr<FlatPtr> do_write(OpenFileDescription&, UserOrKernelBuffer const&, size_t, Optional<off_t> = {});
 
     ErrorOr<FlatPtr> do_statvfs(FileSystem const& path, Custody const*, statvfs* buf);
 
-    ErrorOr<RefPtr<OpenFileDescription>> find_elf_interpreter_for_executable(StringView path, ElfW(Ehdr) const& main_executable_header, size_t main_executable_header_size, size_t file_size, Optional<size_t>& minimum_stack_size);
+    ErrorOr<RefPtr<OpenFileDescription>> find_elf_interpreter_for_executable(StringView path, Elf_Ehdr const& main_executable_header, size_t main_executable_header_size, size_t file_size, Optional<size_t>& minimum_stack_size);
 
     ErrorOr<void> do_kill(Process&, int signal);
     ErrorOr<void> do_killpg(ProcessGroupID pgrp, int signal);
diff --git a/Userland/Libraries/LibC/link.h b/Userland/Libraries/LibC/link.h
index e5458af861..cab297f93e 100644
--- a/Userland/Libraries/LibC/link.h
+++ b/Userland/Libraries/LibC/link.h
@@ -13,10 +13,10 @@
 __BEGIN_DECLS
 
 struct dl_phdr_info {
-    ElfW(Addr) dlpi_addr;
+    Elf_Addr dlpi_addr;
     char const* dlpi_name;
-    const ElfW(Phdr) * dlpi_phdr;
-    ElfW(Half) dlpi_phnum;
+    Elf_Phdr const* dlpi_phdr;
+    Elf_Half dlpi_phnum;
 };
 
 int dl_iterate_phdr(int (*callback)(struct dl_phdr_info* info, size_t size, void* data), void* data);
diff --git a/Userland/Libraries/LibELF/DynamicLinker.cpp b/Userland/Libraries/LibELF/DynamicLinker.cpp
index 44140ef3b5..46ee7aebba 100644
--- a/Userland/Libraries/LibELF/DynamicLinker.cpp
+++ b/Userland/Libraries/LibELF/DynamicLinker.cpp
@@ -244,7 +244,7 @@ static int __dl_iterate_phdr(DlIteratePhdrCallbackFunction callback, void* data)
     for (auto& it : s_global_objects) {
         auto& object = it.value;
         auto info = dl_phdr_info {
-            .dlpi_addr = (ElfW(Addr))object->base_address().as_ptr(),
+            .dlpi_addr = (Elf_Addr)object->base_address().as_ptr(),
             .dlpi_name = object->filepath().characters(),
             .dlpi_phdr = object->program_headers(),
             .dlpi_phnum = object->program_header_count()
diff --git a/Userland/Libraries/LibELF/DynamicLoader.cpp b/Userland/Libraries/LibELF/DynamicLoader.cpp
index 9ad057dfcc..2731b4d216 100644
--- a/Userland/Libraries/LibELF/DynamicLoader.cpp
+++ b/Userland/Libraries/LibELF/DynamicLoader.cpp
@@ -55,7 +55,7 @@ Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> DynamicLoader::try_create(i
 
     VERIFY(stat.st_size >= 0);
     auto size = static_cast<size_t>(stat.st_size);
-    if (size < sizeof(ElfW(Ehdr)))
+    if (size < sizeof(Elf_Ehdr))
         return DlErrorMessage { DeprecatedString::formatted("File {} has invalid ELF header", filepath) };
 
     DeprecatedString file_mmap_name = DeprecatedString::formatted("ELF_DYN: {}", filepath);
@@ -132,7 +132,7 @@ bool DynamicLoader::validate()
     if (!image().is_valid())
         return false;
 
-    auto* elf_header = (ElfW(Ehdr)*)m_file_data;
+    auto* elf_header = (Elf_Ehdr*)m_file_data;
     if (!validate_elf_header(*elf_header, m_file_size))
         return false;
     auto result_or_error = validate_program_headers(*elf_header, m_file_size, { m_file_data, m_file_size });
diff --git a/Userland/Libraries/LibELF/DynamicLoader.h b/Userland/Libraries/LibELF/DynamicLoader.h
index 755881282a..cc00ac1d20 100644
--- a/Userland/Libraries/LibELF/DynamicLoader.h
+++ b/Userland/Libraries/LibELF/DynamicLoader.h
@@ -98,7 +98,7 @@ private:
 
     class ProgramHeaderRegion {
     public:
-        void set_program_header(const ElfW(Phdr) & header) { m_program_header = header; }
+        void set_program_header(Elf_Phdr const& header) { m_program_header = header; }
 
         // Information from ELF Program header
         u32 type() const { return m_program_header.p_type; }
@@ -117,7 +117,7 @@ private:
         bool is_relro() const { return type() == PT_GNU_RELRO; }
 
     private:
-        ElfW(Phdr) m_program_header; // Explicitly a copy of the PHDR in the image
+        Elf_Phdr m_program_header; // Explicitly a copy of the PHDR in the image
     };
 
     // Stage 1
diff --git a/Userland/Libraries/LibELF/DynamicObject.cpp b/Userland/Libraries/LibELF/DynamicObject.cpp
index 94d61d3c99..082710f8e6 100644
--- a/Userland/Libraries/LibELF/DynamicObject.cpp
+++ b/Userland/Libraries/LibELF/DynamicObject.cpp
@@ -21,7 +21,7 @@ DynamicObject::DynamicObject(DeprecatedString const& filepath, VirtualAddress ba
     , m_base_address(base_address)
     , m_dynamic_address(dynamic_section_address)
 {
-    auto* header = (ElfW(Ehdr)*)base_address.as_ptr();
+    auto* header = (Elf_Ehdr*)base_address.as_ptr();
     auto* const phdrs = program_headers();
 
     // Calculate the base address using the PT_LOAD element with the lowest `p_vaddr` (which is the first element)
@@ -200,7 +200,7 @@ void DynamicObject::parse()
         // TODO: FIXME, this shouldn't be hardcoded
         // The reason we need this here is that for some reason, when there only PLT relocations, the compiler
         // doesn't insert a 'PLTRELSZ' entry to the dynamic section
-        m_size_of_relocation_entry = sizeof(ElfW(Rel));
+        m_size_of_relocation_entry = sizeof(Elf_Rel);
     }
 
     // Whether or not RELASZ (stored in m_size_of_relocation_table) only refers to non-PLT entries is not clearly specified.
@@ -226,21 +226,21 @@ DynamicObject::Relocation DynamicObject::RelocationSection::relocation(unsigned
 {
     VERIFY(index < entry_count());
     unsigned offset_in_section = index * entry_size();
-    auto relocation_address = (ElfW(Rela)*)address().offset(offset_in_section).as_ptr();
+    auto relocation_address = (Elf_Rela*)address().offset(offset_in_section).as_ptr();
     return Relocation(m_dynamic, *relocation_address, offset_in_section, m_addend_used);
 }
 
 DynamicObject::Relocation DynamicObject::RelocationSection::relocation_at_offset(unsigned offset) const
 {
     VERIFY(offset <= (m_section_size_bytes - m_entry_size));
-    auto relocation_address = (ElfW(Rela)*)address().offset(offset).as_ptr();
+    auto relocation_address = (Elf_Rela*)address().offset(offset).as_ptr();
     return Relocation(m_dynamic, *relocation_address, offset, m_addend_used);
 }
 
 DynamicObject::Symbol DynamicObject::symbol(unsigned index) const
 {
     auto symbol_section = Section(*this, m_symbol_table_offset, (m_symbol_count * m_size_of_symbol_table_entry), m_size_of_symbol_table_entry, "DT_SYMTAB"sv);
-    auto symbol_entry = (ElfW(Sym)*)symbol_section.address().offset(index * symbol_section.entry_size()).as_ptr();
+    auto symbol_entry = (Elf_Sym*)symbol_section.address().offset(index * symbol_section.entry_size()).as_ptr();
     return Symbol(*this, index, *symbol_entry);
 }
 
@@ -279,16 +279,16 @@ DynamicObject::Section DynamicObject::relr_relocation_section() const
     return Section(*this, m_relr_relocation_table_offset, m_size_of_relr_relocation_table, m_size_of_relr_relocations_entry, "DT_RELR"sv);
 }
 
-ElfW(Half) DynamicObject::program_header_count() const
+Elf_Half DynamicObject::program_header_count() const
 {
-    auto* header = (const ElfW(Ehdr)*)m_base_address.as_ptr();
+    auto* header = (Elf_Ehdr const*)m_base_address.as_ptr();
     return header->e_phnum;
 }
 
-const ElfW(Phdr) * DynamicObject::program_headers() const
+Elf_Phdr const* DynamicObject::program_headers() const
 {
-    auto* header = (const ElfW(Ehdr)*)m_base_address.as_ptr();
-    return (const ElfW(Phdr)*)(m_base_address.as_ptr() + header->e_phoff);
+    auto* header = (Elf_Ehdr const*)m_base_address.as_ptr();
+    return (Elf_Phdr const*)(m_base_address.as_ptr() + header->e_phoff);
 }
 
 auto DynamicObject::HashSection::lookup_sysv_symbol(StringView name, u32 hash_value) const -> Optional<Symbol>
@@ -323,12 +323,12 @@ auto DynamicObject::HashSection::lookup_gnu_symbol(StringView name, u32 hash_val
 
     u32 const* hash_table_begin = (u32*)address().as_ptr();
 
-    const size_t num_buckets = hash_table_begin[0];
-    const size_t num_omitted_symbols = hash_table_begin[1];
-    const u32 num_maskwords = hash_table_begin[2];
+    size_t const num_buckets = hash_table_begin[0];
+    size_t const num_omitted_symbols = hash_table_begin[1];
+    u32 const num_maskwords = hash_table_begin[2];
     // This works because num_maskwords is required to be a power of 2
-    const u32 num_maskwords_bitmask = num_maskwords - 1;
-    const u32 shift2 = hash_table_begin[3];
+    u32 const num_maskwords_bitmask = num_maskwords - 1;
+    u32 const shift2 = hash_table_begin[3];
 
     BloomWord const* bloom_words = (BloomWord const*)&hash_table_begin[4];
     u32 const* const buckets = (u32 const*)&bloom_words[num_maskwords];
@@ -336,7 +336,7 @@ auto DynamicObject::HashSection::lookup_gnu_symbol(StringView name, u32 hash_val
 
     BloomWord hash1 = hash_value;
     BloomWord hash2 = hash1 >> shift2;
-    const BloomWord bitmask = ((BloomWord)1 << (hash1 % bloom_word_size)) | ((BloomWord)1 << (hash2 % bloom_word_size));
+    BloomWord const bitmask = ((BloomWord)1 << (hash1 % bloom_word_size)) | ((BloomWord)1 << (hash2 % bloom_word_size));
 
     if ((bloom_words[(hash1 / bloom_word_size) & num_maskwords_bitmask] & bitmask) != bitmask)
         return {};
@@ -361,13 +361,13 @@ auto DynamicObject::HashSection::lookup_gnu_symbol(StringView name, u32 hash_val
     return {};
 }
 
-StringView DynamicObject::symbol_string_table_string(ElfW(Word) index) const
+StringView DynamicObject::symbol_string_table_string(Elf_Word index) const
 {
     auto const* symbol_string_table_ptr = reinterpret_cast<char const*>(base_address().offset(m_string_table_offset + index).as_ptr());
     return StringView { symbol_string_table_ptr, strlen(symbol_string_table_ptr) };
 }
 
-char const* DynamicObject::raw_symbol_string_table_string(ElfW(Word) index) const
+char const* DynamicObject::raw_symbol_string_table_string(Elf_Word index) const
 {
     return (char const*)base_address().offset(m_string_table_offset + index).as_ptr();
 }
@@ -384,7 +384,7 @@ DynamicObject::FinalizationFunction DynamicObject::fini_section_function() const
     return (FinalizationFunction)fini_section().address().as_ptr();
 }
 
-char const* DynamicObject::name_for_dtag(ElfW(Sword) d_tag)
+char const* DynamicObject::name_for_dtag(Elf_Sword d_tag)
 {
     switch (d_tag) {
     case DT_NULL:
diff --git a/Userland/Libraries/LibELF/DynamicObject.h b/Userland/Libraries/LibELF/DynamicObject.h
index 0b64a57486..2a08fec5fa 100644
--- a/Userland/Libraries/LibELF/DynamicObject.h
+++ b/Userland/Libraries/LibELF/DynamicObject.h
@@ -21,7 +21,7 @@ namespace ELF {
 class DynamicObject : public RefCounted<DynamicObject> {
 public:
     static NonnullRefPtr<DynamicObject> create(DeprecatedString const& filepath, VirtualAddress base_address, VirtualAddress dynamic_section_address);
-    static char const* name_for_dtag(ElfW(Sword) d_tag);
+    static char const* name_for_dtag(Elf_Sword d_tag);
 
     ~DynamicObject();
     void dump() const;
@@ -35,24 +35,24 @@ public:
 
     class DynamicEntry {
     public:
-        explicit DynamicEntry(const ElfW(Dyn) & dyn)
+        explicit DynamicEntry(Elf_Dyn const& dyn)
             : m_dyn(dyn)
         {
         }
 
         ~DynamicEntry() = default;
 
-        ElfW(Sword) tag() const { return m_dyn.d_tag; }
-        ElfW(Addr) ptr() const { return m_dyn.d_un.d_ptr; }
-        ElfW(Word) val() const { return m_dyn.d_un.d_val; }
+        Elf_Sword tag() const { return m_dyn.d_tag; }
+        Elf_Addr ptr() const { return m_dyn.d_un.d_ptr; }
+        Elf_Word val() const { return m_dyn.d_un.d_val; }
 
     private:
-        const ElfW(Dyn) & m_dyn;
+        Elf_Dyn const& m_dyn;
     };
 
     class Symbol {
     public:
-        Symbol(DynamicObject const& dynamic, unsigned index, const ElfW(Sym) & sym)
+        Symbol(DynamicObject const& dynamic, unsigned index, Elf_Sym const& sym)
             : m_dynamic(dynamic)
             , m_sym(sym)
             , m_index(index)
@@ -92,7 +92,7 @@ public:
 
     private:
         DynamicObject const& m_dynamic;
-        const ElfW(Sym) & m_sym;
+        Elf_Sym const& m_sym;
         unsigned const m_index;
     };
 
@@ -153,7 +153,7 @@ public:
 
     class Relocation {
     public:
-        Relocation(DynamicObject const& dynamic, const ElfW(Rela) & rel, unsigned offset_in_section, bool addend_used)
+        Relocation(DynamicObject const& dynamic, Elf_Rela const& rel, unsigned offset_in_section, bool addend_used)
             : m_dynamic(dynamic)
             , m_rel(rel)
             , m_offset_in_section(offset_in_section)
@@ -191,7 +191,7 @@ public:
 
     private:
         DynamicObject const& m_dynamic;
-        const ElfW(Rela) & m_rel;
+        Elf_Rela const& m_rel;
         unsigned const m_offset_in_section;
         bool const m_addend_used;
     };
@@ -246,7 +246,7 @@ public:
 
     typedef void (*InitializationFunction)();
     typedef void (*FinalizationFunction)();
-    typedef ElfW(Addr) (*IfuncResolver)();
+    typedef Elf_Addr (*IfuncResolver)();
 
     bool has_init_section() const { return m_init_offset != 0; }
     bool has_init_array_section() const { return m_init_array_offset != 0; }
@@ -295,8 +295,8 @@ public:
     void set_tls_offset(FlatPtr offset) { m_tls_offset = offset; }
     void set_tls_size(FlatPtr size) { m_tls_size = size; }
 
-    ElfW(Half) program_header_count() const;
-    const ElfW(Phdr) * program_headers() const;
+    Elf_Half program_header_count() const;
+    Elf_Phdr const* program_headers() const;
 
     template<VoidFunction<StringView> F>
     void for_each_needed_library(F) const;
@@ -334,8 +334,8 @@ public:
 private:
     explicit DynamicObject(DeprecatedString const& filepath, VirtualAddress base_address, VirtualAddress dynamic_section_address);
 
-    StringView symbol_string_table_string(ElfW(Word)) const;
-    char const* raw_symbol_string_table_string(ElfW(Word)) const;
+    StringView symbol_string_table_string(Elf_Word) const;
+    char const* raw_symbol_string_table_string(Elf_Word) const;
     void parse();
 
     DeprecatedString m_filepath;
@@ -363,7 +363,7 @@ private:
     FlatPtr m_symbol_table_offset { 0 };
     size_t m_size_of_symbol_table_entry { 0 };
 
-    ElfW(Sword) m_procedure_linkage_table_relocation_type { -1 };
+    Elf_Sword m_procedure_linkage_table_relocation_type { -1 };
     FlatPtr m_plt_relocation_offset_location { 0 }; // offset of PLT relocations, at end of relocations
     size_t m_size_of_plt_relocation_entry_list { 0 };
     Optional<FlatPtr> m_procedure_linkage_table_offset;
@@ -383,14 +383,14 @@ private:
     bool m_is_pie { false };
 
     // DT_FLAGS
-    ElfW(Word) m_dt_flags { 0 };
+    Elf_Word m_dt_flags { 0 };
 
     bool m_has_soname { false };
-    ElfW(Word) m_soname_index { 0 }; // Index into dynstr table for SONAME
+    Elf_Word m_soname_index { 0 }; // Index into dynstr table for SONAME
     bool m_has_rpath { false };
-    ElfW(Word) m_rpath_index { 0 }; // Index into dynstr table for RPATH
+    Elf_Word m_rpath_index { 0 }; // Index into dynstr table for RPATH
     bool m_has_runpath { false };
-    ElfW(Word) m_runpath_index { 0 }; // Index into dynstr table for RUNPATH
+    Elf_Word m_runpath_index { 0 }; // Index into dynstr table for RUNPATH
 
     Optional<FlatPtr> m_tls_offset;
     Optional<FlatPtr> m_tls_size;
@@ -428,7 +428,7 @@ inline void DynamicObject::for_each_relr_relocation(F f) const
     VERIFY(section.entry_size() == sizeof(FlatPtr));
     VERIFY(section.size() >= section.entry_size() * section.entry_count());
 
-    auto* entries = reinterpret_cast<ElfW(Relr)*>(section.address().get());
+    auto* entries = reinterpret_cast<Elf_Relr*>(section.address().get());
     auto base = base_address().get();
     FlatPtr patch_addr = 0;
     for (unsigned i = 0; i < section.entry_count(); ++i) {
@@ -458,7 +458,7 @@ inline void DynamicObject::for_each_symbol(F func) const
 template<IteratorFunction<DynamicObject::DynamicEntry&> F>
 inline void DynamicObject::for_each_dynamic_entry(F func) const
 {
-    auto* dyns = reinterpret_cast<const ElfW(Dyn)*>(m_dynamic_address.as_ptr());
+    auto* dyns = reinterpret_cast<Elf_Dyn const*>(m_dynamic_address.as_ptr());
     for (unsigned i = 0;; ++i) {
         auto&& dyn = DynamicEntry(dyns[i]);
         if (dyn.tag() == DT_NULL)
@@ -483,7 +483,7 @@ inline void DynamicObject::for_each_needed_library(F func) const
     for_each_dynamic_entry([func, this](auto entry) {
         if (entry.tag() != DT_NEEDED)
             return;
-        ElfW(Word) offset = entry.val();
+        Elf_Word offset = entry.val();
         func(symbol_string_table_string(offset));
     });
 }
diff --git a/Userland/Libraries/LibELF/ELFABI.h b/Userland/Libraries/LibELF/ELFABI.h
index 5aecc2f445..5b109991f1 100644
--- a/Userland/Libraries/LibELF/ELFABI.h
+++ b/Userland/Libraries/LibELF/ELFABI.h
@@ -761,6 +761,7 @@ struct elf_args {
 #    define Elf_Sym Elf32_Sym
 #    define Elf_Rel Elf32_Rel
 #    define Elf_RelA Elf32_Rela
+#    define Elf_Rela Elf32_Rela
 #    define Elf_Relr Elf32_Relr
 #    define Elf_Dyn Elf32_Dyn
 #    define Elf_Half Elf32_Half
@@ -789,6 +790,7 @@ struct elf_args {
 #    define Elf_Sym Elf64_Sym
 #    define Elf_Rel Elf64_Rel
 #    define Elf_RelA Elf64_Rela
+#    define Elf_Rela Elf64_Rela
 #    define Elf_Relr Elf64_Relr
 #    define Elf_Dyn Elf64_Dyn
 #    define Elf_Half Elf64_Half
diff --git a/Userland/Libraries/LibELF/Image.cpp b/Userland/Libraries/LibELF/Image.cpp
index bf5ebeaed0..6b66294914 100644
--- a/Userland/Libraries/LibELF/Image.cpp
+++ b/Userland/Libraries/LibELF/Image.cpp
@@ -121,7 +121,7 @@ unsigned Image::program_header_count() const
 
 bool Image::parse()
 {
-    if (m_size < sizeof(ElfW(Ehdr)) || !validate_elf_header(header(), m_size, m_verbose_logging)) {
+    if (m_size < sizeof(Elf_Ehdr) || !validate_elf_header(header(), m_size, m_verbose_logging)) {
         if (m_verbose_logging)
             dbgln("ELF::Image::parse(): ELF Header not valid");
         m_valid = false;
@@ -198,31 +198,31 @@ char const* Image::raw_data(unsigned offset) const
     return reinterpret_cast<char const*>(m_buffer) + offset;
 }
 
-const ElfW(Ehdr) & Image::header() const
+Elf_Ehdr const& Image::header() const
 {
-    VERIFY(m_size >= sizeof(ElfW(Ehdr)));
-    return *reinterpret_cast<const ElfW(Ehdr)*>(raw_data(0));
+    VERIFY(m_size >= sizeof(Elf_Ehdr));
+    return *reinterpret_cast<Elf_Ehdr const*>(raw_data(0));
 }
 
-const ElfW(Phdr) & Image::program_header_internal(unsigned index) const
+Elf_Phdr const& Image::program_header_internal(unsigned index) const
 {
     VERIFY(m_valid);
     VERIFY(index < header().e_phnum);
-    return *reinterpret_cast<const ElfW(Phdr)*>(raw_data(header().e_phoff + (index * sizeof(ElfW(Phdr)))));
+    return *reinterpret_cast<Elf_Phdr const*>(raw_data(header().e_phoff + (index * sizeof(Elf_Phdr))));
 }
 
-const ElfW(Shdr) & Image::section_header(unsigned index) const
+Elf_Shdr const& Image::section_header(unsigned index) const
 {
     VERIFY(m_valid);
     VERIFY(index < header().e_shnum);
-    return *reinterpret_cast<const ElfW(Shdr)*>(raw_data(header().e_shoff + (index * header().e_shentsize)));
+    return *reinterpret_cast<Elf_Shdr const*>(raw_data(header().e_shoff + (index * header().e_shentsize)));
 }
 
 Image::Symbol Image::symbol(unsigned index) const
 {
     VERIFY(m_valid);
     VERIFY(index < symbol_count());
-    auto* raw_syms = reinterpret_cast<const ElfW(Sym)*>(raw_data(section(m_symbol_table_section_index).offset()));
+    auto* raw_syms = reinterpret_cast<Elf_Sym const*>(raw_data(section(m_symbol_table_section_index).offset()));
     return Symbol(*this, index, raw_syms[index]);
 }
 
@@ -243,7 +243,7 @@ Image::ProgramHeader Image::program_header(unsigned index) const
 Image::Relocation Image::RelocationSection::relocation(unsigned index) const
 {
     VERIFY(index < relocation_count());
-    auto* rels = reinterpret_cast<const ElfW(Rel)*>(m_image.raw_data(offset()));
+    auto* rels = reinterpret_cast<Elf_Rel const*>(m_image.raw_data(offset()));
     return Relocation(m_image, rels[index]);
 }
 
@@ -272,7 +272,7 @@ Optional<Image::Section> Image::lookup_section(StringView name) const
     return {};
 }
 
-Optional<StringView> Image::object_file_type_to_string(ElfW(Half) type)
+Optional<StringView> Image::object_file_type_to_string(Elf_Half type)
 {
     switch (type) {
     case ET_NONE:
@@ -290,7 +290,7 @@ Optional<StringView> Image::object_file_type_to_string(ElfW(Half) type)
     }
 }
 
-Optional<StringView> Image::object_machine_type_to_string(ElfW(Half) type)
+Optional<StringView> Image::object_machine_type_to_string(Elf_Half type)
 {
     switch (type) {
     case ET_NONE:
diff --git a/Userland/Libraries/LibELF/Image.h b/Userland/Libraries/LibELF/Image.h
index e137166278..4ca5244b76 100644
--- a/Userland/Libraries/LibELF/Image.h
+++ b/Userland/Libraries/LibELF/Image.h
@@ -44,7 +44,7 @@ public:
 
     class Symbol {
     public:
-        Symbol(Image const& image, unsigned index, const ElfW(Sym) & sym)
+        Symbol(Image const& image, unsigned index, Elf_Sym const& sym)
             : m_image(image)
             , m_sym(sym)
             , m_index(index)
@@ -72,7 +72,7 @@ public:
 
     private:
         Image const& m_image;
-        const ElfW(Sym) & m_sym;
+        Elf_Sym const& m_sym;
         unsigned const m_index;
     };
 
@@ -98,11 +98,11 @@ public:
         bool is_writable() const { return flags() & PF_W; }
         bool is_executable() const { return flags() & PF_X; }
         char const* raw_data() const { return m_image.raw_data(m_program_header.p_offset); }
-        ElfW(Phdr) raw_header() const { return m_program_header; }
+        Elf_Phdr raw_header() const { return m_program_header; }
 
     private:
         Image const& m_image;
-        const ElfW(Phdr) & m_program_header;
+        Elf_Phdr const& m_program_header;
         unsigned m_program_header_index { 0 };
     };
 
@@ -133,7 +133,7 @@ public:
     protected:
         friend class RelocationSection;
         Image const& m_image;
-        const ElfW(Shdr) & m_section_header;
+        Elf_Shdr const& m_section_header;
         unsigned m_section_index;
     };
 
@@ -152,7 +152,7 @@ public:
 
     class Relocation {
     public:
-        Relocation(Image const& image, const ElfW(Rel) & rel)
+        Relocation(Image const& image, Elf_Rel const& rel)
             : m_image(image)
             , m_rel(rel)
         {
@@ -173,7 +173,7 @@ public:
 
     private:
         Image const& m_image;
-        const ElfW(Rel) & m_rel;
+        Elf_Rel const& m_rel;
     };
 
     unsigned symbol_count() const;
@@ -214,8 +214,8 @@ public:
     FlatPtr base_address() const { return (FlatPtr)m_buffer; }
     size_t size() const { return m_size; }
 
-    static Optional<StringView> object_file_type_to_string(ElfW(Half) type);
-    static Optional<StringView> object_machine_type_to_string(ElfW(Half) type);
+    static Optional<StringView> object_file_type_to_string(Elf_Half type);
+    static Optional<StringView> object_machine_type_to_string(Elf_Half type);
     static Optional<StringView> object_abi_type_to_string(Elf_Byte type);
 
     bool has_symbols() const { return symbol_count(); }
@@ -227,9 +227,9 @@ public:
 
 private:
     char const* raw_data(unsigned offset) const;
-    const ElfW(Ehdr) & header() const;
-    const ElfW(Shdr) & section_header(unsigned) const;
-    const ElfW(Phdr) & program_header_internal(unsigned) const;
+    Elf_Ehdr const& header() const;
+    Elf_Shdr const& section_header(unsigned) const;
+    Elf_Phdr const& program_header_internal(unsigned) const;
     StringView table_string(unsigned offset) const;
     StringView section_header_table_string(unsigned offset) const;
     StringView section_index_to_string(unsigned index) const;
diff --git a/Userland/Libraries/LibELF/Relocation.cpp b/Userland/Libraries/LibELF/Relocation.cpp
index 2e9af95141..13dc9c1e51 100644
--- a/Userland/Libraries/LibELF/Relocation.cpp
+++ b/Userland/Libraries/LibELF/Relocation.cpp
@@ -12,8 +12,8 @@ namespace ELF {
 bool perform_relative_relocations(FlatPtr base_address)
 {
 
-    ElfW(Ehdr)* header = (ElfW(Ehdr)*)(base_address);
-    ElfW(Phdr)* pheader = (ElfW(Phdr)*)(base_address + header->e_phoff);
+    Elf_Ehdr* header = (Elf_Ehdr*)(base_address);
+    Elf_Phdr* pheader = (Elf_Phdr*)(base_address + header->e_phoff);
     FlatPtr dynamic_section_addr = 0;
     for (size_t i = 0; i < (size_t)header->e_phnum; ++i, ++pheader) {
         if (pheader->p_type != PT_DYNAMIC)
@@ -30,7 +30,7 @@ bool perform_relative_relocations(FlatPtr base_address)
     FlatPtr relr_relocation_section_addr = 0;
     size_t relr_relocation_table_size = 0;
     bool use_addend = false;
-    auto* dyns = reinterpret_cast<const ElfW(Dyn)*>(dynamic_section_addr);
+    auto* dyns = reinterpret_cast<Elf_Dyn const*>(dynamic_section_addr);
     for (unsigned i = 0;; ++i) {
         auto& dyn = dyns[i];
         if (dyn.d_tag == DT_NULL)
@@ -58,7 +58,7 @@ bool perform_relative_relocations(FlatPtr base_address)
 
     for (unsigned i = 0; i < relocation_count; ++i) {
         size_t offset_in_section = i * relocation_entry_size;
-        auto* relocation = (ElfW(Rela)*)(relocation_section_addr + offset_in_section);
+        auto* relocation = (Elf_Rela*)(relocation_section_addr + offset_in_section);
         VERIFY(ELF64_R_TYPE(relocation->r_info) == R_X86_64_RELATIVE || ELF64_R_TYPE(relocation->r_info) == R_AARCH64_RELATIVE);
         auto* patch_address = (FlatPtr*)(base_address + relocation->r_offset);
         FlatPtr relocated_address;
@@ -78,7 +78,7 @@ bool perform_relative_relocations(FlatPtr base_address)
         __builtin_memcpy(patch_ptr, &relocated_address, sizeof(FlatPtr));
     };
 
-    auto* entries = reinterpret_cast<ElfW(Relr)*>(relr_relocation_section_addr);
+    auto* entries = reinterpret_cast<Elf_Relr*>(relr_relocation_section_addr);
     FlatPtr* patch_ptr = nullptr;
 
     for (unsigned i = 0; i < relr_relocation_table_size / sizeof(FlatPtr); ++i) {
diff --git a/Userland/Libraries/LibELF/Validation.cpp b/Userland/Libraries/LibELF/Validation.cpp
index 8ccb39b3dc..a12bea5126 100644
--- a/Userland/Libraries/LibELF/Validation.cpp
+++ b/Userland/Libraries/LibELF/Validation.cpp
@@ -18,7 +18,7 @@
 
 namespace ELF {
 
-bool validate_elf_header(ElfW(Ehdr) const& elf_header, size_t file_size, bool verbose)
+bool validate_elf_header(Elf_Ehdr const& elf_header, size_t file_size, bool verbose)
 {
     if (!IS_ELF(elf_header)) {
         if (verbose)
@@ -80,9 +80,9 @@ bool validate_elf_header(ElfW(Ehdr) const& elf_header, size_t file_size, bool ve
         return false;
     }
 
-    if (sizeof(ElfW(Ehdr)) != elf_header.e_ehsize) {
+    if (sizeof(Elf_Ehdr) != elf_header.e_ehsize) {
         if (verbose)
-            dbgln("File has incorrect ELF header size..? ({}), expected ({})!", elf_header.e_ehsize, sizeof(ElfW(Ehdr)));
+            dbgln("File has incorrect ELF header size..? ({}), expected ({})!", elf_header.e_ehsize, sizeof(Elf_Ehdr));
         return false;
     }
 
@@ -134,15 +134,15 @@ bool validate_elf_header(ElfW(Ehdr) const& elf_header, size_t file_size, bool ve
         }
     }
 
-    if (0 != elf_header.e_phnum && sizeof(ElfW(Phdr)) != elf_header.e_phentsize) {
+    if (0 != elf_header.e_phnum && sizeof(Elf_Phdr) != elf_header.e_phentsize) {
         if (verbose)
-            dbgln("File has incorrect program header size..? ({}), expected ({}).", elf_header.e_phentsize, sizeof(ElfW(Phdr)));
+            dbgln("File has incorrect program header size..? ({}), expected ({}).", elf_header.e_phentsize, sizeof(Elf_Phdr));
         return false;
     }
 
-    if (sizeof(ElfW(Shdr)) != elf_header.e_shentsize) {
+    if (sizeof(Elf_Shdr) != elf_header.e_shentsize) {
         if (verbose)
-            dbgln("File has incorrect section header size..? ({}), expected ({}).", elf_header.e_shentsize, sizeof(ElfW(Shdr)));
+            dbgln("File has incorrect section header size..? ({}), expected ({}).", elf_header.e_shentsize, sizeof(Elf_Shdr));
         return false;
     }
 
@@ -199,7 +199,7 @@ bool validate_elf_header(ElfW(Ehdr) const& elf_header, size_t file_size, bool ve
     return true;
 }
 
-ErrorOr<bool> validate_program_headers(ElfW(Ehdr) const& elf_header, size_t file_size, ReadonlyBytes buffer, StringBuilder* interpreter_path_builder, Optional<size_t>* requested_stack_size, bool verbose)
+ErrorOr<bool> validate_program_headers(Elf_Ehdr const& elf_header, size_t file_size, ReadonlyBytes buffer, StringBuilder* interpreter_path_builder, Optional<size_t>* requested_stack_size, bool verbose)
 {
     Checked<size_t> total_size_of_program_headers = elf_header.e_phnum;
     total_size_of_program_headers *= elf_header.e_phentsize;
@@ -226,7 +226,7 @@ ErrorOr<bool> validate_program_headers(ElfW(Ehdr) const& elf_header, size_t file
     }
 
     size_t num_program_headers = elf_header.e_phnum;
-    auto program_header_begin = (const ElfW(Phdr)*)buffer.offset(elf_header.e_phoff);
+    auto program_header_begin = (Elf_Phdr const*)buffer.offset(elf_header.e_phoff);
 
     for (size_t header_index = 0; header_index < num_program_headers; ++header_index) {
         auto& program_header = program_header_begin[header_index];
diff --git a/Userland/Libraries/LibELF/Validation.h b/Userland/Libraries/LibELF/Validation.h
index 81c25e7bc6..8cb520f3f2 100644
--- a/Userland/Libraries/LibELF/Validation.h
+++ b/Userland/Libraries/LibELF/Validation.h
@@ -11,7 +11,7 @@
 
 namespace ELF {
 
-bool validate_elf_header(ElfW(Ehdr) const& elf_header, size_t file_size, bool verbose = true);
-ErrorOr<bool> validate_program_headers(ElfW(Ehdr) const& elf_header, size_t file_size, ReadonlyBytes buffer, StringBuilder* interpreter_path_builder = nullptr, Optional<size_t>* requested_stack_size = nullptr, bool verbose = true);
+bool validate_elf_header(Elf_Ehdr const& elf_header, size_t file_size, bool verbose = true);
+ErrorOr<bool> validate_program_headers(Elf_Ehdr const& elf_header, size_t file_size, ReadonlyBytes buffer, StringBuilder* interpreter_path_builder = nullptr, Optional<size_t>* requested_stack_size = nullptr, bool verbose = true);
 
 } // end namespace ELF
diff --git a/Userland/Utilities/file.cpp b/Userland/Utilities/file.cpp
index fe5480afdf..d33be7bde8 100644
--- a/Userland/Utilities/file.cpp
+++ b/Userland/Utilities/file.cpp
@@ -129,12 +129,12 @@ static ErrorOr<Optional<String>> elf_details(StringView description, StringView
         return OptionalNone {};
 
     StringBuilder interpreter_path_builder;
-    auto result_or_error = ELF::validate_program_headers(*(const ElfW(Ehdr)*)elf_data.data(), elf_data.size(), elf_data, &interpreter_path_builder);
+    auto result_or_error = ELF::validate_program_headers(*(Elf_Ehdr const*)elf_data.data(), elf_data.size(), elf_data, &interpreter_path_builder);
     if (result_or_error.is_error() || !result_or_error.value())
         return OptionalNone {};
     auto interpreter_path = interpreter_path_builder.string_view();
 
-    auto& header = *reinterpret_cast<const ElfW(Ehdr)*>(elf_data.data());
+    auto& header = *reinterpret_cast<Elf_Ehdr const*>(elf_data.data());
 
     auto bitness = header.e_ident[EI_CLASS] == ELFCLASS64 ? "64" : "32";
     auto byteorder = header.e_ident[EI_DATA] == ELFDATA2LSB ? "LSB" : "MSB";
diff --git a/Userland/Utilities/ldd.cpp b/Userland/Utilities/ldd.cpp
index 0236d914d9..632e5aa17b 100644
--- a/Userland/Utilities/ldd.cpp
+++ b/Userland/Utilities/ldd.cpp
@@ -110,7 +110,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     }
 
     StringBuilder interpreter_path_builder;
-    auto result_or_error = ELF::validate_program_headers(*(const ElfW(Ehdr)*)elf_image_data.data(), elf_image_data.size(), elf_image_data, &interpreter_path_builder);
+    auto result_or_error = ELF::validate_program_headers(*(Elf_Ehdr const*)elf_image_data.data(), elf_image_data.size(), elf_image_data, &interpreter_path_builder);
     if (result_or_error.is_error() || !result_or_error.value()) {
         warnln("Invalid ELF headers");
         return -1;
diff --git a/Userland/Utilities/readelf.cpp b/Userland/Utilities/readelf.cpp
index bbfb5e6990..5565d1b60e 100644
--- a/Userland/Utilities/readelf.cpp
+++ b/Userland/Utilities/readelf.cpp
@@ -22,7 +22,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-static char const* object_program_header_type_to_string(ElfW(Word) type)
+static char const* object_program_header_type_to_string(Elf_Word type)
 {
     switch (type) {
     case PT_NULL:
@@ -66,7 +66,7 @@ static char const* object_program_header_type_to_string(ElfW(Word) type)
     }
 }
 
-static char const* object_section_header_type_to_string(ElfW(Word) type)
+static char const* object_section_header_type_to_string(Elf_Word type)
 {
     switch (type) {
     case SHT_NULL:
@@ -138,7 +138,7 @@ static char const* object_section_header_type_to_string(ElfW(Word) type)
     }
 }
 
-static char const* object_symbol_type_to_string(ElfW(Word) type)
+static char const* object_symbol_type_to_string(Elf_Word type)
 {
     switch (type) {
     case STT_NOTYPE:
@@ -164,7 +164,7 @@ static char const* object_symbol_type_to_string(ElfW(Word) type)
     }
 }
 
-static char const* object_symbol_binding_to_string(ElfW(Word) type)
+static char const* object_symbol_binding_to_string(Elf_Word type)
 {
     switch (type) {
     case STB_LOCAL:
@@ -184,7 +184,7 @@ static char const* object_symbol_binding_to_string(ElfW(Word) type)
     }
 }
 
-static char const* object_relocation_type_to_string(ElfW(Half) machine, ElfW(Word) type)
+static char const* object_relocation_type_to_string(Elf_Half machine, Elf_Word type)
 {
 #define ENUMERATE_RELOCATION(name) \
     case name:                     \
@@ -280,14 +280,14 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     }
 
     StringBuilder interpreter_path_builder;
-    auto result_or_error = ELF::validate_program_headers(*(const ElfW(Ehdr)*)elf_image_data.data(), elf_image_data.size(), elf_image_data, &interpreter_path_builder);
+    auto result_or_error = ELF::validate_program_headers(*(Elf_Ehdr const*)elf_image_data.data(), elf_image_data.size(), elf_image_data, &interpreter_path_builder);
     if (result_or_error.is_error() || !result_or_error.value()) {
         warnln("Invalid ELF headers");
         return -1;
     }
     auto interpreter_path = interpreter_path_builder.string_view();
 
-    auto& header = *reinterpret_cast<const ElfW(Ehdr)*>(elf_image_data.data());
+    auto& header = *reinterpret_cast<Elf_Ehdr const*>(elf_image_data.data());
 
     RefPtr<ELF::DynamicObject> object = nullptr;