WorksComputer Science
PIMROP: A Feasibility Study of Return-Oriented Programming on Commercial Processing-in-Memory Architectures
Abstract
Processing-in-Memory places small programmable cores on the memory device, where they execute beside the DRAM banks and beyond the control-flow defenses that protect host programs. The security of this in-memory code is an attack surface that remains largely unstudied. We present PIMROP, to our knowledge the first demonstrated code-reuse attack on a commercial Processing in-Memory ISA. We show that return-oriented programming is feasible on a real, commercially shipped PIM instruction set, the UPMEM DPU, whose DRAM Processing Units run C compiled by a dedicated LLVM toolchain. We build Galileo-for-DPU, a gadget scanner adapted to the DPU's fixed-width, 8-byte-aligned RISC encoding, and run it entirely on the UPMEM functional simulator in a reproducible Docker and VM environment. We find the runtime library that every kernel links already yields 517 non-trivial gadgets covering all five canonical ROP primitive classes, and all 13 PrIM benchmarks we scanned carry gadgets as well. We then demonstrate two verified end-to-end attacks, each reproducible on 10 of 10 runs. In the first, a stack buffer overflow in a DPU kernel overwrites the saved return address and diverts control into a routine that copies a secret into host-readable memory. In the second, we leak the same secret using a chain of reused gadgets alone, without diverting control into any such routine. We further show that two standard defenses–stack canaries and _FORTIFY_SOURCE-style bounds-check fortification–fail on the DPU in ways specific to the platform (misplaced canary, silently inactive wrapper), and we verify a bounds-checked DMA that stops the attack on 10 of 10 runs with no effect on benign requests. To enable further research on PIM security, we open-source Galileo-for-DPU and our testing harness at https://github.com/wtegge2/ROP-in-PIM.
Introduction
For decades the cost of moving data between memory and the processor has grown faster than the cost of computing on it. For today’s memory-bound workloads, data movement dominates both time and energy [1]. Processing-in-Memory (PIM) attacks this problem directly by placing computation in or near the memory devices [1], [2], [3], [4]. The UPMEM DPU is the first commercially available, general-purpose PIM product [5], pairing each DRAM chip with programmable in-order cores (DRAM Processing Units) that run ordinary C compiled by a dedicated LLVM toolchain. A programmable processor now lives inside the memory module and with it, a new and largely unexamined attack surface.
Proposed control-flow defenses such as /DEP, address-space layout randomization (ASLR), stack canaries, Intel CET, and ARM pointer authentication harden code running on the host CPU. None of them says anything about code executing on the DPU which runs on a different processor, with a different ISA, on the far side of the memory bus. PIM-security research so far has examined side and covert channels [6], RowHammer-style bit flips [7], and confidentiality of data offloaded to untrusted memory [8], and a recent threat-landscape survey [9] explicitly identifies code-reuse against programmable NDP cores as an open concern, but the integrity of control flow on the in-memory processor itself remains un-demonstrated.
We ask the question Shacham [10] first posed for the x86 and Buchanan et al. [11] extended to RISC, now for a real PIM ISA: does a commercially deployed Processing-in-Memory processor contain enough reusable instruction fragments to mount return-oriented programming (ROP) attacks, on a target where none of the host’s control-flow defenses apply? We focus on ROP because it is what we demonstrate end-to-end; its stackless cousin, jump-oriented programming (JOP) [12], appears here only as the indirect-jump terminators our scanner catalogs and a dispatcher we leave to future work. Because the DPU ISA is fixed-width and 8-byte aligned, we use the Buchanan RISC setting, in which gadgets are intended instruction suffixes of real functions. This method leaves out the extra “hidden” gadgets Shacham obtains on the x86 by decoding the same bytes at misaligned offsets, which the DPU’s alignment rules cut out. We develop this distinction further in Section II-D. We also make two exploitation observations specific to the DPU 1) the saved return is stored as an instruction index rather than a byte address, and 2) standard stack canaries are bypassed in two independent ways on the DPU: misplaced by the toolchain, and replayable by the attacker even when correctly placed. We show that a bounds-checked DMA helps mitigate our attack.
We present PIMROP, to our knowledge the first demonstrated code-reuse (ROP) attack on a commercial Processing-in-Memory ISA. Our contributions are as follows:
We build Galileo-for-DPU, a gadget scanner for the UPMEM DPU that recovers the calling convention and indirect-branch terminators from real
llvm-objdumpdisassembly and enumerates gadgets under the DPU’s fixed-width, 8-byte-aligned RISC encoding which is the Buchanan
RISC setting of intended instruction suffixes, not Shacham’s x86 misaligned-decoding trick.
We show that Shacham’s feasibility thesis [10] holds on real DPU code. In the runtime library alone we discover 317 indirect-branch terminators and 517 non-trivial gadgets covering all five canonical ROP primitive classes, and we find gadgets in every one of 13 PrIM benchmarks [5].
We demonstrate two verified end-to-end attacks on the functional simulator against an intentionally vulnerable DPU kernel. The first hijacks the saved return and diverts control into a routine that copies a secret into host-readable memory. The second leaks the same secret using a chain of reused library gadgets alone, without diverting control into any such routine.
We demonstrate the two reused control-flow primitives required for Turing-complete computation from a code-reuse chain on the DPU: a conditional branch with a runtime-chosen target and a loop with a runtime-chosen iteration count, each measured as deterministic across input variations and built from the already-linked runtime library alone.
We present a defense-gap analysis with a measured mitigation study. The DPU side has no ASLR and no CFI or pointer authentication, and stack canaries are ineffective in two independent ways: the toolchain places the slot on the wrong side of the frame on this upward-growing stack, and even a correctly-placed canary is bypassed 10 of 10 by a sink-free chain that preserves the DPU’s fixed, host-unseeded guard value. We then verify a bounds-checked DMA that does stop the attack and identify the code change needed to make canaries effective.
Background and Motivation
Processing-in-Memory and the UPMEM DPU
Processing-in-Memory places compute logic in or near the memory arrays so that operations run where the data already lives, avoiding the energy and latency of sending it across the memory bus [1]. The UPMEM system is the first commercial, general-purpose realization [5] in which standard DDR4 DIMMs are populated with DRAM Processing Units (DPUs), simple in-order cores co-located with the DRAM banks. The programming model is host-orchestrated. A program on the host CPU allocates DPUs, copies code and input data into DPU memory, launches the DPUs, and copies results back. Each DPU runs a kernel written in C and compiled by UPMEM’s LLVM-based toolchain [13]. Within a DPU, up to 24 hardware threads (tasklets) execute concurrently. Figure 1 shows this organization.

