{

FILE *out; // JSON RPC output.

pid_t pid; // Backend process ID.

{

intptr_t lo;

intptr_t hi;

{

intptr_t lo;

intptr_t hi;

intptr_t addr;

const char *section;

uint8_t byte;

const std::vector<const char *> &options, Backend &backend)

{

int fds[2];

if (pipe(fds) != 0)

error("failed to open pipe to backend process: %s", strerror(errno));

pid_t pid = fork();

if (pid == 0)

{

close(fds[1]);

if (dup2(fds[0], STDIN_FILENO) < 0)

error("failed to dup backend process pipe file descriptor "

"(%d): %s", fds[0], strerror(errno));

close(fds[0]);

const char *argv[options.size() + 2];

prog = findBinary(prog, /*exe=*/true, /*dot=*/true);

argv[0] = "e9patch";

unsigned i = 1;

for (const char *option: options)

argv[i++] = option;

argv[i] = nullptr;

execvp(prog, (char * const *)argv);

error("failed to execute backend process \"%s\": %s", argv[0],

strerror(errno));

}

else if (pid < 0)

error("failed to fork backend process: %s", strerror(errno));

close(fds[0]);

FILE *out = fdopen(fds[1], "w");

if (out == nullptr)

error("failed to open backend process stream: %s", strerror(errno));

backend.out = out;

backend.pid = pid;

{

fclose(backend.out);

if (backend.pid == 0)

return;

int status;

do

{

if (waitpid(backend.pid, &status, WUNTRACED | WCONTINUED) < 0)

error("failed to wait for backend process (%d): %s",

backend.pid, strerror(errno));

}

while (!WIFEXITED(status) && !WIFSIGNALED(status));

if (WIFEXITED(status) && WEXITSTATUS(status) != 0)

error("backend process (%d) exitted with a non-zero status (%d)",

backend.pid, WEXITSTATUS(status));

else if (WIFSIGNALED(status))

error("backend process (%d) killed by signal (%s)", backend.pid,

strsignal(WTERMSIG(status)));

const std::vector<Instr> &Is, Event event)

{

for (auto i: plugins)

{

Plugin *plugin = i.second;

if (plugin->eventFunc == nullptr)

continue;

Context cxt = {API_VERSION, STRING(VERSION), out, &plugin->argv,

plugin->context, elf, &Is, -1, nullptr, -1};

plugin->eventFunc(&cxt, event);

}

const std::vector<Instr> &Is, size_t idx, const InstrInfo *I)

{

for (auto i: plugins)

{

Plugin *plugin = i.second;

if (plugin->matchFunc == nullptr)

continue;

Context cxt = {API_VERSION, STRING(VERSION), out, &plugin->argv,

plugin->context, elf, &Is, (ssize_t)idx, I, -1};

plugin->result = plugin->matchFunc(&cxt);

}

{

for (auto i: plugins)

{

Plugin *plugin = i.second;

if (plugin->initFunc == nullptr)

continue;

Context cxt = {API_VERSION, STRING(VERSION), out, &plugin->argv,

nullptr, elf, nullptr, -1, nullptr, -1};

plugin->context = plugin->initFunc(&cxt);

}

{

for (auto i: plugins)

{

Plugin *plugin = i.second;

if (plugin->finiFunc == nullptr)

continue;

Context cxt = {API_VERSION, STRING(VERSION), out, &plugin->argv,

plugin->context, elf, nullptr, -1, nullptr, -1};

plugin->finiFunc(&cxt);

}

const ELF &elf)

{

Exclude bound = {INTPTR_MAX, INTPTR_MIN};

int t = parser.getToken();

bool neg = false;

switch (t)

{

case '-':

neg = true;

// Fallthrough:

case '+':

parser.expectToken(TOKEN_INTEGER);

// Fallthrough:

case TOKEN_INTEGER:

{

intptr_t b = (neg? -parser.i: parser.i);

bound = {b, b};

break;

}

case '&':

t = parser.getToken();

// Fallthrough:

default:

{

std::string name;

if (t == '.')

{

t = parser.getToken();

name += '.';

}

if (t != TOKEN_STRING && t != TOKEN_NAME)

parser.unexpectedToken();

name += parser.s;

const Elf64_Shdr *shdr = getELFSection(&elf, name.c_str());

if (shdr != nullptr)

{

bound = {elf.base + (intptr_t)shdr->sh_addr,

elf.base + (intptr_t)shdr->sh_addr +

(intptr_t)shdr->sh_size};

break;

}

const Elf64_Sym *sym = getELFDynSym(&elf, name.c_str());

if (sym == nullptr)

sym = getELFSym(&elf, name.c_str());

if (sym != nullptr && sym->st_shndx != SHN_UNDEF)

{

bound = {elf.base + (intptr_t)sym->st_value,

elf.base + (intptr_t)sym->st_value};

break;

}

intptr_t val = getELFPLTEntry(&elf, name.c_str());

if (val != INTPTR_MIN)

{

bound = {val, val};

break;

}

warning("ignoring exclusion \"%s\"; no such symbol or "

"section \"%s\" in \"%s\"", str, name.c_str(), elf.filename);

return bound;

}

}

if (parser.peekToken() == '.')

{

parser.getToken();

switch (parser.getToken())

{

case TOKEN_START:

bound.hi = bound.lo;

break;

case TOKEN_END:

bound.lo = bound.hi;

break;

default:

parser.unexpectedToken();

}

}

neg = false;

intptr_t offset = 0;

switch (parser.peekToken())

{

case '-':

neg = true;

// Fallthrough

case '+':

parser.getToken();

parser.expectToken(TOKEN_INTEGER);

offset = parser.i;

if (offset < INT32_MIN || offset > INT32_MAX)

error("failed to parse exclusion \"%s\"; offset %ld is "

"out-of-range %zd..%zd", str, offset, INT32_MIN,

INT32_MAX);

offset = (neg? -offset: offset);

bound.lo += offset;

bound.hi += offset;

break;

default:

break;

}

return bound;

{

Parser parser(str, "exclusion", elf);

Exclude lb = parseExcludeBound(parser, str, elf);

if (lb.lo == INTPTR_MAX && lb.hi == INTPTR_MIN)

return lb;

Exclude ub = lb;

if (parser.peekToken() == TOKEN_DOTDOT)

{

parser.getToken();

ub = parseExcludeBound(parser, str, elf);

if (ub.lo == INTPTR_MAX && lb.hi == INTPTR_MIN)

return ub;

}

parser.expectToken(TOKEN_EOF);

Exclude exclude = {std::min(lb.lo, ub.hi), std::max(lb.lo, ub.hi)};

if (exclude.lo == exclude.hi)

warning("ignoring empty exclusion \"%s\" (0x%lx..0x%lx)",

str, exclude.lo, exclude.hi);

else

debug("excluding \"%s\" (0x%lx..0x%lx)", str, exclude.lo, exclude.hi);

return exclude;

{

std::vector<Action *> actions;

Matching(std::vector<Action *> &&actions) : actions(std::move(actions))

{

;

}

{

bool operator()(const Matching *m1, const Matching *m2)

{

for (size_t i = 0; ; i++)

{

if (i >= m1->actions.size())

return (i < m2->actions.size());

else if (i >= m2->actions.size())

return false;

if (m1->actions[i] < m2->actions[i])

return true;

if (m1->actions[i] > m2->actions[i])

return false;

}

}

{

std::map<const Matching *, size_t, MatchingCmp> cache;

std::vector<const Matching *> matchings;

const std::vector<Instr> &Is, size_t idx, const InstrInfo *I,

std::vector<Action *> &matching)

{

for (auto *action: actions)

{

if (!matchEval(action->match, elf, Is, idx, I))

continue;

matching.push_back(action);

}

MatchingCache &Ms)

{

// Check for existing:

Matching M(std::move(matching));

auto i = Ms.cache.find(&M);

if (i != Ms.cache.end())

return i->second;

// Check if valid (at most one replace):

bool seen_replace = false, seen_break = false;

for (const auto *action: matching)

for (const auto *patch: action->patch)

seen_break = seen_break ||

(patch->kind == PATCH_BREAK && patch->pos == POS_BEFORE);

for (const auto *action: matching)

{

for (const auto *patch: action->patch)

{

if (patch->pos != POS_REPLACE)

continue;

if (seen_replace && !seen_break)

error("multiple matching \"replace\" trampolines detected "

"for instruction \"%s\" at address 0x%lx", I->string.instr,

I->address);

seen_replace = true;

seen_break = seen_break || (patch->kind == PATCH_BREAK);

}

}

// Add to cache:

size_t idx = Ms.matchings.size();

Matching *N = new Matching(std::move(M.actions));

Ms.cache.insert({N, idx});

Ms.matchings.push_back(N);

return idx;

{

if (excludes.size() == 0)

return 0;

ssize_t lo = 0, hi = (ssize_t)excludes.size()-1;

while (lo <= hi)

{

ssize_t mid = (lo + hi) / 2;

const Exclude &exclude = excludes[mid];

if (addr < exclude.lo)

hi = mid-1;

else if (addr > exclude.hi)

lo = mid+1;

else

return exclude.hi - addr;

}

return 0;

{

ssize_t max = (ssize_t)disasm.size() - 1;

if (disasm.size() == 0 || addr > disasm[max])

return INT32_MAX;

ssize_t lo = 0, hi = max;

while (lo <= hi)

{

ssize_t mid = (lo + hi) / 2;

intptr_t i = disasm[mid];

if (addr < i)

hi = mid-1;

else if (addr > i)

lo = mid+1;

else

return 0;

}

return disasm[lo] - addr;

{

const Action * const action;

size_t idx;

Context *cxt, std::vector<Metadata> &metadata)

{

const Patch *patch = action->patch[idx];

const Plugin *plugin = nullptr;

if (patch->kind == PATCH_PLUGIN)

{

plugin = patch->plugin;

if (plugin->codeFunc != nullptr)

{

cxt->argv = &plugin->argv;

cxt->context = plugin->context;

plugin->codeFunc(cxt);

}

}

else

{

sendString(out, patch->name);

sendSeparator(out);

if (patch->kind == PATCH_BREAK)

return true;

}

bool found = false;

switch (patch->kind)

{

case PATCH_PLUGIN:

plugin = patch->plugin;

if (plugin->patchFunc == nullptr)

break;

// Fallthrough

case PATCH_PRINT: case PATCH_CALL:

for (const auto &entry: metadata)

{

const Patch *prev = entry.action->patch[entry.idx];

if (strcmp(prev->name, patch->name) == 0)

{

found = true;

break;

}

}

if (found)

break;

metadata.push_back({action, idx});

break;

default:

break;

}

return false;

{

OPTION_100,

OPTION_BACKEND,

OPTION_CFR,

OPTION_COMPRESSION,

OPTION_DSYNC,

OPTION_DTHRESHOLD,

OPTION_DEBUG,

OPTION_DUMP_ALL,

OPTION_EXCLUDE,

OPTION_EXECUTABLE,

OPTION_FORMAT,

OPTION_HELP,

OPTION_MATCH,

OPTION_NO_WARNINGS,

OPTION_PATCH,

OPTION_PLT,

OPTION_PLUGIN,

OPTION_OPTION,

OPTION_OUTPUT,

OPTION_SEED,

OPTION_SHARED,

OPTION_STATIC_LOADER,

OPTION_SYNTAX,

OPTION_TRAP,

OPTION_TRAP_ALL,

OPTION_USE_DISASM,

OPTION_USE_TARGETS,

OPTION_VERSION,

{

std::vector<std::string> match;

std::vector<std::string> patch;

intptr_t lb, intptr_t ub)

{

const char *optarg_0 = optarg;

bool neg = (optarg[0] == '-');

if (neg)

optarg++;

int base = 10;

if (optarg[0] == '0' && optarg[1] == 'x')

base = 16;

errno = 0;

char *end = nullptr;

intptr_t r = (intptr_t)strtoul(optarg, &end, base);

r = (neg? -r: r);

if (errno != 0 || end == optarg ||

(end != nullptr && *end != '\0') || r < lb || r > ub)

{

error("failed to parse argument \"%s\" for the `%s' option; "

"expected a number within the range %zd..%zd", option,

optarg_0, lb, ub);

}

return r;

{

/*

(void)atexit(flushWarnings);

const int req_arg = required_argument, /*opt_arg = optional_argument,*/

no_arg = no_argument;

static const struct option long_options[] =

{

{"100", no_arg, nullptr, OPTION_100},

{"backend", req_arg, nullptr, OPTION_BACKEND},

{"CFR", no_arg, nullptr, OPTION_CFR},

{"compression", req_arg, nullptr, OPTION_COMPRESSION},

{"Dsync", req_arg, nullptr, OPTION_DSYNC},

{"Dthreshold", req_arg, nullptr, OPTION_DTHRESHOLD},

{"debug", no_arg, nullptr, OPTION_DEBUG},

{"dump-all", no_arg, nullptr, OPTION_DUMP_ALL},

{"exclude", req_arg, nullptr, OPTION_EXCLUDE},

{"executable", no_arg, nullptr, OPTION_EXECUTABLE},

{"format", req_arg, nullptr, OPTION_FORMAT},

{"help", no_arg, nullptr, OPTION_HELP},

{"match", req_arg, nullptr, OPTION_MATCH},

{"no-warnings", no_arg, nullptr, OPTION_NO_WARNINGS},

{"patch", req_arg, nullptr, OPTION_PATCH},

{"plt", no_arg, nullptr, OPTION_PLT},

{"plugin", req_arg, nullptr, OPTION_PLUGIN},

{"option", req_arg, nullptr, OPTION_OPTION},

{"output", req_arg, nullptr, OPTION_OUTPUT},

{"seed", req_arg, nullptr, OPTION_SEED},

{"shared", no_arg, nullptr, OPTION_SHARED},

{"static-loader", no_arg, nullptr, OPTION_STATIC_LOADER},

{"syntax", req_arg, nullptr, OPTION_SYNTAX},

{"trap", req_arg, nullptr, OPTION_TRAP},

{"trap-all", no_arg, nullptr, OPTION_TRAP_ALL},

{"use-disasm", req_arg, nullptr, OPTION_USE_DISASM},

{"use-targets", req_arg, nullptr, OPTION_USE_TARGETS},

{"version", no_arg, nullptr, OPTION_VERSION},

{nullptr, no_arg, nullptr, 0}

};

option_is_tty = isatty(STDERR_FILENO);

std::vector<const char *> option_options;

unsigned option_compression_level = 9;

bool option_plt = false;

char option_optimization_level = '2';

bool option_executable = false, option_shared = false,

option_static_loader = false;

std::string option_backend("");

std::set<intptr_t> option_trap;

std::vector<std::string> option_match;

std::vector<std::string> option_patch;

std::vector<ActionEntry> option_actions;

std::vector<std::string> option_exclude;

std::string option_use_disasm("");

std::string option_use_targets("");

std::string option_use_funcs("");

bool option_dump_all = false;

int option_sync = 64, option_threshold = 2;

bool option_100 = false, option_CFR = false;

srand(0xe9e9e9e9);

while (true)

{

int idx;

int opt = getopt_long_only(argc, argv, "A:c:E:hM:o:O:P:sX",

long_options, &idx);

if (opt < 0)

break;

switch (opt)

{

case OPTION_100:

option_100 = true;

break;

case OPTION_BACKEND:

option_backend = optarg;

break;

case OPTION_CFR:

case 'X':

option_CFR = true;

break;

case OPTION_COMPRESSION:

case 'c':

option_compression_level = (unsigned)parseIntOptArg(

"--compression/-c", optarg, 0, 9);

break;

case OPTION_DSYNC:

option_sync = (int)parseIntOptArg("--Dsync", optarg,

0, UINT16_MAX);

break;

case OPTION_DTHRESHOLD:

option_threshold = (int)parseIntOptArg("--Dthreshold", optarg,

0, 10);

break;

case OPTION_DEBUG:

option_debug = true;

break;

case OPTION_DUMP_ALL:

option_targets = option_bbs = option_fs =

option_dump_all = true;

break;

case OPTION_EXCLUDE:

case 'E':

option_exclude.push_back(optarg);

break;

case OPTION_EXECUTABLE:

option_executable = true;

break;

case OPTION_FORMAT:

option_format = optarg;

if (option_format != "binary" &&

option_format != "json" &&

option_format != "patch" &&

option_format != "patch.gz" &&

option_format != "patch.bz2" &&

option_format != "patch.xz")

error("bad value \"%s\" for `--format' option; "

"expected one of \"binary\", \"json\", \"patch\", "

"\"patch.gz\", \"patch.bz2\", or \"patch.xz\"",

optarg);

break;

case OPTION_HELP:

case 'h':

usage(stdout, argv[0]);

return EXIT_SUCCESS;

case OPTION_OPTION:

option_options.push_back(optarg);

break;

case OPTION_MATCH:

case 'M':

{

if (option_patch.size() > 0)

{

ActionEntry entry;

entry.match.swap(option_match);

entry.patch.swap(option_patch);

option_actions.emplace_back(entry);

}

std::string match(optarg);

option_match.emplace_back(match);

break;

}

case OPTION_PATCH:

case 'P':

{

if (option_match.size() == 0)

error("failed to parse command-line arguments; "

"the `--patch'/`-P' option must be preceded by "

"one or more `--match'/`-M' options");

std::string patch(optarg);

option_patch.emplace_back(patch);

break;

}

case OPTION_PLT:

option_plt = true;

break;

case OPTION_PLUGIN:

{

size_t i;

for (i = 0; optarg[i] != '\0' && optarg[i] != ':'; i++)

;

if (optarg[i] != ':')

error("bad value \"%s\" for `--plugin'; "

"expected a plugin:option pair", optarg);

char *key = strDup(optarg, i);

char *val = strDup(optarg+i+1);

option_plugin.push_back({key, val});

break;

}

case OPTION_OUTPUT:

case 'o':

option_output = optarg;

break;

case 'O':

option_optimization_level = -1;

switch (optarg[0])

{

case '0': case '1': case '2': case '3': case 's':

option_optimization_level = optarg[0];

break;

}

if (option_optimization_level < 0 || optarg[1] != '\0')

error("bad value \"%s\" for `-O' option; "

"expected one of -O0,-O1,-O2,-O3,-Os", optarg);

break;

case OPTION_NO_WARNINGS:

option_no_warnings = true;

break;

case OPTION_SEED:

{

unsigned long r = (unsigned long)parseIntOptArg("--seed",

optarg, 0, RAND_MAX);

if (r == 0)

syscall(/*SYS_getrandom=*/318, &r, sizeof(unsigned), 0);

srand((unsigned)r);

break;

}

case OPTION_SHARED:

option_shared = true;

break;

case OPTION_STATIC_LOADER:

case 's':

option_static_loader = true;

break;

case OPTION_SYNTAX:

if (strcmp(optarg, "ATT") == 0)

option_intel_syntax = false;

else if (strcmp(optarg, "intel") == 0)

option_intel_syntax = true;

else

error("bad value \"%s\" for `--syntax' option; "

"expected \"ATT\" or \"intel\"", optarg);

break;

case OPTION_TRAP:

{

errno = 0;

char *end = nullptr;

unsigned long r = strtoul(optarg, &end, 0);

if (errno != 0 || end == optarg ||

(end != nullptr && *end != '\0') || r > INTPTR_MAX)

error("bad value \"%s\" for `--trap' option; "

"expected an address", optarg);

option_trap.insert(r);

break;

}

case OPTION_TRAP_ALL:

option_trap_all = true;

break;

case OPTION_USE_DISASM:

option_use_disasm = optarg;

break;

case OPTION_USE_TARGETS:

option_use_targets = optarg;

break;

case OPTION_VERSION:

puts("E9Tool " STRING(VERSION));

return EXIT_SUCCESS;

default:

error("failed to parse command-line options; try `--help' "

"for more information");

return EXIT_FAILURE;

}

}

if (optind != argc-1)

{

error("missing input file; try `--help' for more information");

return EXIT_FAILURE;

}

if (option_match.size() > 0)

{

if (option_patch.size() == 0)

error("failed to parse command-line arguments; the `--match'/`-M' "

"option must be followed by one or more `--patch'/`-P' "

"options");

ActionEntry entry;

entry.match.swap(option_match);

entry.patch.swap(option_patch);

option_actions.emplace_back(entry);

}

if (option_actions.size() > MAX_ACTIONS)

error("failed to parse command-line arguments; the total number of "

"match/patch pairs (%zu) exceeds the maximum (%zu)",

option_actions.size(), MAX_ACTIONS);

if (option_shared && option_executable)

error("failed to parse command-line arguments; both the `--shared' "

"and `--executable' options cannot be used at the same time");

/*

const char *filename = argv[optind];

bool exe = (option_executable? true:

(option_shared? false: !isLibraryFilename(filename)));

filename = findBinary(filename, exe, /*dot=*/true);

ELF &elf = *parseBinary(filename);

/*

std::vector<Action *> actions;

for (const auto &entry: option_actions)

{

if (entry.match.size() == 0)

error("failed to parse action; the `--action' or `-A' option "

"must be preceded by one or more `--match' or `-M' options");

MatchExpr *match = nullptr;

for (const auto &str: entry.match)

{

MatchExpr *expr = parseMatch(elf, str.c_str());

match = (match == nullptr? expr:

new MatchExpr(MATCH_OP_AND, match, expr));

}

std::vector<const Patch *> patch;

for (const auto &str: entry.patch)

{

const Patch *P = parsePatch(elf, str.c_str());

patch.push_back(P);

if (P->kind == PATCH_BREAK)

break;

}

Action *action = new Action(match, std::move(patch));

actions.push_back(action);

}

option_actions.clear();

for (auto &entry: option_plugin)

{

if (entry.first != nullptr)