SilverMoonStudio/Arctyx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First commit.

Browse Source
This commit is contained in:
Karutoh
2025-04-08 22:51:50 -07:00
parent 6ae60f21d1
commit e95bf38d46
17 changed files with 262 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/Compiler.cpp Normal file
View File

@@ -0,0 +1 @@
#include "arctyx/Compiler.h"

116
src/ELF64.cpp → src/ELF.cpp
View File

@@ -1,62 +1,62 @@
#include "ELF64.h"
#include "arctyx/ELF.h"
constexpr ehs::Char_8 Elf_Magic[] = "\x7F" "ELF";
constexpr ehs::UInt_8 Elf_Magic_Size = sizeof(Elf_Magic) - 1;
ELF64::ELF64()
: endianness(ELFH_END_LE), abi(ELFH_ABI_SYSTEMV), type(ELFH_TYPE_EXEC),
arch(ELFH_MARCH_AMD_X86_64), entryPoint(0)
ELF::ELF()
: bitDepth(ELF_BIT_DEPTH_64), endianness(ELF_END_LE), abi(ELFH_ABI_SYSTEMV), type(ELFH_TYPE_EXEC),
arch(ELF_ARCH_X86_64), entryPoint(0)
{
InitializeSections();
}
ELF64::ELF64(ehs::UInt_8 end, ehs::UInt_8 abi, ehs::UInt_16 type, ehs::UInt_16 arch)
: endianness(end), abi(abi), type(type), arch(arch), entryPoint(0)
ELF::ELF(const ehs::UInt_8 &bitDepth, const ehs::UInt_8 &end, const ehs::UInt_8 &abi, const ehs::UInt_16 &type, const ehs::UInt_16 &arch)
: bitDepth(bitDepth), endianness(end), abi(abi), type(type), arch(arch), entryPoint(0)
{
InitializeSections();
}
ELF64::ELF64(ehs::Serializer<ehs::UInt_64>& data)
ELF::ELF(ehs::Serializer<ehs::UInt_64>& data)
{
}
ELF64::ELF64(ELF64&& header) noexcept
: endianness(header.endianness), abi(header.abi), type(header.type), arch(header.arch),
entryPoint(header.entryPoint), programs((ehs::Vector<ELF64_Program, ehs::UInt_16>&&)header.programs),
sections((ehs::Vector<ELF64_Section, ehs::UInt_16>&&)header.sections)
ELF::ELF(ELF&& header) noexcept
: bitDepth(header.bitDepth), endianness(header.endianness), abi(header.abi), type(header.type), arch(header.arch),
entryPoint(header.entryPoint), programs((ehs::Vector<ELF_Program, ehs::UInt_16>&&)header.programs),
sections((ehs::Vector<ELF_Section, ehs::UInt_16>&&)header.sections)
{
header.endianness = ELFH_END_LE;
header.bitDepth = ELF_BIT_DEPTH_64;
header.endianness = ELF_END_LE;
header.abi = ELFH_ABI_SYSTEMV;
header.type = ELFH_TYPE_EXEC;
header.arch = ELFH_MARCH_AMD_X86_64;
header.arch = ELF_ARCH_X86_64;
header.entryPoint = 0;
header.InitializeSections();
}
ELF64::ELF64(const ELF64& header)
: endianness(header.endianness), abi(header.abi), type(header.type), arch(header.arch),
ELF::ELF(const ELF& header)
: bitDepth(header.bitDepth), endianness(header.endianness), abi(header.abi), type(header.type), arch(header.arch),
entryPoint(header.entryPoint), programs(header.programs), sections(header.sections)
{
}
ELF64& ELF64::operator=(ELF64&& header) noexcept
ELF& ELF::operator=(ELF&& header) noexcept
{
if (this == &header)
return *this;
bitDepth = header.bitDepth;
endianness = header.endianness;
abi = header.abi;
type = header.type;
arch = header.arch;
entryPoint = header.entryPoint;
programs = (ehs::Vector<ELF64_Program, ehs::UInt_16>&&)header.programs;
sections = (ehs::Vector<ELF64_Section, ehs::UInt_16>&&)header.sections;
programs = (ehs::Vector<ELF_Program, ehs::UInt_16>&&)header.programs;
sections = (ehs::Vector<ELF_Section, ehs::UInt_16>&&)header.sections;
header.endianness = ELFH_END_LE;
header.bitDepth = ELF_BIT_DEPTH_64;
header.endianness = ELF_END_LE;
header.abi = ELFH_ABI_SYSTEMV;
header.type = ELFH_TYPE_EXEC;
header.arch = ELFH_MARCH_AMD_X86_64;
header.arch = ELF_ARCH_X86_64;
header.entryPoint = 0;
header.InitializeSections();
@@ -64,11 +64,12 @@ ELF64& ELF64::operator=(ELF64&& header) noexcept
return *this;
}
ELF64& ELF64::operator=(const ELF64& header)
ELF& ELF::operator=(const ELF& header)
{
if (this == &header)
return *this;
bitDepth = header.bitDepth;
endianness = header.endianness;
abi = header.abi;
type = header.type;
@@ -80,27 +81,32 @@ ELF64& ELF64::operator=(const ELF64& header)
return *this;
}
ehs::UInt_8 ELF64::GetEndianness() const
ehs::UInt_8 ELF::GetBitDepth() const
{
return bitDepth;
}
ehs::UInt_8 ELF::GetEndianness() const
{
return endianness;
}
ehs::UInt_8 ELF64::GetABI() const
ehs::UInt_8 ELF::GetABI() const
{
return abi;
}
ehs::UInt_16 ELF64::GetType() const
ehs::UInt_16 ELF::GetType() const
{
return type;
}
ehs::UInt_16 ELF64::GetArchitecture() const
ehs::UInt_16 ELF::GetArchitecture() const
{
return arch;
}
void ELF64::SetEntryPoint(ehs::UInt_16 programIndex)
void ELF::SetEntryPoint(ehs::UInt_16 programIndex)
{
if (programIndex > programs.End())
{
@@ -115,12 +121,12 @@ void ELF64::SetEntryPoint(ehs::UInt_16 programIndex)
EHS_LOG_SUCCESS();
}
ELF64_Program* ELF64::GetEntryPoint() const
ELF_Program* ELF::GetEntryPoint() const
{
return &programs[entryPoint];
}
void ELF64::AddProgram(ELF64_Program newProgram)
void ELF::AddProgram(ELF_Program newProgram)
{
/*
for (ehs::UInt_16 i = 0; i < programs.Size(); i++)
@@ -135,10 +141,10 @@ void ELF64::AddProgram(ELF64_Program newProgram)
}
*/
programs.Push((ELF64_Program&&)newProgram);
programs.Push((ELF_Program&&)newProgram);
}
bool ELF64::HasSection(ehs::UInt_64 hashId)
bool ELF::HasSection(ehs::UInt_64 hashId)
{
for (ehs::UInt_16 i = 0; i < sections.Size(); i++)
if (sections[i].GetHashId() == hashId)
@@ -147,12 +153,12 @@ bool ELF64::HasSection(ehs::UInt_64 hashId)
return false;
}
bool ELF64::HasSection(ehs::Str_8& id)
bool ELF::HasSection(ehs::Str_8& id)
{
return HasSection(id.Hash_64());
}
void ELF64::AddSection(ELF64_Section newSection)
void ELF::AddSection(ELF_Section newSection)
{
if (HasSection(newSection.GetHashId()))
{
@@ -162,7 +168,7 @@ void ELF64::AddSection(ELF64_Section newSection)
ehs::Str_8 newId = newSection.GetId();
ELF64_Section* shStrTab = FindShStrTab();
ELF_Section* shStrTab = FindShStrTab();
ehs::Serializer<ehs::UInt_64>& data = shStrTab->GetData();
newSection.nameOffset = data.GetOffset();
@@ -172,12 +178,12 @@ void ELF64::AddSection(ELF64_Section newSection)
data.SetOffset(data.GetOffset() + newId.Size());
data.Write('\0');
sections.Push((ELF64_Section&&)newSection);
sections.Push((ELF_Section&&)newSection);
EHS_LOG_SUCCESS();
}
ELF64_Section* ELF64::GetSection(ehs::UInt_64 sectionHashId) const
ELF_Section* ELF::GetSection(ehs::UInt_64 sectionHashId) const
{
for (ehs::UInt_16 i = 0; i < sections.Size(); i++)
if (sections[i].GetHashId() == sectionHashId)
@@ -186,12 +192,12 @@ ELF64_Section* ELF64::GetSection(ehs::UInt_64 sectionHashId) const
return nullptr;
}
ELF64_Section* ELF64::GetSection(const ehs::Str_8& sectionId) const
ELF_Section* ELF::GetSection(const ehs::Str_8& sectionId) const
{
return GetSection(sectionId.Hash_64());
}
ehs::UInt_64 ELF64::GetLastSegmentOffset() const
ehs::UInt_64 ELF::GetLastSegmentOffset() const
{
ehs::UInt_64 offset = ELFH_SIZE + PRGH_SIZE * programs.Size();
@@ -206,7 +212,7 @@ ehs::UInt_64 ELF64::GetLastSegmentOffset() const
return offset;
}
ehs::Vec2_u64 ELF64::SegmentRange(ehs::UInt_64 sectionHashId)
ehs::Vec2_u64 ELF::SegmentRange(ehs::UInt_64 sectionHashId)
{
ehs::UInt_64 offset = ELFH_SIZE + PRGH_SIZE * programs.Size();
if (sectionHashId)
@@ -237,19 +243,19 @@ ehs::Vec2_u64 ELF64::SegmentRange(ehs::UInt_64 sectionHashId)
return {};
}
ehs::Vec2_u64 ELF64::SegmentRange(const ehs::Str_8& sectionId)
ehs::Vec2_u64 ELF::SegmentRange(const ehs::Str_8& sectionId)
{
return SegmentRange(sectionId.Hash_64());
}
ehs::Serializer<ehs::UInt_64> ELF64::Serialize() const
ehs::Serializer<ehs::UInt_64> ELF::Serialize() const
{
ehs::Serializer<ehs::UInt_64> result(ehs::Endianness::LE);
result.Resize(Elf_Magic_Size);
ehs::Util::Copy(&result[0], Elf_Magic, Elf_Magic_Size);
result.SetOffset(Elf_Magic_Size);
result.Write<ehs::UInt_8>(ELFH_ARCH_64);
// ELF magic number.
result.Write<ehs::UInt_32>(0x7F454C46);
result.Write<ehs::UInt_8>(ELF_BIT_DEPTH_64);
result.Write(endianness);
result.Write<ehs::UInt_8>(1);
result.Write(abi);
@@ -296,15 +302,15 @@ ehs::Serializer<ehs::UInt_64> ELF64::Serialize() const
return result;
}
void ELF64::InitializeSections()
void ELF::InitializeSections()
{
ehs::Str_8 nullName = ".NULL";
ELF64_Section null(nullName, 0, SECH_TYPE_NULL, 0, 0, 0);
ELF_Section null(nullName, 0, SECH_TYPE_NULL, 0, 0, 0);
ehs::Str_8 shStrTabName = ".shstrtab";
ELF64_Section shStrTab(shStrTabName, 0, SECH_TYPE_STRTAB, SECH_FLAG_STRINGS, 0, 1);
ELF_Section shStrTab(shStrTabName, 0, SECH_TYPE_STRTAB, SECH_FLAG_STRINGS, 0, 1);
ehs::Serializer<ehs::UInt_64>& data = shStrTab.GetData();
@@ -320,11 +326,11 @@ void ELF64::InitializeSections()
data.SetOffset(data.GetOffset() + shStrTabName.Size());
data.Write('\0');
sections.Push((ELF64_Section&&)null);
sections.Push((ELF64_Section&&)shStrTab);
sections.Push((ELF_Section&&)null);
sections.Push((ELF_Section&&)shStrTab);
}
ehs::UInt_64 ELF64::RetrieveSectionsOffset() const
ehs::UInt_64 ELF::RetrieveSectionsOffset() const
{
ehs::UInt_64 result = ELFH_SIZE + PRGH_SIZE * programs.Size();
@@ -339,7 +345,7 @@ ehs::UInt_64 ELF64::RetrieveSectionsOffset() const
return result;
}
ehs::UInt_16 ELF64::FindShStrTabIndex() const
ehs::UInt_16 ELF::FindShStrTabIndex() const
{
for (ehs::UInt_16 i = 0; i < sections.Size(); i++)
{
@@ -356,7 +362,7 @@ ehs::UInt_16 ELF64::FindShStrTabIndex() const
return 0;
}
ELF64_Section* ELF64::FindShStrTab() const
ELF_Section* ELF::FindShStrTab() const
{
for (ehs::UInt_16 i = 0; i < sections.Size(); i++)
{

24
src/ELF64_Program.cpp → src/ELF_Program.cpp
View File

@@ -1,24 +1,24 @@
#include "ELF64_Program.h"
#include "arctyx/ELF_Program.h"
ELF64_Program::ELF64_Program()
ELF_Program::ELF_Program()
: type(PRGH_TYPE_LOAD), flags(PRGH_FLAG_EXEC | PRGH_FLAG_READ), offset(0), vAddr(0), pAddr(0), fileSize(0),
adjustedMemSize(0), align(0x200000)
{
}
ELF64_Program::ELF64_Program(ehs::UInt_32 type, ehs::UInt_32 flags, ehs::UInt_64 offset, ehs::UInt_64 address, ehs::UInt_64 size, ehs::UInt_64 adjustedMemSize, ehs::UInt_64 align)
ELF_Program::ELF_Program(ehs::UInt_32 type, ehs::UInt_32 flags, ehs::UInt_64 offset, ehs::UInt_64 address, ehs::UInt_64 size, ehs::UInt_64 adjustedMemSize, ehs::UInt_64 align)
: type(type), flags(flags), offset(offset), vAddr(address), pAddr(address), fileSize(size),
adjustedMemSize(adjustedMemSize), align(align)
{
}
ELF64_Program::ELF64_Program(ehs::Serializer<ehs::UInt_64>& data)
ELF_Program::ELF_Program(ehs::Serializer<ehs::UInt_64>& data)
: type(PRGH_TYPE_LOAD), flags(PRGH_FLAG_EXEC | PRGH_FLAG_READ), offset(0), vAddr(0), pAddr(0), fileSize(0),
adjustedMemSize(0), align(0x200000)
{
}
ELF64_Program::ELF64_Program(ELF64_Program&& program) noexcept
ELF_Program::ELF_Program(ELF_Program&& program) noexcept
: type(program.type), flags(program.flags), offset(program.offset), vAddr(program.vAddr), pAddr(program.pAddr),
fileSize(program.fileSize), adjustedMemSize(program.adjustedMemSize), align(program.align)
{
@@ -32,13 +32,13 @@ ELF64_Program::ELF64_Program(ELF64_Program&& program) noexcept
program.align = 0x200000;
}
ELF64_Program::ELF64_Program(const ELF64_Program& program)
ELF_Program::ELF_Program(const ELF_Program& program)
: type(program.type), flags(program.flags), offset(program.offset), vAddr(program.vAddr), pAddr(program.pAddr),
fileSize(program.fileSize), adjustedMemSize(program.adjustedMemSize), align(program.align)
{
}
ELF64_Program& ELF64_Program::operator=(ELF64_Program&& program) noexcept
ELF_Program& ELF_Program::operator=(ELF_Program&& program) noexcept
{
if (this == &program)
return *this;
@@ -64,7 +64,7 @@ ELF64_Program& ELF64_Program::operator=(ELF64_Program&& program) noexcept
return *this;
}
ELF64_Program& ELF64_Program::operator=(const ELF64_Program& program)
ELF_Program& ELF_Program::operator=(const ELF_Program& program)
{
if (this == &program)
return *this;
@@ -81,22 +81,22 @@ ELF64_Program& ELF64_Program::operator=(const ELF64_Program& program)
return *this;
}
ehs::UInt_32 ELF64_Program::GetType() const
ehs::UInt_32 ELF_Program::GetType() const
{
return type;
}
ehs::UInt_32 ELF64_Program::GetFlags() const
ehs::UInt_32 ELF_Program::GetFlags() const
{
return flags;
}
ehs::UInt_64 ELF64_Program::GetAlign() const
ehs::UInt_64 ELF_Program::GetAlign() const
{
return align;
}
void ELF64_Program::Serialize(ehs::Serializer<ehs::UInt_64>& inData) const
void ELF_Program::Serialize(ehs::Serializer<ehs::UInt_64>& inData) const
{
inData.Write(type);
inData.Write(flags);

38
src/ELF64_Section.cpp → src/ELF_Section.cpp
View File

@@ -1,19 +1,19 @@
#include "ELF64_Section.h"
#include "arctyx/ELF_Section.h"
ELF64_Section::ELF64_Section()
ELF_Section::ELF_Section()
: hashId(0), nameOffset(0), fileOffset(0), type(0), flags(0), vAddr(0), segmentOffset(0), link(0),
info(0), align(0), entries(0), data(ehs::Endianness::LE)
{
}
ELF64_Section::ELF64_Section(ehs::Str_8 id, ehs::UInt_64 fileOffset, ehs::UInt_32 type, ehs::UInt_64 flags, ehs::UInt_64 vAddr, ehs::UInt_64 align)
ELF_Section::ELF_Section(ehs::Str_8 id, ehs::UInt_64 fileOffset, ehs::UInt_32 type, ehs::UInt_64 flags, ehs::UInt_64 vAddr, ehs::UInt_64 align)
: hashId(id.Hash_64()), id((ehs::Str_8&&)id), nameOffset(0), fileOffset(fileOffset), type(type), flags(flags), vAddr(vAddr),
segmentOffset(0), link(0), info(0), align(align), entries(0), data(ehs::Endianness::LE)
{
}
ELF64_Section::ELF64_Section(ELF64_Section&& sect) noexcept
ELF_Section::ELF_Section(ELF_Section&& sect) noexcept
: hashId(sect.hashId), id((ehs::Str_8&&)sect.id), nameOffset(sect.nameOffset), fileOffset(sect.fileOffset),
type(sect.type), flags(sect.flags), vAddr(sect.vAddr), segmentOffset(sect.segmentOffset),
link(sect.link), info(sect.info), align(sect.align), entries(sect.entries),
@@ -32,14 +32,14 @@ ELF64_Section::ELF64_Section(ELF64_Section&& sect) noexcept
sect.entries = 0;
}
ELF64_Section::ELF64_Section(const ELF64_Section& sect)
ELF_Section::ELF_Section(const ELF_Section& sect)
: hashId(sect.hashId), id(sect.id), nameOffset(0), fileOffset(sect.fileOffset), type(sect.type),
flags(sect.flags), vAddr(sect.vAddr), segmentOffset(sect.segmentOffset), link(sect.link),
info(sect.info), align(sect.align), entries(sect.entries), data(sect.data)
{
}
ELF64_Section& ELF64_Section::operator=(ELF64_Section&& sect) noexcept
ELF_Section& ELF_Section::operator=(ELF_Section&& sect) noexcept
{
if (this == &sect)
return *this;
@@ -74,7 +74,7 @@ ELF64_Section& ELF64_Section::operator=(ELF64_Section&& sect) noexcept
return *this;
}
ELF64_Section& ELF64_Section::operator=(const ELF64_Section& sect)
ELF_Section& ELF_Section::operator=(const ELF_Section& sect)
{
if (this == &sect)
return *this;
@@ -96,62 +96,62 @@ ELF64_Section& ELF64_Section::operator=(const ELF64_Section& sect)
return *this;
}
ehs::UInt_64 ELF64_Section::GetHashId() const
ehs::UInt_64 ELF_Section::GetHashId() const
{
return hashId;
}
ehs::Str_8 ELF64_Section::GetId() const
ehs::Str_8 ELF_Section::GetId() const
{
return id;
}
ehs::UInt_32 ELF64_Section::GetType() const
ehs::UInt_32 ELF_Section::GetType() const
{
return type;
}
ehs::UInt_64 ELF64_Section::GetFlags() const
ehs::UInt_64 ELF_Section::GetFlags() const
{
return flags;
}
ehs::UInt_64 ELF64_Section::GetVirtualAddress() const
ehs::UInt_64 ELF_Section::GetVirtualAddress() const
{
return vAddr;
}
void ELF64_Section::SetLink(ehs::UInt_32 newLink)
void ELF_Section::SetLink(ehs::UInt_32 newLink)
{
link = newLink;
}
void ELF64_Section::SetInfo(ehs::UInt_32 newInfo)
void ELF_Section::SetInfo(ehs::UInt_32 newInfo)
{
info = newInfo;
}
ehs::UInt_64 ELF64_Section::GetAlignment() const
ehs::UInt_64 ELF_Section::GetAlignment() const
{
return align;
}
void ELF64_Section::SetEntries(ehs::UInt_64 newEntries)
void ELF_Section::SetEntries(ehs::UInt_64 newEntries)
{
entries = newEntries;
}
void ELF64_Section::SetData(ehs::Serializer<ehs::UInt_64> newData)
void ELF_Section::SetData(ehs::Serializer<ehs::UInt_64> newData)
{
data = (ehs::Serializer<ehs::UInt_64>&&)newData;
}
ehs::Serializer<ehs::UInt_64>& ELF64_Section::GetData()
ehs::Serializer<ehs::UInt_64>& ELF_Section::GetData()
{
return data;
}
void ELF64_Section::Serialize(ehs::Serializer<ehs::UInt_64>& inData) const
void ELF_Section::Serialize(ehs::Serializer<ehs::UInt_64>& inData) const
{
inData.Write(nameOffset);
inData.Write(type);

8
src/ELF64_Sym.cpp → src/ELF_Sym.cpp
View File

@@ -1,17 +1,17 @@
#include "ELF64_Sym.h"
#include "arctyx/ELF_Sym.h"
ELF64_Sym::ELF64_Sym()
ELF_Sym::ELF_Sym()
: nameOffset(0), type(0), visibility(0), section(0), value(0), size(0)
{
}
ELF64_Sym::ELF64_Sym(ehs::UInt_32 nameOffset, ehs::UInt_8 type, ehs::UInt_8 visibility, ehs::UInt_16 section, ehs::UInt_64 value, ehs::UInt_64 size)
ELF_Sym::ELF_Sym(ehs::UInt_32 nameOffset, ehs::UInt_8 type, ehs::UInt_8 visibility, ehs::UInt_16 section, ehs::UInt_64 value, ehs::UInt_64 size)
: nameOffset(nameOffset), type(type), visibility(visibility), section(section), value(value), size(size)
{
}
void ELF64_Sym::Serialize(ehs::Serializer<ehs::UInt_64>& inData) const
void ELF_Sym::Serialize(ehs::Serializer<ehs::UInt_64>& inData) const
{
inData.Write(nameOffset);
inData.Write(type);

1
src/Linker.cpp Normal file
View File

@@ -0,0 +1 @@
#include "arctyx/Linker.h"

24
src/main.cpp
View File

@@ -1,5 +1,5 @@
#include "ELF64.h"
#include "ELF64_Sym.h"
#include "arctyx/ELF.h"
#include "arctyx/ELF_Sym.h"
#include <ehs/EHS.h>
#include <ehs/io/Console.h>
@@ -7,7 +7,7 @@
int main()
{
ehs::Initialize("Compiler", "Alpha", {1, 0, 0});
ehs::Initialize("Arctyx", "Alpha", {1, 0, 0});
ehs::Vector<ehs::Str_8> args = ehs::Console::GetArgs_8();
if (args.Size() <= 1)
@@ -22,15 +22,15 @@ int main()
ehs::Serializer<ehs::UInt_64> code = codeFile.ReadSerializer_64(ehs::Endianness::LE, codeFile.Size());
codeFile.Release();
ELF64 executable(ELFH_END_LE, ELFH_ABI_SYSTEMV, ELFH_TYPE_EXEC, ELFH_MARCH_AMD_X86_64);
ELF executable(ELF_BIT_DEPTH_64, ELF_END_LE, ELFH_ABI_SYSTEMV, ELFH_TYPE_EXEC, ELF_ARCH_X86_64);
ehs::UInt_64 lSgmtOffset = executable.GetLastSegmentOffset();
ELF64_Section text(".text", 0x1000, SECH_TYPE_PROGBITS, SECH_FLAG_ALLOC | SECH_FLAG_EXEC, 0x401000, 16);
ELF_Section text(".text", 0x1000, SECH_TYPE_PROGBITS, SECH_FLAG_ALLOC | SECH_FLAG_EXEC, 0x401000, 16);
text.SetData(code);
executable.AddSection((ELF64_Section&&)text);
executable.AddSection((ELF_Section&&)text);
ELF64_Section strTab(".strtab", 0, SECH_TYPE_STRTAB, 0, 0, 1);
ELF_Section strTab(".strtab", 0, SECH_TYPE_STRTAB, 0, 0, 1);
ehs::Serializer<ehs::UInt_64>& strTabData = strTab.GetData();
constexpr ehs::Char_8 symName[] = "\0_start\0";
@@ -38,21 +38,21 @@ int main()
ehs::Util::Copy(&strTabData[0], symName, sizeof(symName));
strTabData.SetOffset(sizeof(symName));
executable.AddSection((ELF64_Section&&)strTab);
executable.AddSection((ELF_Section&&)strTab);
ELF64_Section symTab(".symtab", 0, SECH_TYPE_SYMTAB, 0, 0, 8);
ELF_Section symTab(".symtab", 0, SECH_TYPE_SYMTAB, 0, 0, 8);
symTab.SetLink(3);
symTab.SetInfo(2);
symTab.SetEntries(SYMH_SIZE);
ehs::Serializer<ehs::UInt_64>& symTabData = symTab.GetData();
ELF64_Sym nullSym;
ELF_Sym nullSym;
nullSym.Serialize(symTabData);
ELF64_Sym _start(1, SYM_INFO(SYM_BIND_GLOBAL, SYM_TYPE_NOTYPE), SYM_VIS_DEFAULT, 2, 0x401000, 0);
ELF_Sym _start(1, SYM_INFO(SYM_BIND_GLOBAL, SYM_TYPE_NOTYPE), SYM_VIS_DEFAULT, 2, 0x401000, 0);
_start.Serialize(symTabData);
executable.AddSection((ELF64_Section&&)symTab);
executable.AddSection((ELF_Section&&)symTab);
executable.AddProgram({PRGH_TYPE_LOAD, PRGH_FLAG_READ, 0, 0x400000, lSgmtOffset, 0, 0x1000});
executable.AddProgram({PRGH_TYPE_LOAD, PRGH_FLAG_EXEC | PRGH_FLAG_READ, 0x1000, 0x401000, code.Size(), 0, 0x1000});