Figure 1. UPMEM DPU organization. The host reaches the DPU over the DDR4 interface, and a DMA engine moves data between the MRAM bank and the on-core WRAM and IRAM that the RISC core executes from. Sizes are listed in Table I.
Microarchitecture and Memory Hierarchy
Table I summarizes the DPU microarchitecture [5, 13]; Figure 1 shows how the pieces connect. The calling convention (§ 5-C) uses r23 as the link register and r22 as the frame and stack pointer. The DPU side carries none of the standard control-flow protections (Section VIII-B).
| Property | Value |
| Word size | 32-bit |
| Instruction width | 64 bits (8 bytes), fixed-width, aligned |
| IRAM (code) | 24 KB, up to 4096 instructions |
| WRAM (scratchpad) | 64 KB — the stack lives here |
| MRAM (main) | 64 MB DRAM bank |
| Hardware threads | up to 24 tasklets per DPU |
| Registers / thread | 24 × 32-bit GPR |
| Pipeline | 14-stage, in-order |
| Link register | r23 (holds return address on call) |
| Frame/stack pointer | r22 |
| CFI protections | none (no canaries, no ASLR, no W⊕X on DPU) |
Table I. UPMEM DPU Architecture
Code-Reuse Attacks: ROP and JOP
Modern systems resist code-injection attacks with write-or-execute (, also called DEP/NX) in which memory is either writable or executable but never both, so an attacker cannot run data they inject. Code-reuse attacks sidestep this by executing code that is already present and executable in the target. Return-oriented programming (ROP) [10] corrupts the stack so that a chain of short instruction sequences — also called “gadgets,” each ending in a ret — executes in sequence, with the stack supplying the next gadget’s address after every return. Prior work [14] showed that any indirect branch suffices, and the terminator need not be a ret. Jump-oriented programming (JOP) [12] drops the stack entirely and creates chains through indirect jumps and a central dispatcher gadget. The central claim underlying both of these is that a sufficiently large body of code contains enough reusable gadgets to assemble arbitrary, even Turing-complete, computation [10]. Shacham identifies five canonical primitive classes a gadget set must span to be computationally universal: load-constant, load-from-memory, store-to-memory, arithmetic/logic, and control-flow (data-dependent branches and loops) [10, 11]. Showing that a target realizes all five is therefore the standard feasibility criterion, and the property we measure for the DPU in Section VII-B.
Why Fixed-Width RISC (Galileo vs. Buchanan)
Shacham’s Galileo algorithm [10] exploits a peculiarity of the x86. Decoding the same bytes at a different offset yields different, unintended instructions because instructions are variable-length and unaligned, so a binary hides far more gadgets than its intended instruction stream contains. The DPU ISA removes this entirely. Instructions are fixed-width and 8-byte aligned, so there are no “hidden” instructions to uncover. This means every gadget must begin at a real instruction boundary. This places our work in the setting of Buchanan et al. [11], who generalized ROP to fixed-width aligned RISC (SPARC), where gadgets are intended instruction suffixes of real functions.
Stack Layout and Overflow Mechanics
In our running-example vulnerable function (parse_request, detailed in Section VI-A), the saved {r22,r23} pair sits just past the vulnerable buffer, so a linear overflow reaches it once the buffer is full. WRAM has no address randomization, so the buffer, stack, and every gadget and sink address are fixed and known offline from the binary. Only the in-frame offset to the saved pair varies between builds. The saved pair is stored with r23 in the low word and r22 in the high word—the opposite of the naive guess—so the overflow must place the jump target in the low word and a valid frame pointer in the high word. Rather than aim at one slot, we saturate the region past the buffer with copies of the pair so that whichever 8-byte-aligned slot ends up holding the saved return receives a valid {r23,r22} (Section VI-B). Figure 2 shows the baseline frame and the overflow moment side by side.

