mirror of
https://github.com/RPCS3/rpcs3
synced 2024-09-05 07:56:33 +00:00
![Nekotekina](/assets/img/avatar_default.png)
Improve JIT profiling dump format (data + name, mmap) Improve objdump interception util (better speed, fix bugs) Rename spu_ubertrampoline to __ub+number
212 lines
4.2 KiB
C++
212 lines
4.2 KiB
C++
// objdump injection utility for Linux perf tools.
|
|
// Profiling JIT generated code is always problematic.
|
|
// On Linux, perf annotation tools do not automatically
|
|
// disassemble runtime-generated code.
|
|
// However, it's possible to override objdump utility
|
|
// which is used to disassemeble executables.
|
|
// This tool intercepts objdump commands, and if they
|
|
// correspond to JIT generated objects in RPCS3,
|
|
// it should be able to correctly disassemble them.
|
|
// Usage:
|
|
// 1. Make sure ~/.cache/rpcs3/ASMJIT directory exists.
|
|
// 2. Build this utility, for example:
|
|
// g++-11 objdump.cpp -o objdump
|
|
// 3. Run perf, for example:
|
|
// perf record -b -p `pgrep rpcs3`
|
|
// 4. Specify --objdump override, for example:
|
|
// perf report --objdump=./objdump --gtk
|
|
|
|
#include <cstring>
|
|
#include <cstdio>
|
|
#include <cstdint>
|
|
#include <unistd.h>
|
|
#include <sys/file.h>
|
|
#include <sys/mman.h>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <charconv>
|
|
|
|
std::string to_hex(std::uint64_t value, bool prfx = true)
|
|
{
|
|
char buf[20]{}, *ptr = buf + 19;
|
|
do *--ptr = "0123456789abcdef"[value % 16], value /= 16; while (value);
|
|
if (!prfx) return ptr;
|
|
*--ptr = 'x';
|
|
*--ptr = '0';
|
|
return ptr;
|
|
}
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
std::string home;
|
|
|
|
if (const char* d = ::getenv("XDG_CACHE_HOME"))
|
|
home = d;
|
|
else if (const char* d = ::getenv("XDG_CONFIG_HOME"))
|
|
home = d;
|
|
else if (const char* d = ::getenv("HOME"))
|
|
home = d, home += "/.cache";
|
|
|
|
// Get cache path
|
|
home += "/rpcs3/ASMJIT/";
|
|
|
|
// Get objects
|
|
int fd = open((home + ".objects").c_str(), O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
return 1;
|
|
|
|
// Map 4GiB (full size)
|
|
const auto data = mmap(nullptr, 0x10000'0000, PROT_READ, MAP_SHARED, fd, 0);
|
|
|
|
struct entry
|
|
{
|
|
std::uint64_t addr;
|
|
std::uint32_t size;
|
|
std::uint32_t off;
|
|
};
|
|
|
|
// Index part (precedes actual data)
|
|
const auto index = static_cast<const entry*>(data);
|
|
|
|
const entry* found = nullptr;
|
|
|
|
std::string out_file;
|
|
|
|
std::vector<std::string> args;
|
|
|
|
for (int i = 0; i < argc; i++)
|
|
{
|
|
// Replace args
|
|
std::string arg = argv[i];
|
|
|
|
if (std::uintptr_t(data) != -1 && arg.find("--start-address=0x") == 0)
|
|
{
|
|
// Decode address and try to find the object
|
|
std::uint64_t addr = -1;
|
|
|
|
std::from_chars(arg.data() + strlen("--start-address=0x"), arg.data() + arg.size(), addr, 16);
|
|
|
|
for (int j = 0; j < 0x100'0000; j++)
|
|
{
|
|
if (index[j].addr == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (index[j].addr == addr)
|
|
{
|
|
found = index + j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
// Extract object into a new file (read file name from the mapped memory)
|
|
const char* name = static_cast<char*>(data) + found->off + found->size;
|
|
|
|
if (name[0])
|
|
{
|
|
out_file = home + name;
|
|
}
|
|
else
|
|
{
|
|
out_file = "/tmp/rpcs3.objdump." + std::to_string(getpid());
|
|
unlink(out_file.c_str());
|
|
}
|
|
|
|
const int fd2 = open(out_file.c_str(), O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
|
|
|
|
if (fd2 > 0)
|
|
{
|
|
// Don't overwrite if exists
|
|
write(fd2, static_cast<char*>(data) + found->off, found->size);
|
|
close(fd2);
|
|
}
|
|
|
|
args.emplace_back("--adjust-vma=" + to_hex(addr));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (found && arg.find("--stop-address=0x") == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (found && arg == "-d")
|
|
{
|
|
arg = "-D";
|
|
}
|
|
|
|
if (arg == "-l")
|
|
{
|
|
arg = "-Mintel,x86-64";
|
|
}
|
|
|
|
args.emplace_back(std::move(arg));
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
args.pop_back();
|
|
args.emplace_back("-b");
|
|
args.emplace_back("binary");
|
|
args.emplace_back("-m");
|
|
args.emplace_back("i386:x86-64");
|
|
args.emplace_back(std::move(out_file));
|
|
}
|
|
|
|
args[0] = "/usr/bin/objdump";
|
|
|
|
std::vector<char*> new_argv;
|
|
|
|
for (auto& arg : args)
|
|
{
|
|
new_argv.push_back(arg.data());
|
|
}
|
|
|
|
new_argv.push_back(nullptr);
|
|
|
|
if (found)
|
|
{
|
|
int fds[2];
|
|
pipe(fds);
|
|
|
|
if (fork() > 0)
|
|
{
|
|
close(fds[1]);
|
|
char c = 0;
|
|
std::string buf;
|
|
|
|
while (read(fds[0], &c, 1) != 0)
|
|
{
|
|
if (c)
|
|
{
|
|
buf += c;
|
|
|
|
if (c == '\n')
|
|
{
|
|
write(STDOUT_FILENO, buf.data(), buf.size());
|
|
buf.clear();
|
|
}
|
|
}
|
|
|
|
c = 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
while ((dup2(fds[1], STDOUT_FILENO) == -1) && (errno == EINTR)) {}
|
|
close(fds[1]);
|
|
close(fds[0]);
|
|
// Fallthrough
|
|
}
|
|
}
|
|
|
|
return execv(new_argv[0], new_argv.data());
|
|
}
|