Starting December 1, 2026, I will join Leiden University’s Leiden Institute of Advanced Computer Science (LIACS) as a postdoctoral researcher.
I am a post-doctoral researcher with the Department of Computer, Control and Management Engineering (DIAG) “Antonio Ruberti” at Sapienza University of Rome. I am currently working with the research group of my advisor Prof. Leonardo Querzoni and my co-advisor Dr. Daniele Cono D’Elia.
My research interests span several aspects of compilers, software security, and systems security. My current focus is debug information quality and profile-guided optimizations. I work on evaluating debug information quality, how compiler optimizations affect it, and how its incompleteness can affect downstream tools. As part of a collaboration with Google, I also work on improving the effectiveness of profile-guided optimizations. I am passionate about compiler optimizations, program analysis techniques, operating systems, and micro-architectural attacks.
I obtained my M.Sc. degree (summa cum laude) with a thesis about the completeness of debug symbols in optimizing compilers, and my B.Sc. degree (summa cum laude) with a thesis about a micro-architectural approach to malware evasion techniques (winner of the CLUSIT prize for the most innovative cybersecurity thesis, 2019).
From 2020 to 2023, I was among the organizers and training coordinators for the CyberChallenge.IT introductory cybersecurity program at Sapienza University of Rome. During the course I gave practical and theoretical lectures on cryptography, reverse engineering, binary exploitation, and micro-architectural attacks. In 2023, the Sapienza team reached first place at the national finals in Turin, Italy.
I am a CTF player, mainly involved in reverse engineering, with the Sapienza team (TRX) and mhackeroni (six-time DEFCON finalist and winner of Hack-A-Sat4).
No publications match these filters.
CORE26 rank: A
Compiler optimizations may lead to loss of debug information, hampering developer productivity and techniques that rely on binary-to-source mappings, such as sampling-based feedback-directed optimization. While recent endeavors exposed debug information correctness and completeness bugs in compiler transformations, understanding where a complex optimizing pipeline loses debug information is an understudied problem.
In this paper, we first rectify accuracy issues in methods for measuring the availability of debug information, and show that the synthetic programs evaluated so far lead to metric values that differ from those we observe for real-world programs. Building on this, we present DebugTuner, a framework for systematically analyzing the impact of individual compiler optimization passes on debug information, and assemble a test suite of programs for collecting more realistic metrics. Using DebugTuner and the test suite, we identify transformations in gcc and clang that cause more debug information loss, and construct modified optimization levels that improve debuggability while retaining competitive performance. We obtain levels that outperform gcc’s Og for both debuggability and performance, and make recommendations for constructing an Og level for clang. Finally, we present a case study on AutoFDO where, by disabling selected passes in the profiling stage, the final optimized binary is more performant due to the improved quality of the binary-to-source mapping.
CORE26 rank: B
Monitoring how a program utilizes userland APIs is behind much dependability and security research. To intercept and study their invocations, the established practice targets the prologue of API implementations for inserting hooks.
This paper questions the validity of this design for security uses by examining completeness and correctness attacks to it. We first show how evasions that jump across the hook instrumentation are practical and can reach places much deeper than those we currently find in executables in the wild. Next, we propose and demonstrate TOCTTOU attacks that lead monitoring systems to observe false indicators for the argument values that a program uses for API calls.
To mitigate both threats, we design a static analysis to identify vantage points for effective hook placement in API code, supporting both reliable call recording and accurate argument extraction. We use this analysis to implement an open-source prototype API monitor, Toxotidae, that we evaluate against adversarial and benign executables for Windows.
CORE26 rank: A*
The availability of debug information for optimized executables can largely ease crucial tasks such as crash analysis. Source-level debuggers use this information to display program state in terms of source code, allowing users to reason on it even when optimizations alter program structure extensively. A few recent endeavors have proposed effective methodologies for identifying incorrect instances of debug information, which can mislead users by presenting them with an inconsistent program state.
In this work, we identify and study a related important problem: the completeness of debug information. Unlike correctness issues for which an unoptimized executable can serve as reference, we find there is no analogous oracle to deem when the cause behind an unreported part of program state is an unavoidable effect of optimization or a compiler implementation defect. In this scenario, we argue that empirically derived conjectures on the expected availability of debug information can serve as an effective means to expose classes of these defects.
We propose three conjectures involving variable values and study how often synthetic programs compiled with different configurations of the popular gcc and LLVM compilers deviate from them. We then discuss techniques to pinpoint the optimizations behind such violations and minimize bug reports accordingly. Our experiments revealed, among others, 24 bugs already confirmed by the developers of the gcc-gdb and clang-lldb ecosystems.
2026
2023
2024