Figure 2. DPU stack layout and overflow mechanic (addresses grow upward, opposite of x86). (a) baseline non-leaf frame. (b) overflow moment in parse_request (Section VII-C): the unbounded mram_read runs upward from the local buffer and overwrites the saved {r22,r23} pair, so the epilogue transfers to the attacker-written value.
Threat Model
We consider a deployed UPMEM-style PIM system in which a host offloads work to DPU kernels. A concrete setting is multi-tenant DPU inference: tenant A’s request shape parameterizes an mram_read on a DPU shared with tenant B. A single missing length clamp hands A a chain assembled from the shared runtime library (Section VII-C) that leaks B’s secret into MRAM A can read back, with no DPU-code injection and no knowledge of B’s kernel source. Our trust boundary is the DPU itself: we treat the host CPU, OS, and orchestration runtime as trusted, and ask only what an adversary can achieve on the in-memory processor. Prior PIM-security work considers adjacent threats (timing/covert channels [6], RowHammer [7], confidentiality of data in untrusted memory [8], [15]) but not control-flow integrity on the DPU, which is our focus.
a) Attacker capabilities: The attacker (i) supplies input to a DPU kernel that contains a memory-safety bug — our running example is an unbounded mram_read that copies an attacker-controlled number of bytes into a fixed-size WRAM buffer — and (ii) knows the DPU runtime library the target kernel links against, which is a reasonable assumption. The SDK and its runtime sources are public [13], so an attacker can rebuild librt.a byte-identically to a victim deployment and enumerate every runtime gadget offline. We do not assume the attacker knows the proprietary user kernel. In fact, the sink-free leak of Section VII-D performs the exfiltrating write using only reused library gadgets, so the kernel it runs against need only link the DPU runtime, not share any user code with the attacker. Because the DPU provides no address-space layout randomization (ASLR), gadget and sink addresses are static and computed offline from the known runtime binary (IRAM is fixed at 0x80000000 and further explained in Section II-B).
b) Restrictions: The attacker cannot inject or modify DPU code. All executed instructions already exist in the kernel or in the runtime library it links. This is a code-reuse setting, consistent with a -style assumption on instruction memory, and is what distinguishes the attack from classical shellcode injection.
c) Goals: The adversary’s goal is to chain reused gadgets into arbitrary, Turing-complete computation. We establish that the necessary gadgets and primitives exist, demonstrate multi-gadget chaining of control flow, and further demonstrate a fully general, sink-free chain — one that performs the exfiltration from reused gadgets alone, rather than by routing control into an existing function (Section VII-D).
d) Out of scope: Host-side compromise, physical and fault attacks, and data-oriented corruption such as RowHammer [7] are orthogonal and out of scope. We assume both the host and the channel by which code and data are loaded onto the DPU are trusted.
e) Bug reachability in deployed PIM software: The attack of Section VII-C needs only one ingredient: a destination-side overflow of a WRAM buffer through an unbounded mram_read. The reason it is dangerous is not that it is common today but that nothing on the DPU catches it once it appears (Section VIII-B). An audit of all 48 mram_read call sites in the 16 PIM benchmarks [5]: 42 pass a compile-time constant length, and the remaining 6 clamp their runtime-computed length at the source. Zero of 48 sites admit the destination-side overflow we exploit—the bug class is latent in current PIM code rather than endemic. The clamp-at-every-call discipline PrIM maintains is a per-site programmer convention with no backstop, and as PIM moves toward multi-tenant and ML-inference deployments [16, 8], that discipline becomes harder to guarantee. The exploit characterizes a durable platform property rather than a specific bug.
Related Work
Code-Reuse Attacks: Lineage and Setting
Shacham [10] introduced ROP on the x86; subsequent work generalized the technique to fixed-width aligned RISC [11], removed the dependence on ret [14], introduced jump-oriented variants [12], demonstrated the method on RISC-V [17, 18], and automated gadget discovery and chaining through symbolic execution for RISC-V and ARM64 [19]. Production scanners such as ROPgadget [20] already handle aligned ISAs one instruction at a time. Beyond the CPU, Guo et al. [21] and Roels et al. [22] show that GPUs and CUDA SASS admit code-reuse execution with no deployed defenses, and defensive work has followed on the GPU side as well [23, 24]. Our method—disassembling and scanning backward from indirect-branch terminators for intended instruction suffixes—is the established approach for a fixed-width aligned RISC target and is not a technical contribution. What is new is the domain: to our knowledge no prior work poses Shacham’s feasibility question on a Processing-in-Memory ISA or demonstrates a control-flow hijack on the memory side of the bus, where the host’s control-flow defenses do not reach. The GPU accelerator-side results are the closest methodological precedents, but they target host-launched compute accelerators, whereas on PIM the host CPU is the attack’s victim rather than its launcher.
PIM Security
Prior PIM-security work targets different mechanisms than code reuse. Bostanci et al. [6] build timing channels amplified by PIM operations, and Tobah et al. [7] flip nested pointers with RowHammer, a data-corruption primitive that shares the word gadget but not the mechanism of reused instruction sequences. Gholfsaz Ghinani et al. [8] propose a defense for computing on untrusted in-memory hardware, and surveys by Arafin and Lu [15], Yuksel et al. [16], and Waingankar et al. [9] catalog the PIM threat landscape; the last of these explicitly names code-reuse against programmable NDP cores as an open concern. None of this work demonstrates a control-flow-hijacking or code-reuse attack on a PIM ISA, which is the gap this paper closes with a quantified gadget inventory and a working exploit.
Methodology and Experimental Setup
Reproducible Environment
We run on the UPMEM DPU functional simulator (no physical PIM hardware) using the UPMEM SDK 2023.1.0 from the CMU-SAFARI mirror [13], driven by the stock dpu-upmem-dpurte-clang and llvm-objdump 12.0.0. Our aarch64 host runs x86-64 SDK binaries under QEMU user-mode (each pipeline in a container, end-to-end exploit in a full-system x86-64 guest), which affects tool speed only, not the decoded instruction stream.
Target Binaries
We study two targets: our vulnerable kernel vuln_dpu (Section VI-A) and the DPU runtime library librt.a (6,711 instructions; profiling build librt_p.a at 8,264) that the SDK links into every DPU kernel [13]. Because ld.lld is unstable under QEMU, we scan the pre-built archives directly rather than freshly linking. The disassembly is byte-identical to a native run. LTO archives ship as LLVM bitcode with no native code [25, 26]. PrIM ships 16 benchmarks. Our source-level mram_read audit (§ 3) covers all 16, while the gadget scan (Section VII-F) and fortification diff (Section VIII-C) cover the 13 and 12 benchmarks respectively that build cleanly under our simulator toolchain.
Recovering the Calling Convention
The precondition for any return hijack is that a function’s return address lives on attacker-reachable, writable memory [27]. We recovered the DPU calling convention directly from disassembly (shown in Listing 1), and it satisfies this condition. On the DPU the frame pointer is r22 and the link register is r23, which holds the return address on call. On entry, a non-leaf function spills the caller’s {r22,r23}
; prologue -- save {r22,r23}, grow frame
sd r22, 16, d22 ; spill {r22,r23} to stack
add r22, r22, 24 ; grow frame
sd r22, -24, d14 ; save {r14,r15}
; epilogue -- restore and return
ld d14, r22, -24 ; restore {r14,r15}
ld d22, r22, -8 ; reload {r22,r23} (ret addr)
jump r23 ; return == ROP terminator
Listing 1: Observed DPU prologue/epilogue: the saved link register r23 is spilled to the WRAM stack and reloaded before the indirect ‘jump r23’ that implements return.
register pair to its WRAM stack frame (sd r22, 16, d22) and then advances r22 to grow the frame. Callee-saved pairs such as {r14,r15} are saved alongside it. On exit, the epilogue reverses this: it reloads the saved pair from the stack (ld d22, r22, -8) and returns by branching to the restored link register (jump r23). An attacker who can write past a stack buffer controls the branch target because WRAM is writable and the saved r23 is read back off the stack immediately before that indirect jump r23. This shows the classic ROP precondition on the memory side of the bus and is consistent with the upmem calling convention [13].
Two details of this convention shape the payload (Section VII-C). First, the pair is stored as {r23 in the low word, r22 in the high word}, so the overflow must place the jump target in the low word and a valid frame pointer in the high word. Second, r23 is not a byte address but an instruction index, so writing a raw code address lands control at the wrong place. Finally, only the callee-saved pairs r14–r23 are spilled to the stack and thus recoverable by an attacker, which narrows the set of library routines a chain can thread through but does not block it (Section VII-C).
The Galileo-for-DPU Gadget Scanner
Figure 3 gives our scanner. It follows Shacham’s Galileo [10] in scanning backward from every terminator for straight-line suffixes but adapts to the DPU’s fixed-width aligned ISA in four ways: (i) it steps one aligned 8-byte instruction at a time rather than one byte at a time (no misaligned decodes, no trie); (ii) it keys on register-indirect jump r23 (ROP terminator) and jump rN with (JOP terminator) rather than the ret byte c3, ignoring direct jump 0xADDR; (iii) it parses llvm-objdump text, where instructions already sit at true boundaries, rather than decoding raw bytes; (iv) it grows gadgets backward only while the window stays 8-byte contiguous and contains no control-flow diverter before the terminator (including the DPU’s embedded conditional branches—ALU ops that also carry a <cond>, <target> operand). Gadgets are classified by capability and flagged chainable when they either reload r23 or are JOP. The backward walk is bounded by MAXLEN, which Section VII-A sweeps.

