PastaBoy12345/vystem-b
2
0
Fork 0
forked from lolo859/vystem
Code Pull Requests Activity
Files
147e704be12070fe37e77b65dcd36786f6631a5e
vystem-b/vybuild/vybuild-vyld.cpp
lolo859 d238606b75 Vystem 0.2
2026-05-27 19:34:54 +02:00

796 lines
31 KiB
C++
Raw Blame History

// SPDX-License-Identifier: MPL-2.0
#include "vybuild.hpp"
#include <iostream>
#include <unistd.h>
#include <sstream>
#include <thread>
#include <queue>
#include <mutex>
#include <functional>
#include <regex>
#include <sys/wait.h>
#include <wordexp.h>
#include <random>
#include "elfio.hpp"
#include "common/versions.h"
using namespace std;
extern int get_deepness();
queue<function<vybuild::actions::ActionStatus()>> vyld_compilation_tasks;
mutex vyld_compilation_tasks_mutex;
void print_deepness_vyld(string text) {
cout<<"[VyBuild] ";
for (int i=0;i<get_deepness();i++) {
cout<<"│ ";
}
cout<<text<<endl;
return;
}
string find_executable_vyld(const string& exe_name) {
const char* path_env=getenv("PATH");
if (!path_env) return "";
string paths(path_env);
stringstream ss(paths);
string dir;
while (std::getline(ss,dir,':')) {
fs::path candidate=fs::path(dir)/exe_name;
if (fs::exists(candidate) && fs::is_regular_file(candidate) && (fs::status(candidate).permissions() & fs::perms::owner_exec)!=fs::perms::none) {
return candidate.string();
}
}
return "";
}
vector<string> split_args_shell_vyld(const string& input) {
wordexp_t result;
vector<string> args;
if (wordexp(input.c_str(),&result,0)==0) {
for (size_t i=0;i<result.we_wordc;++i) {
args.emplace_back(result.we_wordv[i]);
}
}
wordfree(&result);
return args;
}
string get_command_output_vyld(string command) {
int pipefd[2];
if (pipe(pipefd)==-1) {
throw std::runtime_error("Couldn't create pipe for obtaining command output.");
}
pid_t pid=fork();
if (pid<0) {
throw std::runtime_error("Couldn't fork process.");
}
if (pid==0) {
close(pipefd[0]);
dup2(pipefd[1],STDOUT_FILENO);
dup2(pipefd[1],STDERR_FILENO);
close(pipefd[1]);
std::vector<const char*> argv;
auto args=split_args_shell_vyld(command);
args[0]=find_executable_vyld(args[0]).c_str();
for (auto &a:args) argv.push_back(a.c_str());
argv.push_back(nullptr);
execvp(argv[0],const_cast<char* const*>(argv.data()));
cout<<string(strerror(errno))<<endl;
throw std::runtime_error("Command failed.");
_exit(1);
} else {
close(pipefd[1]);
std::stringstream buffer;
char c;
while (read(pipefd[0],&c,1)>0) {
buffer<<c;
}
close(pipefd[0]);
int status;
waitpid(pid,&status,0);
if (!WIFEXITED(status)) {
throw std::runtime_error("An error happened in forked process.");
}
return buffer.str();
}
}
vector<string> headers_from_dfile_vyld(string dfile_path) {
if (!fs::exists(dfile_path)) throw std::runtime_error(dfile_path+" doesn't exist.");
ifstream dfile(dfile_path);
vector<string> deps;
string line,all;
while (getline(dfile,line)) {
if (!line.empty() && line.back()=='\\') {
line.pop_back();
all+=line+" ";
} else {
all+=line+ " ";
}
}
auto pos=all.find(':');
if (pos==string::npos) return deps;
string rest=all.substr(pos+1);
istringstream iss(rest);
string token;
while (iss>>token) {
deps.push_back(token);
}
return deps;
}
struct vyx_addresses {
uint64_t text_offset;
uint64_t stack_base;
};
uint64_t rand_in_range(uint64_t min,uint64_t max) {
static random_device rd;
static mt19937_64 gen(rd());
std::uniform_int_distribution<uint64_t> dis(min, max);
return dis(gen);
}
uint64_t random_canonical(uint64_t start,uint64_t end) {
uint64_t addr=rand_in_range(start/4096,end/4096)*4096;
return addr;
}
vyx_addresses generate_vyx_addresses() {
vyx_addresses addr;
addr.text_offset=random_canonical(0xFFFF800000000000ULL,0xFFFF900000000000ULL-1);
addr.stack_base=random_canonical(0xFFFFF00000000000ULL,0xFFFFFF8000000000ULL-0x100000ULL);
return addr;
}
size_t pad_size(size_t value,size_t multiple) {
if (multiple==0) return value;
size_t remainder=value%multiple;
if (remainder==0) return value;
return value+multiple-remainder;
}
#pragma pack(1)
struct payload_header {
uint8_t sig[8]={'V','P','A','Y','L','O','A','D'};
uint32_t payload_size_bytes=0;
uint32_t payload_pages_count=0;
uint8_t map_flags=0;
uint64_t load_address=0;
};
#pragma pack()
#define EXECUTABLE (1<<0)
#define WRITABLE (1<<1)
static bool char_to_value(char c,uint8_t &out) {
if (c>='0' && c<='9') {
out=c-'0';
return true;
}
if (c>='a' && c<='f') {
out=c-'a'+10;
return true;
}
if (c>='A' && c<='F') {
out=c-'A'+10;
return true;
}
return false;
}
uint64_t string_hex_to_u64(const std::string &str){
if (str.size()<3) return false;
if (!(str[0]=='0' && (str[1]=='x'))) return false;
uint64_t value=0;
for (size_t i=2;i<str.size();i++) {
uint8_t v=0;
if (!char_to_value(str[i],v))return false;
value=(value<<4)|v;
}
return value;
}
vector<uint8_t> generate_payloads(const json& payloads) {
vector<uint8_t> out={};
if (payloads.size()==0) return out;
for (auto &p:payloads) {
if (!p.is_object()) throw std::runtime_error("Payload must be stored in a dictionnary.");
vybuild::actions::check_arg_string(p,"source_file");
if (!p.contains("is_executable")) throw std::runtime_error("Is executable isn't provided.");
if (!p["is_executable"].is_boolean()) throw std::runtime_error("Is executable isn't a boolean.");
if (!p.contains("is_writable")) throw std::runtime_error("Is writable isn't provided.");
if (!p["is_writable"].is_boolean()) throw std::runtime_error("Is writbale isn't a boolean.");
if (!p.contains("expected_va")) throw std::runtime_error("Expected VA isn't provided.");
if (!p["expected_va"].is_string()) throw std::runtime_error("Expected VA isn't a string.");
fs::path source_file=p["source_file"].get<string>();
bool source_file_variables=p["source_file_variables"].get<bool>();
if (source_file_variables) source_file=vybuild::parser::string_vars(source_file);
if (!fs::exists(source_file)) throw std::runtime_error("Source file doesn't exist: "+source_file.string());
if (!fs::is_regular_file(source_file)) throw std::runtime_error("Source file isn't a regular file: "+source_file.string());
size_t payload_size=fs::file_size(source_file);
size_t payload_page_count=pad_size(payload_size,4096)/4096;
uint64_t va=string_hex_to_u64(p["expected_va"].get<string>());
if (va==0 || va%4096!=0) throw std::runtime_error("Invalid expected VA: expected VA must be non null and 4KB aligned.");
payload_header header;
header.payload_size_bytes=payload_size;
header.payload_pages_count=payload_page_count;
header.load_address=va;
if (p["is_executable"].get<bool>()) header.map_flags|=EXECUTABLE;
if (p["is_writable"].get<bool>()) header.map_flags|=WRITABLE;
ifstream payload_bin(source_file,ios::binary);
if (!payload_bin) throw std::runtime_error("VyldCompilationAction: Cannot open payload source file: "+source_file.string());
vector<uint8_t> payload_content(payload_size);
payload_bin.read(reinterpret_cast<char*>(payload_content.data()),payload_size);
if (!payload_bin) throw std::runtime_error("VyldCompilationAction: Cannot read payload source file: "+source_file.string());
vector<uint8_t> final_payload(sizeof(payload_header));
memcpy(final_payload.data(),(uint8_t*)&header,sizeof(payload_header));
final_payload.insert(final_payload.end(),payload_content.begin(),payload_content.end());
out.insert(out.end(),final_payload.begin(),final_payload.end());
}
return out;
}
vybuild::actions::ActionStatus parallel_vyld_compilation(string source,string compiler_path,string compiler_hash,vector<string> compiler_args,string dfile_path,string header_command,string output_file) {
if (compiler_hash!="") {
string c_content="";
auto vars_list=vybuild::vars::get_global_variables_list();
if (header_command!="") {
string dep_command=header_command;
regex regvar1("%dfile%");
dep_command=regex_replace(dep_command,regvar1,dfile_path);
regex regvar2("%sourcefile%");
dep_command=regex_replace(dep_command,regvar2,source);
int res=std::system(dep_command.c_str());
if (res!=0) {
print_deepness_vyld("ParallelVyldCompilation: Cannot get headers list for file \""+source+"\" with command: "+dep_command);
return vybuild::actions::ActionStatus::Fail;
}
auto headers=headers_from_dfile_vyld(dfile_path);
for (auto &h:headers) {
ifstream header(h);
vector<char> header_data(fs::file_size(fs::absolute(h)));
if (!header) {
print_deepness_vyld("ParallelVyldCompilation: Couldn't open source/header file: "+h);
return vybuild::actions::ActionStatus::SystemError;
}
header.read(header_data.data(),header_data.size());
if (!header) {
print_deepness_vyld("ParallelVyldCompilation: Couldn't read source/header file: "+h);
return vybuild::actions::ActionStatus::SystemError;
}
c_content+=string(header_data.begin(),header_data.end());
header.close();
}
fs::remove(dfile_path);
}
c_content+="\n"+compiler_path;
c_content+="\n"+compiler_hash;
for (auto& a:compiler_args) c_content+="\n"+a;
string key=vybuild::cache::xxhash_to_string(XXH3_128bits(c_content.data(),c_content.size()));
if (vybuild::cache::cache_contains(key)) {
vybuild::cache::extract_file(key,output_file);
return vybuild::actions::ActionStatus::Success;
}
int pipefd[2];
if (pipe(pipefd)==-1) {
print_deepness_vyld("ParallelVyldCompilation: An error happened while creating pipe.");
return vybuild::actions::ActionStatus::SystemError;
}
pid_t pid=fork();
if (pid<0) {
print_deepness_vyld("ParallelVyldCompilation: An error happened while forking.");
return vybuild::actions::ActionStatus::SystemError;
}
if (pid==0) {
close(pipefd[0]);
dup2(pipefd[1],STDOUT_FILENO);
dup2(pipefd[1],STDERR_FILENO);
close(pipefd[1]);
std::vector<const char*> argv={compiler_path.c_str()};
argv.push_back("-c");
argv.push_back(source.c_str());
argv.push_back("-o");
argv.push_back(output_file.c_str());
for (int i=0;i<compiler_args.size();i++) {
argv.push_back(compiler_args[i].c_str());
}
argv.push_back(nullptr);
execvp(compiler_path.c_str(),const_cast<char* const*>(argv.data()));
print_deepness_vyld("ParallelVyldCompilation: An error happened while executing command.");
_exit(1);
} else {
close(pipefd[1]);
std::stringstream buffer;
char c;
while (read(pipefd[0],&c,1)>0) {
buffer<<c;
}
close(pipefd[0]);
int status;
waitpid(pid,&status,0);
if (!WIFEXITED(status)) {
print_deepness_vyld("ParallelVyldCompilation: An error happened in forked process.");
return vybuild::actions::ActionStatus::SystemError;
}
if (WEXITSTATUS(status)!=0) {
print_deepness_vyld("ParallelVyldCompilation: Command exited with error (status "+to_string(WEXITSTATUS(status))+"), showing output:\n");
cout<<buffer.str()<<endl;
return vybuild::actions::ActionStatus::Fail;
} else {
vybuild::cache::store_file(key,output_file);
return vybuild::actions::ActionStatus::Success;
}
}
} else {
int pipefd[2];
if (pipe(pipefd)==-1) {
print_deepness_vyld("ParallelVyldCompilation: An error happened while creating pipe.");
return vybuild::actions::ActionStatus::SystemError;
}
pid_t pid=fork();
if (pid<0) {
print_deepness_vyld("ParallelVyldCompilation: An error happened while forking.");
return vybuild::actions::ActionStatus::SystemError;
}
if (pid==0) {
close(pipefd[0]);
dup2(pipefd[1],STDOUT_FILENO);
dup2(pipefd[1],STDERR_FILENO);
close(pipefd[1]);
std::vector<const char*> argv={compiler_path.c_str()};
argv.push_back("-c");
argv.push_back(source.c_str());
argv.push_back("-o");
argv.push_back(output_file.c_str());
for (int i=0;i<compiler_args.size();i++) {
argv.push_back(compiler_args[i].c_str());
}
argv.push_back(nullptr);
execvp(compiler_path.c_str(),const_cast<char* const*>(argv.data()));
print_deepness_vyld("ParallelVyldCompilation: An error happened while executing command.");
_exit(1);
} else {
close(pipefd[1]);
std::stringstream buffer;
char c;
while (read(pipefd[0],&c,1)>0) {
buffer<<c;
}
close(pipefd[0]);
int status;
waitpid(pid,&status,0);
if (!WIFEXITED(status)) {
print_deepness_vyld("ParallelVyldCompilation: An error happened in forked process.");
return vybuild::actions::ActionStatus::SystemError;
}
if (WEXITSTATUS(status)==0) {
print_deepness_vyld("ParallelVyldCompilation: Command exited with error (status "+to_string(WEXITSTATUS(status))+"), showing output:\n");
cout<<buffer.str()<<endl;
return vybuild::actions::ActionStatus::Fail;
} else {
return vybuild::actions::ActionStatus::Success;
}
}
}
return vybuild::actions::ActionStatus::Success;
}
vybuild::actions::ActionStatus parrallel_vyld_compilation_worker(size_t thread_num) {
while (true) {
function<vybuild::actions::ActionStatus()> task;
{
std::lock_guard lock(vyld_compilation_tasks_mutex);
if (vyld_compilation_tasks.empty()) break;
task=std::move(vyld_compilation_tasks.front());
vyld_compilation_tasks.pop();
}
auto status=task();
if (status!=vybuild::actions::ActionStatus::Success) {
return status;
}
}
return vybuild::actions::ActionStatus::Success;
}
vybuild::actions::ActionStatus vybuild::actions::VyldCompilationAction::run_action() {
if (this->source_files_variables) this->source_files=vybuild::parser::vector_string_vars(this->source_files);
if (this->source_files_path_completion) this->source_files=vybuild::parser::vector_string_path_completions(this->source_files,".c");
if (this->source_asm_variables) this->source_asm=vybuild::parser::vector_string_vars(this->source_asm);
if (this->source_asm_path_completion) this->source_asm=vybuild::parser::vector_string_path_completions(this->source_asm,".asm");
if (this->compiler_variables) this->compiler=vybuild::parser::string_vars(this->compiler);
if (this->assembler_variables) this->assembler=vybuild::parser::string_vars(this->assembler);
if (this->linker_variables) this->linker=vybuild::parser::string_vars(this->linker);
if (this->compiler_flags_variables) this->compiler_flags=vybuild::parser::string_vars(this->compiler_flags);
if (this->output_file_variables) this->output_file=vybuild::parser::string_vars(this->output_file);
if (this->headers_command_variables) this->headers_command=vybuild::parser::string_vars(this->headers_command);
string compiler_path=find_executable_vyld(this->compiler);
string compiler_hash="";
auto vars_list=vybuild::vars::get_global_variables_list();
if (this->object_files_cache_authorized) {
ifstream compiler_bin(compiler_path,ios::binary);
if (!compiler_bin) {
print_deepness_vyld("VyldCompilationAction: Cannot open compiler binary: "+compiler_path);
return vybuild::actions::ActionStatus::SystemError;
}
size_t compiler_size=fs::file_size(compiler_path);
vector<uint8_t> compiler_data(compiler_size);
compiler_bin.read(reinterpret_cast<char*>(compiler_data.data()),compiler_size);
if (!compiler_bin) {
print_deepness_vyld("VyldCompilationAction: Cannot read compiler binary: "+compiler_path);
return vybuild::actions::ActionStatus::SystemError;
}
compiler_hash=vybuild::cache::xxhash_to_string(XXH3_128bits(compiler_data.data(),compiler_data.size()));
for (auto &v:vars_list) {
if (v.starts_with("\\$__VYBUILD_COMPILER_HASH_")) {
compiler_hash+="\n"+get_command_output_vyld(vybuild::vars::get_global_variable(v));
}
}
}
char buf[PATH_MAX];
ssize_t len=readlink("/proc/self/exe",buf,sizeof(buf)-1);
fs::path exe_path;
if (len!=-1) {
buf[len]='\0';
exe_path=fs::path(buf);
} else {
print_deepness_vyld("VyldCompilationAction: Couldn't obtain vybuild executable path.");
return vybuild::actions::ActionStatus::SystemError;
}
exe_path=exe_path.parent_path();
if (!fs::exists(exe_path/"_vyx_start.c")) {
print_deepness_vyld("VyldCompilationAction: _vyx_start.c isn't accessible.");
return vybuild::actions::ActionStatus::SystemError;
}
this->source_files.insert(this->source_files.begin(),string(exe_path/"_vyx_start.c"));
size_t nb_thread=thread::hardware_concurrency();
size_t original_quantity=this->source_files.size();
fs::path build_path=".vybuild_build";
fs::create_directory(build_path);
auto compiler_args=split_args_shell_vyld(this->compiler_flags+" -fno-pic -m64 -mcmodel=large");
auto compiler_args_entry=split_args_shell_vyld("-ffreestanding -nostdlib -nostartfiles -Wall -Wextra -fno-stack-protector -Wno-missing-prototypes -fno-builtin -fno-pic -m64 -mcmodel=large");
vector<string> outputs;
for (int i=0;i<original_quantity;i++) {
string source_file=std::move(this->source_files[i]);
string filename=fs::path(source_file).filename().string();
string output_file=build_path/(filename.substr(0,filename.size()-2)+".o");
string dfile_path=build_path/(filename.substr(0,filename.size()-2)+".d");
string headers_cmd=this->headers_command;
outputs.push_back(output_file);
if (source_file!=string(exe_path/"_vyx_start.c")) {
vyld_compilation_tasks.push([source_file=std::move(source_file),compiler_path,compiler_hash,compiler_args,dfile_path=std::move(dfile_path),headers_cmd,output_file=std::move(output_file)]() mutable -> vybuild::actions::ActionStatus {
return parallel_vyld_compilation(source_file,compiler_path,compiler_hash,compiler_args,dfile_path,headers_cmd,output_file);
});
} else {
vyld_compilation_tasks.push([source_file=std::move(source_file),compiler_path,compiler_hash,compiler_args_entry,dfile_path=std::move(dfile_path),headers_cmd,output_file=std::move(output_file)]() mutable -> vybuild::actions::ActionStatus {
return parallel_vyld_compilation(source_file,compiler_path,compiler_hash,compiler_args_entry,dfile_path,headers_cmd,output_file);
});
}
}
vector<thread> threads;
vector<vybuild::actions::ActionStatus> results;
mutex results_mutex;
size_t real_threads=0;
if (original_quantity>nb_thread) {
real_threads=nb_thread;
} else {
real_threads=original_quantity;
}
results.resize(real_threads,vybuild::actions::ActionStatus::Success);
for (size_t i=0;i<real_threads;i++) {
threads.emplace_back([i,&results,&results_mutex]() {
auto status=parrallel_vyld_compilation_worker(i);
lock_guard<mutex> lock(results_mutex);
results[i]=status;
});
}
for (auto &t:threads) {
t.join();
}
for (auto status:results) {
if (status!=vybuild::actions::ActionStatus::Success) {
return status;
}
}
string assembler_path=find_executable_vyld(this->assembler);
for (auto &f:this->source_asm) {
string source_file=std::move(f);
string filename=fs::path(source_file).filename().string();
string output_file=build_path/(filename.substr(0,filename.size()-4)+".o");
outputs.push_back(output_file);
int pipefd[2];
if (pipe(pipefd)==-1) {
print_deepness_vyld("VyldCompilationAction: An error happened while creating pipe.");
return vybuild::actions::ActionStatus::SystemError;
}
pid_t pid=fork();
if (pid<0) {
print_deepness_vyld("VyldCompilationAction: An error happened while forking.");
return vybuild::actions::ActionStatus::SystemError;
}
if (pid==0) {
close(pipefd[0]);
dup2(pipefd[1],STDOUT_FILENO);
dup2(pipefd[1],STDERR_FILENO);
close(pipefd[1]);
vector<string> all_args;
all_args.push_back(assembler_path);
all_args.push_back("-f");
all_args.push_back("elf64");
all_args.push_back(source_file);
all_args.push_back("-o");
all_args.push_back(output_file);
std::vector<const char*> argv;
for (auto &s:all_args) argv.push_back(s.c_str());
argv.push_back(nullptr);
execvp(assembler_path.c_str(),const_cast<char* const*>(argv.data()));
print_deepness_vyld("VyldCompilationAction: An error happened while executing command.");
_exit(1);
} else {
close(pipefd[1]);
std::stringstream buffer;
char c;
while (read(pipefd[0],&c,1)>0) {
buffer<<c;
}
close(pipefd[0]);
int status;
waitpid(pid,&status,0);
if (!WIFEXITED(status)) {
print_deepness_vyld("VyldCompilationAction: An error happened in forked process.");
return vybuild::actions::ActionStatus::SystemError;
}
if (WEXITSTATUS(status)!=0) {
print_deepness_vyld("VyldCompilationAction: Command exited with error (status "+to_string(WEXITSTATUS(status))+"), showing output:\n");
cout<<buffer.str()<<endl;
return vybuild::actions::ActionStatus::Fail;
}
}
}
int pipefd[2];
if (pipe(pipefd)==-1) {
print_deepness_vyld("VyldCompilationAction: An error happened while creating pipe.");
return vybuild::actions::ActionStatus::SystemError;
}
pid_t pid=fork();
if (pid<0) {
print_deepness_vyld("VyldCompilationAction: An error happened while forking.");
return vybuild::actions::ActionStatus::SystemError;
}
if (pid==0) {
close(pipefd[0]);
dup2(pipefd[1],STDOUT_FILENO);
dup2(pipefd[1],STDERR_FILENO);
close(pipefd[1]);
vector<string> all_args;
all_args.push_back(compiler_path);
all_args.push_back("-r");
all_args.insert(all_args.end(),outputs.begin(),outputs.end());
all_args.push_back("-o");
all_args.push_back((build_path/"combined.o").string());
std::vector<const char*> argv;
for (auto &s:all_args) argv.push_back(s.c_str());
argv.push_back(nullptr);
execvp(compiler_path.c_str(),const_cast<char* const*>(argv.data()));
print_deepness_vyld("VyldCompilationAction: An error happened while executing command.");
_exit(1);
} else {
close(pipefd[1]);
std::stringstream buffer;
char c;
while (read(pipefd[0],&c,1)>0) {
buffer<<c;
}
close(pipefd[0]);
int status;
waitpid(pid,&status,0);
if (!WIFEXITED(status)) {
print_deepness_vyld("VyldCompilationAction: An error happened in forked process.");
return vybuild::actions::ActionStatus::SystemError;
}
if (WEXITSTATUS(status)!=0) {
print_deepness_vyld("VyldCompilationAction: Command exited with error (status "+to_string(WEXITSTATUS(status))+"), showing output:\n");
cout<<buffer.str()<<endl;
return vybuild::actions::ActionStatus::Fail;
}
}
ELFIO::elfio reader;
fs::path combined_o=build_path/"combined.o";
if (!reader.load(string(combined_o))) {
print_deepness_vyld("VyldCompilationAction: couldn't open combined.o.");
return vybuild::actions::ActionStatus::SystemError;
}
if (reader.get_type()!=ELFIO::ET_REL) {
print_deepness_vyld("VyldCompilationAction: combined.o isn't a relocatable object file.");
return vybuild::actions::ActionStatus::Fail;
}
if (reader.get_class()!=ELFIO::ELFCLASS64) {
print_deepness_vyld("VyldCompilationAction: combined.o isn't a 64-bit ELF file.");
return vybuild::actions::ActionStatus::Fail;
}
if (reader.get_machine()!=ELFIO::EM_X86_64) {
print_deepness_vyld("VyldCompilationAction: combined.o isn't a x86-64 file.");
return vybuild::actions::ActionStatus::Fail;
}
const ELFIO::section* text_sec=reader.sections[".text"];
const ELFIO::section* data_sec=reader.sections[".data"];
const ELFIO::section* rodata_sec=reader.sections[".rodata"];
const ELFIO::section* bss_sec=reader.sections[".bss"];
if (!text_sec) {
print_deepness_vyld("VyldCompilationAction: no .text section found.");
return vybuild::actions::ActionStatus::Fail;
}
if (text_sec->get_size()==0) {
print_deepness_vyld("VyldCompilationAction: .text is empty.");
return vybuild::actions::ActionStatus::Fail;
}
size_t text_size=text_sec->get_size();
size_t text_size_padded=pad_size(text_size,4096);
size_t data_size=0;
size_t data_size_padded=0;
size_t rodata_size=0;
size_t rodata_size_padded=0;
size_t bss_size=0;
size_t bss_size_padded=0;
if (data_sec) {
data_size=data_sec->get_size();
data_size_padded=pad_size(data_size,4096);
}
if (rodata_sec) {
rodata_size=rodata_sec->get_size();
for (const auto &s:reader.sections) {
if (s->get_name().size()>7 && s->get_name().substr(0,7)==".rodata" && s->get_name()!=".rodata") {
rodata_size+=s->get_size();
}
}
rodata_size_padded=pad_size(rodata_size,4096);
}
if (bss_sec) {
bss_size=bss_sec->get_size();
bss_size_padded=pad_size(bss_size,4096);
}
vyx_addresses va=generate_vyx_addresses();
size_t text_offset=va.text_offset;
size_t data_offset=text_offset+text_size_padded;
size_t rodata_offset=data_offset+data_size_padded;
size_t bss_offset=rodata_offset+rodata_size_padded;
ofstream ld(build_path/"script.ld");
ld<<"ENTRY(_vyx_start)\n";
ld<<"MEMORY\n{\n";
ld<<" TEXT (rx) : ORIGIN = 0x"<<hex<<text_offset<<", LENGTH = "<<dec<<text_size_padded<<"\n";
ld<<" DATA (rw) : ORIGIN = 0x"<<hex<<data_offset<<", LENGTH = "<<dec<<data_size_padded<<"\n";
ld<<" RODATA (r) : ORIGIN = 0x"<<hex<<rodata_offset<<", LENGTH = "<<dec<<rodata_size_padded<<"\n";
ld<<" BSS (rw) : ORIGIN = 0x"<<hex<<bss_offset<<", LENGTH = "<<dec<<bss_size_padded<<"\n";
ld<<"}\nSECTIONS\n{\n";
ld<<" .text :\n";
ld<<" {\n";
ld<<" . = ORIGIN(TEXT);\n";
ld<<" *(.text)\n";
ld<<" *(.text.*)\n";
ld<<" . = ALIGN(0x1000);\n";
ld<<" } > TEXT\n\n";
ld<<" .data :\n";
ld<<" {\n";
ld<<" . = ORIGIN(DATA);\n";
ld<<" *(.data)\n";
ld<<" *(.data.*)\n";
ld<<" . = ALIGN(0x1000);\n";
ld<<" } > DATA\n\n";
ld<<" .rodata :\n";
ld<<" {\n";
ld<<" . = ORIGIN(RODATA);\n";
ld<<" *(.rodata)\n";
ld<<" *(.rodata.*)\n";
ld<<" . = ALIGN(0x1000);\n";
ld<<" } > RODATA\n\n";
ld<<" .bss :\n";
ld<<" {\n";
ld<<" . = ORIGIN(BSS);\n";
ld<<" *(.bss)\n";
ld<<" *(.bss.*)\n";
ld<<" . = ALIGN(0x1000);\n";
ld<<" } > BSS\n\n";
ld<<" /DISCARD/ :\n";
ld<<" {\n";
ld<<" *(.note.*)\n";
ld<<" *(.comment)\n";
ld<<" *(.eh_frame)\n";
ld<<" *(.eh_frame_hdr)\n";
ld<<" }\n}";
ld.close();
pipefd[0]=0;
pipefd[1]=0;
if (pipe(pipefd)==-1) {
print_deepness_vyld("VyldCompilationAction: An error happened while creating pipe.");
return vybuild::actions::ActionStatus::SystemError;
}
pid=fork();
if (pid<0) {
print_deepness_vyld("VyldCompilationAction: An error happened while forking.");
return vybuild::actions::ActionStatus::SystemError;
}
if (pid==0) {
close(pipefd[0]);
dup2(pipefd[1],STDOUT_FILENO);
dup2(pipefd[1],STDERR_FILENO);
close(pipefd[1]);
vector<string> all_args;
all_args.push_back(this->linker);
all_args.push_back("-T");
all_args.push_back((build_path/"script.ld").string());
all_args.push_back("-o");
all_args.push_back((build_path/"compiled.elf").string());
all_args.push_back((build_path/"combined.o").string());
std::vector<const char*> argv;
for (auto &s:all_args) argv.push_back(s.c_str());
argv.push_back(nullptr);
execvp(this->linker.c_str(),const_cast<char* const*>(argv.data()));
print_deepness_vyld("VyldCompilationAction: An error happened while executing command.");
_exit(1);
} else {
close(pipefd[1]);
std::stringstream buffer;
char c;
while (read(pipefd[0],&c,1)>0) {
buffer<<c;
}
close(pipefd[0]);
int status;
waitpid(pid,&status,0);
if (!WIFEXITED(status)) {
print_deepness_vyld("VyldCompilationAction: An error happened in forked process.");
return vybuild::actions::ActionStatus::SystemError;
}
if (WEXITSTATUS(status)!=0) {
print_deepness_vyld("VyldCompilationAction: Command exited with error (status "+to_string(WEXITSTATUS(status))+"), showing output:\n");
cout<<buffer.str()<<endl;
return vybuild::actions::ActionStatus::Fail;
}
}
fs::path compiled_elf=build_path/"compiled.elf";
if (!reader.load(string(compiled_elf))) {
print_deepness_vyld("VyldCompilationAction: Couldn't open combined.elf.");
return vybuild::actions::ActionStatus::SystemError;
}
if (reader.get_type()!=ELFIO::ET_EXEC) {
print_deepness_vyld("VyldCompilationAction: compiled.elf isn't isn't an ELF binary.");
return vybuild::actions::ActionStatus::Fail;
}
if (reader.get_class()!=ELFIO::ELFCLASS64) {
print_deepness_vyld("VyldCompilationAction: combined.elf isn't a 64-bit ELF file.");
return vybuild::actions::ActionStatus::Fail;
}
if (reader.get_machine()!=ELFIO::EM_X86_64) {
print_deepness_vyld("VyldCompilationAction: combined.elf isn't a x86_64 file.");
return vybuild::actions::ActionStatus::Fail;
}
const ELFIO::section* elf_text_sec=reader.sections[".text"];
const ELFIO::section* elf_data_sec=reader.sections[".data"];
const ELFIO::section* elf_rodata_sec=reader.sections[".rodata"];
const ELFIO::section* elf_bss_sec=reader.sections[".bss"];
if (!elf_text_sec) {
print_deepness_vyld("VyldCompilationAction: no .text section found.");
return vybuild::actions::ActionStatus::Fail;
}
if (elf_text_sec->get_size()==0) {
print_deepness_vyld("VyldCompilationAction: .text is empty.");
return vybuild::actions::ActionStatus::Fail;
}
vector<unsigned char> elf_text_bin(text_size_padded,0);
vector<unsigned char> elf_data_bin(data_size_padded,0);
vector<unsigned char> elf_rodata_bin(rodata_size_padded,0);
memcpy(elf_text_bin.data(),elf_text_sec->get_data(),elf_text_sec->get_size());
if (elf_data_sec->get_size()!=0) {
memcpy(elf_data_bin.data(),elf_data_sec->get_data(),elf_data_sec->get_size());
}
if (elf_rodata_sec->get_size()!=0) {
memcpy(elf_rodata_bin.data(),elf_rodata_sec->get_data(),elf_rodata_sec->get_size());
}
uint8_t vyx_sig[3]={'V','y','X'};
uint16_t vyx_ver=VY_COMMON_VERSIONS_VYX;
string outfile=this->output_file;
size_t payload_count=this->payloads.size();
auto payloads=generate_payloads(this->payloads);
ofstream out(outfile,ios::binary);
out.write(reinterpret_cast<char*>(vyx_sig),3);
out.write(reinterpret_cast<char*>(&vyx_ver),2);
out.write(reinterpret_cast<char*>(&va.text_offset),8);
out.write(reinterpret_cast<char*>(&va.stack_base),8);
out.write(reinterpret_cast<char*>(&text_size_padded),8);
out.write(reinterpret_cast<char*>(&data_size_padded),8);
out.write(reinterpret_cast<char*>(&rodata_size_padded),8);
uint64_t bss_size_elf=elf_bss_sec->get_size();
out.write(reinterpret_cast<char*>(&bss_size_elf),8);
out.write(reinterpret_cast<char*>(&payload_count),8);
out.write(reinterpret_cast<char*>(elf_text_bin.data()),elf_text_bin.size());
if (data_size_padded!=0) out.write(reinterpret_cast<char*>(elf_data_bin.data()),elf_data_bin.size());
if (rodata_size_padded!=0) out.write(reinterpret_cast<char*>(elf_rodata_bin.data()),elf_rodata_bin.size());
if (payload_count!=0) {
out.write(reinterpret_cast<char*>(payloads.data()),payloads.size());
}
out.close();
fs::remove_all(build_path);
return vybuild::actions::ActionStatus::Success;
}
View Git Blame Copy Permalink