RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-28 00:57:44 +00:00
Code Issues Activity Actions

Everywhere: Run clang-format

Browse source
This commit is contained in:
Idan Horowitz 2022-04-01 20:58:27 +03:00 • committed by Linus Groh
parent 0376c127f6
commit 086969277e
1665 changed files with 8479 additions and 8479 deletions
Download patch file Download diff file Expand all files Collapse all files

32
Userland/Libraries/LibELF/DynamicLinker.cpp
View file

@ -56,8 +56,8 @@ static bool s_do_breakpoint_trap_before_entry { false };
static StringView s_ld_library_path;
static Result<void, DlErrorMessage> __dlclose(void* handle);
static Result<void*, DlErrorMessage> __dlopen(const char* filename, int flags);
static Result<void*, DlErrorMessage> __dlsym(void* handle, const char* symbol_name);
static Result<void*, DlErrorMessage> __dlopen(char const* filename, int flags);
static Result<void*, DlErrorMessage> __dlsym(void* handle, char const* symbol_name);
static Result<void, DlErrorMessage> __dladdr(void* addr, Dl_info* info);
Optional<DynamicObject::SymbolLookupResult> DynamicLinker::lookup_global_symbol(StringView name)
@ -84,7 +84,7 @@ static String get_library_name(String path)
return LexicalPath::basename(move(path));
}
static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> map_library(const String& filename, int fd)
static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> map_library(String const& filename, int fd)
{
auto result = ELF::DynamicLoader::try_create(fd, filename);
if (result.is_error()) {
@ -139,7 +139,7 @@ static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> map_library(String c
return DlErrorMessage { String::formatted("Could not find required shared library: {}", name) };
}
static Vector<String> get_dependencies(const String& name)
static Vector<String> get_dependencies(String const& name)
{
auto lib = s_loaders.get(name).value();
Vector<String> dependencies;
@ -152,13 +152,13 @@ static Vector<String> get_dependencies(const String& name)
return dependencies;
}
static Result<void, DlErrorMessage> map_dependencies(const String& name)
static Result<void, DlErrorMessage> map_dependencies(String const& name)
{
dbgln_if(DYNAMIC_LOAD_DEBUG, "mapping dependencies for: {}", name);
auto const& parent_object = (*s_loaders.get(name))->dynamic_object();
for (const auto& needed_name : get_dependencies(name)) {
for (auto const& needed_name : get_dependencies(name)) {
dbgln_if(DYNAMIC_LOAD_DEBUG, "needed library: {}", needed_name.characters());
String library_name = get_library_name(needed_name);
@ -180,7 +180,7 @@ static Result<void, DlErrorMessage> map_dependencies(const String& name)
static void allocate_tls()
{
s_total_tls_size = 0;
for (const auto& data : s_loaders) {
for (auto const& data : s_loaders) {
dbgln_if(DYNAMIC_LOAD_DEBUG, "{}: TLS Size: {}", data.key, data.value->tls_size_of_current_object());
s_total_tls_size += data.value->tls_size_of_current_object();
}
@ -198,7 +198,7 @@ static void allocate_tls()
auto& initial_tls_data = initial_tls_data_result.value();
// Initialize TLS data
for (const auto& entry : s_loaders) {
for (auto const& entry : s_loaders) {
entry.value->copy_initial_tls_data_into(initial_tls_data);
}
@ -277,7 +277,7 @@ static void initialize_libc(DynamicObject& libc)
}
template<typename Callback>
static void for_each_unfinished_dependency_of(const String& name, HashTable<String>& seen_names, bool first, bool skip_global_objects, Callback callback)
static void for_each_unfinished_dependency_of(String const& name, HashTable<String>& seen_names, bool first, bool skip_global_objects, Callback callback)
{
if (!s_loaders.contains(name))
return;
@ -289,13 +289,13 @@ static void for_each_unfinished_dependency_of(const String& name, HashTable<Stri
return;
seen_names.set(name);
for (const auto& needed_name : get_dependencies(name))
for (auto const& needed_name : get_dependencies(name))
for_each_unfinished_dependency_of(get_library_name(needed_name), seen_names, false, skip_global_objects, callback);
callback(*s_loaders.get(name).value());
}
static NonnullRefPtrVector<DynamicLoader> collect_loaders_for_library(const String& name, bool skip_global_objects)
static NonnullRefPtrVector<DynamicLoader> collect_loaders_for_library(String const& name, bool skip_global_objects)
{
HashTable<String> seen_names;
NonnullRefPtrVector<DynamicLoader> loaders;
@ -305,7 +305,7 @@ static NonnullRefPtrVector<DynamicLoader> collect_loaders_for_library(const Stri
return loaders;
}
static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> load_main_library(const String& name, int flags, bool skip_global_objects)
static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> load_main_library(String const& name, int flags, bool skip_global_objects)
{
auto main_library_loader = *s_loaders.get(name);
auto main_library_object = main_library_loader->map();
@ -333,7 +333,7 @@ static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> load_main_library(co
if (loader.filename() == "libsystem.so"sv) {
VERIFY(!loader.text_segments().is_empty());
for (const auto& segment : loader.text_segments()) {
for (auto const& segment : loader.text_segments()) {
if (syscall(SC_msyscall, segment.address().get())) {
VERIFY_NOT_REACHED();
}
@ -367,7 +367,7 @@ static Result<void, DlErrorMessage> __dlclose(void* handle)
return {};
}
static Optional<DlErrorMessage> verify_tls_for_dlopen(const DynamicLoader& loader)
static Optional<DlErrorMessage> verify_tls_for_dlopen(DynamicLoader const& loader)
{
if (loader.tls_size_of_current_object() == 0)
return {};
@ -396,7 +396,7 @@ static Optional<DlErrorMessage> verify_tls_for_dlopen(const DynamicLoader& loade
return DlErrorMessage("Using dlopen() with libraries that have non-zeroed TLS is currently not supported");
}
static Result<void*, DlErrorMessage> __dlopen(const char* filename, int flags)
static Result<void*, DlErrorMessage> __dlopen(char const* filename, int flags)
{
// FIXME: RTLD_NOW and RTLD_LOCAL are not supported
flags &= ~RTLD_NOW;
@ -451,7 +451,7 @@ static Result<void*, DlErrorMessage> __dlopen(const char* filename, int flags)
return *object;
}
static Result<void*, DlErrorMessage> __dlsym(void* handle, const char* symbol_name)
static Result<void*, DlErrorMessage> __dlsym(void* handle, char const* symbol_name)
{
dbgln_if(DYNAMIC_LOAD_DEBUG, "__dlsym: {}, {}", handle, symbol_name);

10
Userland/Libraries/LibELF/DynamicLoader.cpp
View file

@ -26,7 +26,7 @@
#include <unistd.h>
#ifndef __serenity__
static void* mmap_with_name(void* addr, size_t length, int prot, int flags, int fd, off_t offset, const char*)
static void* mmap_with_name(void* addr, size_t length, int prot, int flags, int fd, off_t offset, char const*)
{
return mmap(addr, length, prot, flags, fd, offset);
}
@ -86,7 +86,7 @@ DynamicLoader::~DynamicLoader()
}
}
const DynamicObject& DynamicLoader::dynamic_object() const
DynamicObject const& DynamicLoader::dynamic_object() const
{
if (!m_cached_dynamic_object) {
VirtualAddress dynamic_section_address;
@ -238,7 +238,7 @@ void DynamicLoader::load_stage_4()
void DynamicLoader::do_lazy_relocations()
{
for (const auto& relocation : m_unresolved_relocations) {
for (auto const& relocation : m_unresolved_relocations) {
if (auto res = do_relocation(relocation, ShouldInitializeWeak::Yes); res != RelocationResult::Success) {
dbgln("Loader.so: {} unresolved symbol '{}'", m_filename, relocation.symbol().name());
VERIFY_NOT_REACHED();
@ -256,7 +256,7 @@ void DynamicLoader::load_program_headers()
VirtualAddress dynamic_region_desired_vaddr;
m_elf_image.for_each_program_header([&](const Image::ProgramHeader& program_header) {
m_elf_image.for_each_program_header([&](Image::ProgramHeader const& program_header) {
ProgramHeaderRegion region {};
region.set_program_header(program_header.raw_header());
if (region.is_tls_template()) {
@ -555,7 +555,7 @@ ssize_t DynamicLoader::negative_offset_from_tls_block_end(ssize_t tls_offset, si
void DynamicLoader::copy_initial_tls_data_into(ByteBuffer& buffer) const
{
const u8* tls_data = nullptr;
u8 const* tls_data = nullptr;
size_t tls_size_in_image = 0;
m_elf_image.for_each_program_header([this, &tls_data, &tls_size_in_image](ELF::Image::ProgramHeader program_header) {

6
Userland/Libraries/LibELF/DynamicLoader.h
View file

@ -45,7 +45,7 @@ public:
static Result<NonnullRefPtr<DynamicLoader>, DlErrorMessage> try_create(int fd, String filename);
~DynamicLoader();
const String& filename() const { return m_filename; }
String const& filename() const { return m_filename; }
bool is_valid() const { return m_valid; }
@ -74,7 +74,7 @@ public:
void for_each_needed_library(F) const;
VirtualAddress base_address() const { return m_base_address; }
const Vector<LoadedSegment> text_segments() const { return m_text_segments; }
Vector<LoadedSegment> const text_segments() const { return m_text_segments; }
bool is_dynamic() const { return m_elf_image.is_dynamic(); }
static Optional<DynamicObject::SymbolLookupResult> lookup_symbol(const ELF::DynamicObject::Symbol&);
@ -129,7 +129,7 @@ private:
Success = 1,
ResolveLater = 2,
};
RelocationResult do_relocation(const DynamicObject::Relocation&, ShouldInitializeWeak should_initialize_weak);
RelocationResult do_relocation(DynamicObject::Relocation const&, ShouldInitializeWeak should_initialize_weak);
void do_relr_relocations();
size_t calculate_tls_size() const;
ssize_t negative_offset_from_tls_block_end(ssize_t tls_offset, size_t value_of_symbol) const;

28
Userland/Libraries/LibELF/DynamicObject.cpp
View file

@ -16,7 +16,7 @@
namespace ELF {
DynamicObject::DynamicObject(const String& filename, VirtualAddress base_address, VirtualAddress dynamic_section_address)
DynamicObject::DynamicObject(String const& filename, VirtualAddress base_address, VirtualAddress dynamic_section_address)
: m_filename(filename)
, m_base_address(base_address)
, m_dynamic_address(dynamic_section_address)
@ -44,7 +44,7 @@ void DynamicObject::dump() const
builder.append("\nd_tag tag_name value\n");
size_t num_dynamic_sections = 0;
for_each_dynamic_entry([&](const DynamicObject::DynamicEntry& entry) {
for_each_dynamic_entry([&](DynamicObject::DynamicEntry const& entry) {
String name_field = String::formatted("({})", name_for_dtag(entry.tag()));
builder.appendff("{:#08x} {:17} {:#08x}\n", entry.tag(), name_field, entry.val());
num_dynamic_sections++;
@ -64,7 +64,7 @@ void DynamicObject::dump() const
void DynamicObject::parse()
{
for_each_dynamic_entry([&](const DynamicEntry& entry) {
for_each_dynamic_entry([&](DynamicEntry const& entry) {
switch (entry.tag()) {
case DT_INIT:
m_init_offset = entry.ptr() - m_elf_base_address.get();
@ -294,7 +294,7 @@ auto DynamicObject::HashSection::lookup_gnu_symbol(StringView name, u32 hash_val
using BloomWord = FlatPtr;
constexpr size_t bloom_word_size = sizeof(BloomWord) * 8;
const u32* hash_table_begin = (u32*)address().as_ptr();
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];
@ -303,9 +303,9 @@ auto DynamicObject::HashSection::lookup_gnu_symbol(StringView name, u32 hash_val
const u32 num_maskwords_bitmask = num_maskwords - 1;
const u32 shift2 = hash_table_begin[3];
const BloomWord* bloom_words = (BloomWord const*)&hash_table_begin[4];
const u32* const buckets = (u32 const*)&bloom_words[num_maskwords];
const u32* const chains = &buckets[num_buckets];
BloomWord const* bloom_words = (BloomWord const*)&hash_table_begin[4];
u32 const* const buckets = (u32 const*)&bloom_words[num_maskwords];
u32 const* const chains = &buckets[num_buckets];
BloomWord hash1 = hash_value;
BloomWord hash2 = hash1 >> shift2;
@ -317,7 +317,7 @@ auto DynamicObject::HashSection::lookup_gnu_symbol(StringView name, u32 hash_val
size_t current_sym = buckets[hash1 % num_buckets];
if (current_sym == 0)
return {};
const u32* current_chain = &chains[current_sym - num_omitted_symbols];
u32 const* current_chain = &chains[current_sym - num_omitted_symbols];
for (hash1 &= ~1;; ++current_sym) {
hash2 = *(current_chain++);
@ -336,12 +336,12 @@ auto DynamicObject::HashSection::lookup_gnu_symbol(StringView name, u32 hash_val
StringView DynamicObject::symbol_string_table_string(ElfW(Word) index) const
{
return StringView { (const char*)base_address().offset(m_string_table_offset + index).as_ptr() };
return StringView { (char const*)base_address().offset(m_string_table_offset + index).as_ptr() };
}
const char* DynamicObject::raw_symbol_string_table_string(ElfW(Word) index) const
char const* DynamicObject::raw_symbol_string_table_string(ElfW(Word) index) const
{
return (const char*)base_address().offset(m_string_table_offset + index).as_ptr();
return (char const*)base_address().offset(m_string_table_offset + index).as_ptr();
}
DynamicObject::InitializationFunction DynamicObject::init_section_function() const
@ -350,7 +350,7 @@ DynamicObject::InitializationFunction DynamicObject::init_section_function() con
return (InitializationFunction)init_section().address().as_ptr();
}
const char* DynamicObject::name_for_dtag(ElfW(Sword) d_tag)
char const* DynamicObject::name_for_dtag(ElfW(Sword) d_tag)
{
switch (d_tag) {
case DT_NULL:
@ -463,7 +463,7 @@ auto DynamicObject::lookup_symbol(StringView name) const -> Optional<SymbolLooku
return lookup_symbol(HashSymbol { name });
}
auto DynamicObject::lookup_symbol(const HashSymbol& symbol) const -> Optional<SymbolLookupResult>
auto DynamicObject::lookup_symbol(HashSymbol const& symbol) const -> Optional<SymbolLookupResult>
{
auto result = hash_section().lookup_symbol(symbol);
if (!result.has_value())
@ -474,7 +474,7 @@ auto DynamicObject::lookup_symbol(const HashSymbol& symbol) const -> Optional<Sy
return SymbolLookupResult { symbol_result.value(), symbol_result.size(), symbol_result.address(), symbol_result.bind(), this };
}
NonnullRefPtr<DynamicObject> DynamicObject::create(const String& filename, VirtualAddress base_address, VirtualAddress dynamic_section_address)
NonnullRefPtr<DynamicObject> DynamicObject::create(String const& filename, VirtualAddress base_address, VirtualAddress dynamic_section_address)
{
return adopt_ref(*new DynamicObject(filename, base_address, dynamic_section_address));
}

44
Userland/Libraries/LibELF/DynamicObject.h
View file

@ -20,8 +20,8 @@ namespace ELF {
class DynamicObject : public RefCounted<DynamicObject> {
public:
static NonnullRefPtr<DynamicObject> create(const String& filename, VirtualAddress base_address, VirtualAddress dynamic_section_address);
static const char* name_for_dtag(ElfW(Sword) d_tag);
static NonnullRefPtr<DynamicObject> create(String const& filename, VirtualAddress base_address, VirtualAddress dynamic_section_address);
static char const* name_for_dtag(ElfW(Sword) d_tag);
~DynamicObject();
void dump() const;
@ -52,7 +52,7 @@ public:
class Symbol {
public:
Symbol(const DynamicObject& dynamic, unsigned index, const ElfW(Sym) & sym)
Symbol(DynamicObject const& dynamic, unsigned index, const ElfW(Sym) & sym)
: m_dynamic(dynamic)
, m_sym(sym)
, m_index(index)
@ -60,7 +60,7 @@ public:
}
StringView name() const { return m_dynamic.symbol_string_table_string(m_sym.st_name); }
const char* raw_name() const { return m_dynamic.raw_symbol_string_table_string(m_sym.st_name); }
char const* raw_name() const { return m_dynamic.raw_symbol_string_table_string(m_sym.st_name); }
unsigned section_index() const { return m_sym.st_shndx; }
FlatPtr value() const { return m_sym.st_value; }
size_t size() const { return m_sym.st_size; }
@ -90,17 +90,17 @@ public:
return m_dynamic.base_address().offset(value());
return VirtualAddress { value() };
}
const DynamicObject& object() const { return m_dynamic; }
DynamicObject const& object() const { return m_dynamic; }
private:
const DynamicObject& m_dynamic;
DynamicObject const& m_dynamic;
const ElfW(Sym) & m_sym;
const unsigned m_index;
unsigned const m_index;
};
class Section {
public:
Section(const DynamicObject& dynamic, unsigned section_offset, unsigned section_size_bytes, unsigned entry_size, StringView name)
Section(DynamicObject const& dynamic, unsigned section_offset, unsigned section_size_bytes, unsigned entry_size, StringView name)
: m_dynamic(dynamic)
, m_section_offset(section_offset)
, m_section_size_bytes(section_size_bytes)
@ -126,7 +126,7 @@ public:
protected:
friend class RelocationSection;
friend class HashSection;
const DynamicObject& m_dynamic;
DynamicObject const& m_dynamic;
unsigned m_section_offset;
unsigned m_section_size_bytes;
unsigned m_entry_size;
@ -135,7 +135,7 @@ public:
class RelocationSection : public Section {
public:
explicit RelocationSection(const Section& section, bool addend_used)
explicit RelocationSection(Section const& section, bool addend_used)
: Section(section.m_dynamic, section.m_section_offset, section.m_section_size_bytes, section.m_entry_size, section.m_name)
, m_addend_used(addend_used)
{
@ -150,12 +150,12 @@ public:
void for_each_relocation(F func) const;
private:
const bool m_addend_used;
bool const m_addend_used;
};
class Relocation {
public:
Relocation(const DynamicObject& dynamic, const ElfW(Rela) & rel, unsigned offset_in_section, bool addend_used)
Relocation(DynamicObject const& dynamic, const ElfW(Rela) & rel, unsigned offset_in_section, bool addend_used)
: m_dynamic(dynamic)
, m_rel(rel)
, m_offset_in_section(offset_in_section)
@ -200,10 +200,10 @@ public:
[[nodiscard]] DynamicObject const& dynamic_object() const { return m_dynamic; }
private:
const DynamicObject& m_dynamic;
DynamicObject const& m_dynamic;
const ElfW(Rela) & m_rel;
const unsigned m_offset_in_section;
const bool m_addend_used;
unsigned const m_offset_in_section;
bool const m_addend_used;
};
enum class HashType {
@ -230,13 +230,13 @@ public:
class HashSection : public Section {
public:
HashSection(const Section& section, HashType hash_type)
HashSection(Section const& section, HashType hash_type)
: Section(section.m_dynamic, section.m_section_offset, section.m_section_size_bytes, section.m_entry_size, section.m_name)
, m_hash_type(hash_type)
{
}
Optional<Symbol> lookup_symbol(const HashSymbol& symbol) const
Optional<Symbol> lookup_symbol(HashSymbol const& symbol) const
{
if (m_hash_type == HashType::SYSV)
return lookup_sysv_symbol(symbol.name(), symbol.sysv_hash());
@ -286,7 +286,7 @@ public:
VirtualAddress plt_got_base_address() const { return m_base_address.offset(m_procedure_linkage_table_offset.value()); }
VirtualAddress base_address() const { return m_base_address; }
const String& filename() const { return m_filename; }
String const& filename() const { return m_filename; }
StringView rpath() const { return m_has_rpath ? symbol_string_table_string(m_rpath_index) : StringView {}; }
StringView runpath() const { return m_has_runpath ? symbol_string_table_string(m_runpath_index) : StringView {}; }
@ -326,7 +326,7 @@ public:
};
Optional<SymbolLookupResult> lookup_symbol(StringView name) const;
Optional<SymbolLookupResult> lookup_symbol(const HashSymbol& symbol) const;
Optional<SymbolLookupResult> lookup_symbol(HashSymbol const& symbol) const;
// Will be called from _fixup_plt_entry, as part of the PLT trampoline
VirtualAddress patch_plt_entry(u32 relocation_offset);
@ -336,10 +336,10 @@ public:
void* symbol_for_name(StringView name);
private:
explicit DynamicObject(const String& filename, VirtualAddress base_address, VirtualAddress dynamic_section_address);
explicit DynamicObject(String const& filename, VirtualAddress base_address, VirtualAddress dynamic_section_address);
StringView symbol_string_table_string(ElfW(Word)) const;
const char* raw_symbol_string_table_string(ElfW(Word)) const;
char const* raw_symbol_string_table_string(ElfW(Word)) const;
void parse();
String m_filename;
@ -403,7 +403,7 @@ template<IteratorFunction<DynamicObject::Relocation&> F>
inline void DynamicObject::RelocationSection::for_each_relocation(F func) const
{
for (unsigned i = 0; i < relocation_count(); ++i) {
const auto reloc = relocation(i);
auto const reloc = relocation(i);
if (reloc.type() == 0)
continue;
if (func(reloc) == IterationDecision::Break)

16
Userland/Libraries/LibELF/Image.cpp
View file

@ -26,7 +26,7 @@ Image::Image(ReadonlyBytes bytes, bool verbose_logging)
parse();
}
Image::Image(const u8* buffer, size_t size, bool verbose_logging)
Image::Image(u8 const* buffer, size_t size, bool verbose_logging)
: Image(ReadonlyBytes { buffer, size }, verbose_logging)
{
}
@ -69,7 +69,7 @@ void Image::dump() const
dbgln(" phnum: {}", header().e_phnum);
dbgln(" shstrndx: {}", header().e_shstrndx);
for_each_program_header([&](const ProgramHeader& program_header) {
for_each_program_header([&](ProgramHeader const& program_header) {
dbgln(" Program Header {}: {{", program_header.index());
dbgln(" type: {:x}", program_header.type());
dbgln(" offset: {:x}", program_header.offset());
@ -78,7 +78,7 @@ void Image::dump() const
});
for (unsigned i = 0; i < header().e_shnum; ++i) {
const auto& section = this->section(i);
auto const& section = this->section(i);
dbgln(" Section {}: {{", i);
dbgln(" name: {}", section.name());
dbgln(" type: {:x}", section.type());
@ -90,7 +90,7 @@ void Image::dump() const
dbgln("Symbol count: {} (table is {})", symbol_count(), m_symbol_table_section_index);
for (unsigned i = 1; i < symbol_count(); ++i) {
const auto& sym = symbol(i);
auto const& sym = symbol(i);
dbgln("Symbol @{}:", i);
dbgln(" Name: {}", sym.name());
dbgln(" In section: {}", section_index_to_string(sym.section_index()));
@ -187,10 +187,10 @@ StringView Image::table_string(unsigned offset) const
return table_string(m_string_table_section_index, offset);
}
const char* Image::raw_data(unsigned offset) const
char const* Image::raw_data(unsigned offset) const
{
VERIFY(offset < m_size); // Callers must check indices into raw_data()'s result are also in bounds.
return reinterpret_cast<const char*>(m_buffer) + offset;
return reinterpret_cast<char const*>(m_buffer) + offset;
}
const ElfW(Ehdr) & Image::header() const
@ -361,7 +361,7 @@ StringView Image::Symbol::raw_data() const
Optional<Image::Symbol> Image::find_demangled_function(StringView name) const
{
Optional<Image::Symbol> found;
for_each_symbol([&](const Image::Symbol& symbol) {
for_each_symbol([&](Image::Symbol const& symbol) {
if (symbol.type() != STT_FUNC)
return IterationDecision::Continue;
if (symbol.is_undefined())
@ -416,7 +416,7 @@ Optional<Image::Symbol> Image::find_symbol(FlatPtr address, u32* out_offset) con
NEVER_INLINE void Image::sort_symbols() const
{
m_sorted_symbols.ensure_capacity(symbol_count());
for_each_symbol([this](const auto& symbol) {
for_each_symbol([this](auto const& symbol) {
m_sorted_symbols.append({ symbol.value(), symbol.name(), {}, symbol });
});
quick_sort(m_sorted_symbols, [](auto& a, auto& b) {

34
Userland/Libraries/LibELF/Image.h
View file

@ -21,18 +21,18 @@ namespace ELF {
class Image {
public:
explicit Image(ReadonlyBytes, bool verbose_logging = true);
explicit Image(const u8*, size_t, bool verbose_logging = true);
explicit Image(u8 const*, size_t, bool verbose_logging = true);
~Image() = default;
void dump() const;
bool is_valid() const { return m_valid; }
bool parse();
bool is_within_image(const void* address, size_t size) const
bool is_within_image(void const* address, size_t size) const
{
if (address < m_buffer)
return false;
if (((const u8*)address + size) > m_buffer + m_size)
if (((u8 const*)address + size) > m_buffer + m_size)
return false;
return true;
}
@ -44,7 +44,7 @@ public:
class Symbol {
public:
Symbol(const Image& image, unsigned index, const ElfW(Sym) & sym)
Symbol(Image const& image, unsigned index, const ElfW(Sym) & sym)
: m_image(image)
, m_sym(sym)
, m_index(index)
@ -79,14 +79,14 @@ public:
StringView raw_data() const;
private:
const Image& m_image;
Image const& m_image;
const ElfW(Sym) & m_sym;
const unsigned m_index;
unsigned const m_index;
};
class ProgramHeader {
public:
ProgramHeader(const Image& image, unsigned program_header_index)
ProgramHeader(Image const& image, unsigned program_header_index)
: m_image(image)
, m_program_header(image.program_header_internal(program_header_index))
, m_program_header_index(program_header_index)
@ -105,18 +105,18 @@ public:
bool is_readable() const { return flags() & PF_R; }
bool is_writable() const { return flags() & PF_W; }
bool is_executable() const { return flags() & PF_X; }
const char* raw_data() const { return m_image.raw_data(m_program_header.p_offset); }
char const* raw_data() const { return m_image.raw_data(m_program_header.p_offset); }
ElfW(Phdr) raw_header() const { return m_program_header; }
private:
const Image& m_image;
Image const& m_image;
const ElfW(Phdr) & m_program_header;
unsigned m_program_header_index { 0 };
};
class Section {
public:
Section(const Image& image, unsigned sectionIndex)
Section(Image const& image, unsigned sectionIndex)
: m_image(image)
, m_section_header(image.section_header(sectionIndex))
, m_section_index(sectionIndex)
@ -131,7 +131,7 @@ public:
size_t entry_size() const { return m_section_header.sh_entsize; }
size_t entry_count() const { return !entry_size() ? 0 : size() / entry_size(); }
FlatPtr address() const { return m_section_header.sh_addr; }
const char* raw_data() const { return m_image.raw_data(m_section_header.sh_offset); }
char const* raw_data() const { return m_image.raw_data(m_section_header.sh_offset); }
ReadonlyBytes bytes() const { return { raw_data(), size() }; }
Optional<RelocationSection> relocations() const;
auto flags() const { return m_section_header.sh_flags; }
@ -140,14 +140,14 @@ public:
protected:
friend class RelocationSection;
const Image& m_image;
Image const& m_image;
const ElfW(Shdr) & m_section_header;
unsigned m_section_index;
};
class RelocationSection : public Section {
public:
explicit RelocationSection(const Section& section)
explicit RelocationSection(Section const& section)
: Section(section.m_image, section.m_section_index)
{
}
@ -160,7 +160,7 @@ public:
class Relocation {
public:
Relocation(const Image& image, const ElfW(Rel) & rel)
Relocation(Image const& image, const ElfW(Rel) & rel)
: m_image(image)
, m_rel(rel)
{
@ -188,7 +188,7 @@ public:
}
private:
const Image& m_image;
Image const& m_image;
const ElfW(Rel) & m_rel;
};
@ -243,7 +243,7 @@ public:
Optional<Image::Symbol> find_symbol(FlatPtr address, u32* offset = nullptr) const;
private:
const char* raw_data(unsigned offset) const;
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;
@ -252,7 +252,7 @@ private:
StringView section_index_to_string(unsigned index) const;
StringView table_string(unsigned table_index, unsigned offset) const;
const u8* m_buffer { nullptr };
u8 const* m_buffer { nullptr };
size_t m_size { 0 };
bool m_verbose_logging { true };
bool m_valid { false };