Figure 3. The Galileo-for-DPU gadget-scanning algorithm; scanner details and its four departures from Shacham’s byte-recursive Galileo are in § 5-D.
Attack Design and Implementation
The Vulnerable DPU Kernel
Our vulnerable kernel vuln_dpu isolates the single bug this paper exploits: parse_request uses mram_read to DMA an attacker-controlled number of bytes into a fixed 32-byte WRAM buffer with no bounds check. The routine is marked noinline (to force its own spilled frame rather than inlining into main, which the UPMEM runtime handles specially [13]) and is non-leaf through its call to printf, so the calling convention of § 5-C spills {r22,r23} just past the buffer. A long request overwrites the saved return; the epilogue’s jump r23 then transfers to the attacker-written address.
Two host-readable witnesses record the outcome: returned_cleanly (a __host-attributed byte [13] set to 1 only on a clean epilogue) and output_buf (MRAM scratch). The exfiltration target win()—a ret2libc-style sink that reads a host-planted secret (0x00C0FFEE) and writes it with a "LEAK" marker into output_buf—is unreachable on any legitimate path, so landing control there demonstrates an attacker-chosen effect rather than a crash.
Payload Construction
Two values in each saved-pair copy must be encoded carefully. The low word is the branch target, but r23 on the DPU holds an instruction index: the byte offset from the 0x80000000 IRAM base divided by eight, not a byte address. Writing a raw byte address sends control to eight times the intended location and faults. The high word is r22, the restored frame pointer, which must be a valid low-stack WRAM address (such as 0x2a0) so the sink runs with headroom. With no address randomization both are fixed and are computed offline from the disassembly.
Chaining via the Calling Convention
Multi-gadget chaining needs no classical stack-pivot gadget. The epilogue every non-leaf function uses (Listing 1) reloads {r22,r23} from the WRAM stack before branching, so the attacker-controlled payload sets r22 on every return and the next hop’s frame pointer is already in place, making the calling convention itself the pivot.
Evaluation
Gadget Inventory
We ran Galileo-for-DPU, described in § 5-D, on two real targets: the DPU runtime library librt.a (6,711 instructions across 260 functions, 315 jump r23 + 2 JOP terminators, 517 non-trivial gadgets, 221 chainable) and the profiling build librt_p.a (8,264 instructions, 247 + 2 terminators, 222 non-trivial, 808 chainable). The LTO archives librtlto*.a are LLVM bitcode, not native code, and are excluded.
In librt.a, roughly 47 register-indirect terminators per 1000 instructions falls in the same range the RISC-ROP precedent reports for SPARC and ARM libraries [11], [14], so this single library already exceeds Shacham’s feasibility threshold before any application code is linked. The two JOP terminators (jump r1, jump r3) are enough to exhibit a JOP sink but too thin for a full dispatcher. Gadgets are short, as code reuse requires: most are only one to three instructions long, and none exceeds five. Nearly all are return-type, with a small JOP minority. Their capability mix covers what a flexible chain needs: arithmetic, memory load and store, register move, and constant loading. These counts are stable across optimization levels.
Primitive Coverage
We next ask which of Shacham’s canonical primitive classes are realizable from the gadgets found in librt.a, giving one representative gadget per class in Figure 4.

Figure 4. Shacham primitive coverage in librt.a. All five canonical classes are realized by the runtime library alone; counts are the total non-trivial gadgets found per class, and each panel shows one representative example gadget (gadgets within a class vary in instructions and operands).
All five canonical classes are realized. Of the 221 chainable gadgets, 217 also carry a data capability—217 with load-mem, 9 with store-mem, 13 with arith, and 4 with load-const—so chainable terminators and data operations coexist in the same gadgets rather than requiring separate chaining and data gadgets. The scan also confirms the attack-design claim of Section VI-C. No gadget writes r22 before a terminator at any scan-window size we tried. Every r22 write in librt.a is a function-entry frame advance (add r22, r22, imm), never epilogue-adjacent. Chaining is still feasible because the standard DPU epilogue reloads {r22,r23} from the stack, so the attacker’s payload threads r22 on every return without any pivot gadget.
End-to-End Control-Flow Hijack and Secret Leak
We verified the full attack end-to-end on the functional simulator against vuln_dpu (Section VI-A). A crafted 128-byte request overruns the 32-byte buffer and redirects parse_request’s epilogue into win(), which exfiltrates the host-planted secret (0x00C0FFEE) into output_buf; Figure 2(b) shows the WRAM stack at the moment of the overflow.
a) A DPU-specific exploitation detail: The saved return register is not a byte address. The DPU stores and consumes it as an instruction index which means it is the byte offset from the 0x80000000 IRAM base divided by eight. The hijack payload must therefore write win()’s instruction index into the saved-return slot rather than its byte address, since a raw byte address lands at eight times the intended target and faults. This is a concrete, reusable finding for exploiting this ISA. It does not weaken the attack because addresses are static with no ASLR so the index is known offline, but it is required to land control precisely.
b) Determinism: With no ASLR the exploit is fully repeatable. The single static payload mentioned above leaked the secret on 10 of 10 runs.
c) A multi-gadget chain: A true multi-hop chain through the r22-threaded reload also succeeds. The overflow sets the saved return to a reused gadget whose tail is the standard epilogue (Listing 1). That gadget reads the next {r22,r23} pair from an attacker-planted WRAM node and jumps on, reaching either __sys_end for a clean halt or the exfiltration sink. This establishes gadget chaining, not merely a single hijack.
A sink-free exfiltration
A sink-free chain performs the entire exfiltration from reused gadgets alone, without routing control into any pre-existing function such as win(). Two reused gadget tails suffice, threaded through the r22-reload mechanism. The first is a setter: a tail of a printf runtime helper that loads the callee-saved pair {r18,r19} from the attacker-controlled frame and sets them to &secret and output_buf. The second is a DMA tail from the runtime’s __memcpy_mw, whose sdma copies the secret word from WRAM to host-readable MRAM. After the copy, the chain threads to __sys_end for a clean halt. On the simulator, the secret reaches output_buf on 10/10 runs and the kernel halts cleanly on 10/10. Rebuilding with win() absent gives the same 10/10, confirming that reused gadgets alone perform the write. This chain works because the kernel links the runtime copy helpers, which is true of any kernel using memcpy or memmove. The result realizes the tenant-A/tenant-B scenario of {xref}Section III`: a payload crafted against the shared runtime leaks a secret from the victim’s WRAM without knowing the victim’s source or injecting DPU code.
Data-Dependent Control Flow
The chains in Section VII-C execute a fixed sequence of gadgets, so their behavior is independent of any value computed at run time. Arbitrary rather than fixed-chain computation requires two more primitives on top of the data primitives of Section VII-B: a conditional branch whose target is runtime-chosen and a loop whose iteration count is runtime-chosen. We realize both from reused library code.
a) Data-dependent conditional branch (store-into-chain): The DPU threads its chain through the epilogue reload (Listing 1). A reused store gadget that writes a runtime-computed value into that reload slot before the epilogue reads it yields a jump target chosen at run time, with no pivot gadget required. We realize this with a reused tail of strsep, feeding it the byte sum parse_request already computes. We verified the mechanism two ways, each with three input values and reaching the expected outcome on 3/3 runs per value. First, we routed the runtime value through the DMA tail to output_buf so the host could read it back directly, confirming the store wrote the correct runtime value. Second, we placed the same runtime value in the reload slot so the epilogue dispatched control to it as an instruction index, confirming the runtime value actually steers control flow. The branch target is never a constant in the payload.
b) Data-dependent loop (ret2loop into strcat): Rather than synthesize a loop from a counter and a predicate gadget, we re-enter an existing library loop mid-function. strcat’s inner copy loop iterates until the source byte is null, then returns through the standard epilogue back into our chain. A setter gadget loads the source address with a runtime value, so varying that address varies the iteration count. A DMA gadget then copies the destination region to output_buf for the host to observe. Across input strings of varying lengths, the measured iteration count matched strlen(src) on 3/3 runs per input. The loop bound is never a constant in the payload.
These two reused primitives, together with the data primitives of Section VII-B, supply the computational building blocks of a Turing-complete gadget set.
Gadget Density on Real Workloads
To show that the attack surface is not an artifact of our demo kernel, we compiled and scanned 13 benchmarks from the PrIM suite [5], the standard UPMEM DPU workload set reported in the PrIM suite. Every one contains register-indirect terminators and non-trivial gadgets, ranging from 8 to 49 terminators per 1000 instructions. These counts cover the application kernels on their own, and because every DPU program links the runtime the effective corpus for any of these workloads is its own gadgets together with the 517 non-trivial gadgets in librt reported in Section VII-A. Gadget availability therefore holds across real PIM software and not just our target.
Discussion
Interpreting the Results
Shacham’s feasibility thesis carries over to the DPU: the runtime library alone realizes all five canonical primitive classes and furnishes enough control for a working hijack that leaks a secret, with no code injection and nothing beyond the standard runtime required. Combined with the two reused control-flow primitives of Section VII-E—a data-dependent branch and a data-dependent loop—these are the building blocks of a Turing-complete gadget set; what we do not demonstrate is an automated synthesizer that composes them into arbitrary programs (Section IX). Because the DPU’s fixed-width aligned ISA has no misaligned decodes, our scanner works in a strictly smaller search space than Shacham’s x86 setting, so the gadget supply we report is a lower bound.
Defense-Gap Analysis
We probed each standard mitigation on the DPU side. ASLR is absent because code lives at a fixed IRAM base of 0x80000000 and the WRAM stack is deterministic, so the exploit reproduced 10 of 10 runs from a single hard-coded payload and every gadget and sink address is known offline. The DPU also lacks any CFI or pointer-authentication. The net result is that none of the host-side protections in Table I has a working counterpart on the DPU, which is exactly why the overflow discussed in Section VII-C is exploitable with a single static payload.
Stack canaries fail in two separate ways. First they are unavailable out of the box: the compiler front end accepts -fstack-protector-all and emits canary checks, but linking fails on undefined __stack_chk_guard and __stack_chk_fail, so a stack-protected kernel cannot be built at all. We removed this obstacle with a minimal runtime that defines a guard word and a __stack_chk_fail handler that halts. A protected kernel then links. Even so, the canary does not stop the attack: refiring the same exploit against the hardened kernel still leaks the secret 10 of 10 while the canary trips 0 of 10 (Table II). The reason is architectural. The DPU stack frame grows toward higher addresses, so a callee saves its return pair {r22,r23} above its local buffer whereas the compiler places the canary below it. A linear overflow DMAs upward from the buffer into the saved return and never touches the canary (Figure 5). This placement is not an artifact of one build: we swept 144 configurations of the vulnerable kernel (six optimization levels, six buffer sizes from 32 to 1024 bytes, with and without frame-pointer omission, at 1 or 4 tasklets), and every build placed the canary slot at the lowest offset of the frame. We therefore treat the misplacement as a property of the toolchain port, requiring a backend fix rather than per-kernel source changes. Specifically, it belongs in an LLVM backend pass over the DPU stack-protector slot ordering; implementing and upstreaming the pass is left as future work.

Figure 5. Why stack canaries fail on the DPU: the upward-growing frame leaves the canary on the wrong side of the overflow (Section VIII-B).
| Build | Leak | Caught | Clean |
| Baseline (no mitigation) | 10/10 | — | — |
| Stack canary (runtime supplied) | 10/10 | 0/10 | — |
| Bounds-checked DMA | 0/10 | — | 10/10 |
Table II. Mitigation experiment ( per build). Leak = secret in output_buf; caught = canary trip; clean = benign completion.
We also verified one mitigation that does hold: a bounds-checked DMA that clamps the request length to the destination buffer size before mram_read. This removes the overflow primitive at its source, so the same exploit leaks the secret 0 of 10 while benign requests complete normally 10 of 10 (Table II). It is a per-call source fix rather than a platform-wide defense, but it shows the attack is preventable once the DMA length is validated.
Portability of Transparent Fortification to PIM
The bounds-checked DMA of Section VIII-B stops the attack on vuln_dpu 10 of 10, but vuln_dpu’s overflowed buffer is a stack array whose size the compiler can see. Real DPU kernels allocate WRAM through mem_alloc(), which returns an opaque pointer with no compile-time size. We asked whether the _FORTIFY_SOURCE-style transparent form of the wrapper—the form a PIM SDK would ship as the default—actually fortifies that code. The question is a defense-portability question rather than a cost question, and we answer it by compiling each kernel twice with the stock Upmem toolchain (dpu-upmem-dpurte-clang 2023.1.0, -O2, -c, no linker required): once without the wrapper and once with safe_mram.h included so every mram_read/mram_write macro expands to the fortified form. We then compare the two .text instruction counts from llvm-objdump -d to see whether a bounds check was emitted at all.
Table III reports the measurement, and the headline is a portability finding rather than a cost one: the transparent host-style bounds-check wrapper is silently inactive on 12 of 12 PIM kernels we measured. The reason is specific to how PIM allocates WRAM. Every DPU kernel in the suite obtains its scratchpad buffers through mem_alloc(), which returns an opaque pointer, and __builtin_object_size is unable to attribute a size to such a pointer and returns (unsigned long)-1. The wrapper itself short-circuits when the size is unknown, so on PIM it skips the check everywhere and the DMA ships unguarded. This is not a toolchain bug; it is exactly how _FORTIFY_SOURCE behaves on glibc when the destination size is unknown. The difference is that on a PIM runtime the “destination size is unknown” branch is not an exception but the default, because the standard allocation idiom hides it.
| Kernel | Base ins | Hard ins | Sites | Guard? | |
vuln_dpu | 130 | 132 | +2 | 1 | yes |
| VA | 78 | 78 | 0 | 3 | no |
| RED | 114 | 114 | 0 | 1 | no |
| HST-L | 159 | 159 | 0 | 3 | no |
| GEMV | 190 | 190 | 0 | 7 | no |
| SPMV | 148 | 148 | 0 | 5 | no |
| TRNS | 394 | 394 | 0 | 7 | no |
| BS | 167 | 167 | 0 | 6 | no |
| TS | 215 | 215 | 0 | 5 | no |
| SEL | 1169 | 1169 | 0 | 2 | no |
| UNI | 1382 | 1382 | 0 | 2 | no |
| SCAN-RSS | 2152 | 2152 | 0 | 3 | no |
| NW | 27 | 27 | 0 | 8 | no |
Table III. Whether the transparent safe_mram.h bounds-check wrapper actually emits a guard in each kernel.
The only kernel in our set where the transparent form fires is vuln_dpu, whose overflowed buffer is a 32-byte stack array that __builtin_object_size resolves without help. There the wrapper emits a single jgeu r0, 257, <fail> (DPU’s combined compare-and-branch) plus one extra instruction to materialize the fail-handler target: a two-instruction increase, 1.5% of the 130-instruction baseline. This is the measured per-site cost of a bounds check when it is emitted, and the number useful for projecting the cost of a working defense.
Making bounds-checked DMA a platform-wide default on PIM therefore requires one of two SDK changes, neither of which is in the current runtime. A mem_alloc-shaped allocator that returns a size-carrying descriptor rather than an opaque pointer would let the transparent wrapper resolve dst_size and emit the check at every call site, which is the natural generalization of glibc’s pattern. Alternatively, the kernel-side convention could be changed to declare WRAM buffers as fixed-size arrays so that sizeof() supplies the size, which is what safe_mram.h’s _bounded form already exploits. In either case, the per-site cost is the same two instructions we measure on vuln_dpu. Scaling from the six runtime-length sites across PrIM identified in § 3, the IRAM budget for a working platform-wide default is at most twelve added instructions across the entire suite, negligible against the 4,096-instruction IRAM ceiling. Direct wall-clock confirmation on physical upmem silicon remains future work (Section VIII-F).
Bypassing a Correctly-Placed Canary
A natural response to Section VIII-B is to assume that a one-time toolchain patch—moving the canary slot to the saved-return side of the frame—would close the gap. We tested this directly. To simulate the corrected placement without rebuilding the compiler, we modified parse_request to wrap its vulnerable buffer and a canary word in a single struct, so the canary is guaranteed by the C object model to sit immediately above the buffer and below the saved {r22,r23} pair. The function initializes the canary on entry, re-reads it through a volatile pointer after the DMA, and calls __stack_chk_fail on mismatch. A linear overflow from the buffer must now cross the canary slot before it can reach the saved return.
We then fired three payloads at the same hardened kernel, built so win() is physically absent from the binary. The baseline sink-free chain of Section VII-D serves as the first case. The second is a canary-aware variant that places the four bytes of the fixed guard value (0x0BADC0DE, recovered from the DPU runtime binary with a single llvm-objdump invocation) at the payload offset that lands on the canary slot and continues the saturated {r23,r22} pattern above it. The third is the same canary-aware builder with the preservation disabled, as a negative control.
The results are reported in Table IV. The baseline chain, which has no knowledge of the guard, trips the canary and halts on every one of 10 runs with no leak. The canary-aware chain leaks the secret on 10 of 10 runs with the canary silent on every one. The DPU reports dpu_launch status: success, so the chain reaches __sys_end and exits cleanly. The negative control, which clobbers the canary slot with the saturated pattern instead of the guard, trips the canary 10 of 10. The entire bypass costs the attacker four bytes of extra payload at a precomputed offset, and win() is never reached because it does not exist in this build.
| Payload | Leak | Caught |
| Baseline sink-free chain, no canary knowledge | 0/10 | 10/10 |
| Canary-aware sink-free chain (preserves 0x0BADC0DE) | 10/10 | 0/10 |
| Canary-aware builder, preservation disabled (negative control) | 0/10 | 10/10 |
Table IV. Canary bypass experiment (=10 per case). “leak” = secret reached output_buf; “caught” = __stack_chk_fail marker.
The root cause is not the placement but the secrecy of the guard. dpu_canary.c fixes __stack_chk_guard at a compile-time constant because the DPU has no entropy source exposed to kernels. A per-launch random guard seeded by the host would close the static-disclosure path we exercise here, but the guard still lives in WRAM at a fixed address with no memory protection, so any attacker primitive that can read or

Figure 6. Bypassing a correctly-placed canary: the attacker preserves the fixed guard 0x0BADC0DE at the canary offset and overwrites the saved return above it. Measured 10/10 in Table IV.
overwrite that word reduces the problem to the static case. We return to this in Section VIII-E.
Mitigations
The experiments of Sections VIII-B and VIII-D together argue that shipping __stack_chk_* in the DPU runtime is necessary but not sufficient: making stack-smashing protection effective on this upward-growing frame requires both a correct canary slot placement (a LLVM backend pass over the DPU stack-protector slot ordering) and a host-seeded random guard with a WRAM protection story to prevent recovery.
The bounds-checked DMA of Section VIII-B is a small immediately deployable fix (safe mram_read/mram_write wrappers in the SDK), but Section VIII-C shows the _FORTIFY_SOURCE-style transparent form is silently inactive on 12 of 12 PrIM kernels. Making it platform-wide requires either a size-carrying mem_alloc descriptor or fixed-size WRAM arrays. Beyond this, a W ⊕ X policy for IRAM and a lightweight CFI validating r23 and jump rN targets would raise the bar against code-reuse attacks not tied to a single overflowable buffer.
a hardware-friendly CFI sketch: The structural weakness is that every function return reads its target from attacker-overwritable stack memory. A per-tasklet shadow return-index register would close this gap, in the spirit of Intel’s hardware shadow stack in CET [28]. It is a small hardware stack of 32-bit instruction indices, separate from the WRAM frame. On a call, the hardware pushes the next instruction index in parallel with writing r23. On jump r23, it compares the return target against the shadow top and faults on mismatch. Our attacks fail at every chain-hop because the attacker-written r23 is not the index the caller pushed. The storage cost is modest. Each DPU needs tasklets entries bytes bytes of SRAM, a first-order estimate under at a modern 6T-SRAM cell [29]. Full RTL evaluation remains future work, including whether the check fits in fetch slack or requires an added pipeline stage.
The functional simulator does not model cycle timing. We therefore bound the primitive’s overhead using static instruction counts from the same hardened PrIM builds in Table III. The relevant dynamic events are call and jump r23, which exercise the shadow stack. Across the twelve PrIM kernels, their combined share of static .text has a median near 8%.
The hardware primitive adds at most one pipeline cycle per return event. Its dynamic cost is therefore bounded by the return fraction times CPI, which comes out under 8% on the median kernel. A conservative software emulation of the same semantics would add five extra instructions per round trip, inflating the committed .text by roughly 40% at the median. Both numbers are strict overestimates, since hot code paths amortize better than static counts suggest. Both are also strictly worse than a hardware shadow stack, consistent with prior measurements comparing software and hardware shadow-stack costs [30].
We report bounds rather than a cycle-accurate measurement because the UPMEM functional simulator exposes only committed-instruction counts [13], and a cycle-level DPU model is itself future work (Section IX). Even these loose bounds place the primitive within what a throughput-oriented PIM core can absorb.
The remaining register-indirect terminators, jump r1 and jump r3, which our scanner catalogs as JOP sinks, require a complementary coarse-grained target check such as a landing-pad instruction at every indirect-call target [28]. The combined mechanism is a plausibly affordable in-memory CFI and would turn every chain in this paper into a fault, which is the direction we think a hardened DPU should take.
Limitations
Our results come from the UPMEM functional simulator rather than a physical DIMM. The functional model reproduces the decoded instruction stream and control flow faithfully [5], [13], and the toolchain under x86 emulation on an aarch64 host changes tool speed only. Our scanner parses llvm-objdump text rather than decoding raw bytes, so a gadget the disassembler fails to render would be missed; this makes our counts a lower bound. The published ISA describes 48-bit instructions, yet the ELF encoding is 8-byte aligned, and it is this 8-byte stride our aligned scan relies on.
Ethical Considerations
This work was a controlled self-contained study on the UPMEM functional simulator inside a disposable VM; every program it attacks is intentionally vulnerable code we wrote. Our intent is defensive, and we pair the attack with the mitigations of Section VIII-E. The behaviors we rely on (absent canary runtime, lack of ASLR/CFI) are documented design characteristics of the current platform rather than secret flaws, so no coordinated disclosure timeline is needed.
Future Work
The natural next offensive step is to automate the manual sink-free chain of Section VII-D: a synthesizer that consumes the scanner’s gadget JSON and emits a working payload, together with a JOP dispatcher over the jump r1/jump r3 terminators we catalog. Risc yROP [19] does this for RISC-V/ARM64 via symbolic execution; porting that style to the DPU’s instruction-index returns and r22-threaded reload is the concrete next step. The application interface should also be stressed intra-DPU (24 tasklets share one WRAM address space) and across other PIM designs (Samsung HBM-PIM, SK Hynix AiM). On the defensive side, the hardware shadow-return-index primitive of Section VIII-E needs RTL prototyping with a cycle-level DPU simulator; all of this ultimately needs validation on real uppem silicon, which would exercise the real MRAM-to-WRAM DMA engine and expose multi-DPU and 24-tasklet concurrency effects the functional model abstracts away.
Conclusion
We present PIMROP, to our knowledge the first demonstrated code-reuse attack on a commercial Processing-in-Memory ISA, and Galileo-for-DPU, a gadget scanner adapted to the UPMEM DPU’s fixed-width, 8-byte-aligned RISC encoding. Using it, we show that Shacham’s feasibility thesis holds on real DPU code. The runtime library alone yields 517 non-trivial gadgets spanning all five canonical ROP primitive classes, and every one of 13 PrIM benchmarks carries gadgets as well. We demonstrate two verified end-to-end attacks on the functional simulator. In the first, a stack buffer overflow overwrites the saved return and diverts control into a routine that copies a secret into host-readable memory. In the second, we leak the same secret using a chain of reused gadgets alone, without diverting control into any such routine. We further demonstrate the two reused control-flow primitives needed to lift these chains from fixed straight-line exfiltration to arbitrary computation: a data-dependent conditional branch via a store-into-chain gadget, and a data-dependent loop via ret2loop into strcat, each measured as deterministic across input variations and together supplying the computational basis for a Turing-complete gadget set on the DPU. We also report two DPU-specific exploitation observations in that the saved return is stored as an instruction index, and the upward-growing stack frame bypasses conventional stack canaries. Moving the canary slot to the correct side of the frame via source-level simulation does not close the gap either: a sink-free gadget chain that preserves the DPU’s fixed, host-unseeded guard value leaks the secret on 10 of 10 runs against a kernel with a correctly-placed canary. We also verify a bounds-checked DMA that stops the attack. To enable further research on PIM security, we open-source Galileo-for-DPU and our testing harness at https://github.com/wtegge2/ROP-in-PIM.
References
References
- [1]O. Mutlu, S. Ghose, J. Gomez-Luna, and R. Ausavarungnirun, “A modern primer on processing in memory,” Emerging Computing: From Devices to Systems; arXiv:2012.03112, 2022.arxiv.org/abs/2012.03112
- [2]W. C. Tegge, J. P. Cardoso de Lima, S. Fang, J. Castrillon, and A. K. Jones, “RAPID: Row-parallel arithmetic processing in DRAM,” arXiv:2610.02502, 2026.arxiv.org/abs/2610.02502
- [3]W. C. Tegge, J. P. Cardoso de Lima, B. F. Morris III, and A. K. Jones, “Low-overhead bitwise shifting in dram,” in Proceedings of the Great Lakes Symposium on VLSI 2026, 2026, pp. 715–716.DOI
- [4]S. Fang, W. C. Tegge, C. Yue, E. Hoque, and A. K. Jones, “Memory is the cipher: Confidential AES in commodity DRAM,” in Proc. Great Lakes Symposium on VLSI (GLSVLSI). ACM, 2026.DOI
- [5]J. Gomez-Luna, I. El Hajj, I. Fernandez, C. Giannoula, G. F. Oliveira, and O. Mutlu, “Benchmarking a new paradigm: Experimental analysis and characterization of a real processing-in-memory system,” IEEE Access, vol. 10, 2022.
- [6]F. N. Bostanci, K. Kanellopoulos, A. Olgun, A. G. Yaglikci, I. E. Yuksel, N. Mansouri Ghiasi, N. Bingol, M. Sadrosadat, and O. Mutlu, “Revisiting main memory-based covert and side channel attacks in the context of processing-in-memory,” in Proc. IEEE/IFIP International Conference on Dependable Systems and Networks (DSN), 2025, arXiv:2404.11284; earlier title “Amplifying Main Memory-Based Timing Covert and Side Channels using PIM Operations”.arxiv.org/abs/2404.11284
- [7]Y. Tobah, A. Kwong, I. Kang, D. Genkin, and K. G. Shin, “Go go gadget hammer: Flipping nested pointers for arbitrary data leakage,” in Proc. USENIX Security Symposium, 2024.
- [8]S. Ghoflsaz Ghinani, J. Zhang, and E. Sadredini, “Enabling low-cost secure computing on untrusted in-memory architectures,” in Proc. USENIX Security Symposium, 2025, arXiv:2501.17292.
- [9]S. Waingankar, H. Q. Le, and D. Benhaddou, “Redefining trust at the memory wall: The threat landscape, an adversary model and a conceptual framework for secure processing-in-memory,” Computers, vol. 15, no. 9, p. 611, 2025.DOI
- [10]H. Shacham, “The geometry of innocent flesh on the bone: Return-into-libc without function calls (on the x86),” in Proc. ACM Conference on Computer and Communications Security (CCS), 2007.
- [11]E. Buchanan, R. Roemer, H. Shacham, and S. Savage, “When good instructions go bad: Generalizing return-oriented programming to risc,” in Proc. ACM Conference on Computer and Communications Security (CCS), 2008.
- [12]T. Bletsch, X. Jiang, V. W. Freeh, and Z. Liang, “Jump-oriented programming: A new class of code-reuse attack,” in Proc. ACM Symposium on Information, Computer and Communications Security (ASIACCS), 2011.
- [13]UPMEM, “UPMEM DPU SDK,” https://sdk.upmem.com/, 2023, functional simulator; CMU-SAFARI mirror: https://github.com/CMU-SAFARI/UPMEM.
- [14]C. Scheel, W. L. Davi, A. Dmitrienko, A.-R. Sadeghi, H. Shacham, and M. Winandy, “Return-oriented programming without returns,” in Proc. ACM Conference on Computer and Communications Security (CCS), 2010.
- [15]M. T. Arafın and Z. Lu, “Security challenges of processing-in-memory systems,” in Proc. Great Lakes Symposium on VLSI (GLSVLSI), 2020, pp. 229–234.DOI
- [16]I. E. Yuksel, F. N. Bostanci, A. Olgun, and O. Mutlu, “Memory-centric computing: Security benefits and challenges of processing-in-dram,” arXiv preprint arXiv:2606.20786, 2026.arxiv.org/abs/2606.20786
- [17]G.-A. Jaloyan, K. Markantonakis, R. N. Akram, D. Robin, K. Mayes, and D. Naccache, “Return-oriented programming on RISC-V,” in Proc. ACM Asia Conference on Computer and Communications Security (ASIA CCS), 2020, pp. 471–480.DOI
- [18]G. Gu and H. Shacham, “No RISC no reward: Return-oriented programming on RISC-V,” arXiv:2007.14995, 2020.
- [19]T. Cloosters, D. Paaßen, J. Wang, O. Draissi, P. Jauernig, E. Stapf, L. Davi, and A.-R. Sadeghi, “RiccyROP: Automated return-oriented programming attacks on RISC-V and ARM64,” in Proc. International Symposium on Research in Attacks, Intrusions and Defenses (RAID), 2022.DOI
- [20]J. Salwan, “ROPgadget — gadgets finder and auto-roper,” https://github.com/JonathanSalwan/ROPgadget, 2011.
- [21]Y. Guo, Z. Zhang, and J. Yang, “GPU memory exploitation for fun and profit,” in Proc. USENIX Security Symposium, 2024, pp. 4033–4050.
- [22]J. Roels, A. Jacobs, and S. Volckaert, “Cuda, woulda, shoulda: Returning exploits in a sass-y world,” in Proc. 18th European Workshop on Systems Security (EuroSec), 2025, pp. 40–48.DOI
- [23]I. Santos-Greiro, “Warpguard: Protected-site control-flow integrity for cuda sass binaries,” arXiv preprint arXiv:2606.11871, 2026.
- [24]—, “Gerrymandering the warp: Non-control-data attacks on cuda collective decision,” arXiv preprint arXiv:2606.11878, 2026.
- [25]C. Lattner and V. Adve, “LLVM: A compilation framework for lifelong program analysis and transformation,” in Proc. Int. Symp. on Code Generation and Optimization (CGO), 2004, pp. 75–86.
- [26]LLVM Project, “LLVM link time optimization: Design and implementation,” https://llvm.org/docs/LinkTimeOptimization.html, 2024.
- [27]Aleph One, “Smashing the stack for fun and profit,” Phrack Magazine, vol. 7, no. 49, 1996.
- [28]Intel Corporation, “Intel control-flow enforcement technology (cet) specification,” https://www.intel.com/content/www/us/en/developer/articles/technical/technical-look-control-flow-enforcement-technology.html, 2019.
- [29]J. Chang, Y.-H. Chen, H. Cheng, W.-M. Chan, H.-J. Liao, Q. Li, S. Chang, S. Natarajan, R. Lee, P.-W. Wang, S.-S. Lin, C.-C. Wu, K.-L. Cheng, M. Cao, and G. H. Chang, “A 20nm 112mb sram in high-k metal-gate with assist circuitry for low-leakage and low-vmin applications,” in Proc. IEEE International Solid-State Circuits Conference (ISSCC), 2013, pp. 316–317.DOI
- [30]T. H. Dang, P. Maniatis, and D. Wagner, “The performance cost of shadow stacks and stack canaries,” in Proc. ACM Asia Conference on Computer and Communications Security (ASIA CCS), 2015, pp. 555–566.DOI