arxiv: 2604.27486 · v1 · submitted 2026-04-30 · 💻 cs.AR

Recognition: unknown

CuLifter: Lifting GPU Binaries to Typed IR

Chihyo Ahn, Huanzhi Pu, Hyesoon Kim, Jisheng Zhao, Shinnung Jeong

Authors on Pith no claims yet

Pith reviewed 2026-05-07 10:04 UTC · model grok-4.3

classification 💻 cs.AR

keywords binary liftingGPU binariesSASSLLVM IRtype recoveryconstraint propagationbinary analysisCUDA

0 comments

The pith

Recovering register types from GPU's unified file via constraint propagation allows lifting SASS binaries to valid LLVM IR for nearly all functions.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

GPU compilers store every value in one register file and discard type distinctions, so binary tools cannot tell integers from floats or pointers. The paper demonstrates that this lost type information is the main obstacle to lifting GPU binaries into a typed intermediate representation. CuLifter solves the problem by propagating type constraints through the code while detecting conflicts, then rebuilds explicit control flow and groups repeated instruction patterns. On more than twenty-four thousand functions from open-source programs, vendor libraries, and machine-learning runtimes, the lifter produces correct LLVM IR in 99.98 percent of cases. An ablation test shows that removing the type-recovery step alone causes the lifted code to fail every x86 execution test.

Core claim

We present CuLifter, a SASS-to-LLVM IR lifting framework that recovers register types via constraint propagation with conflict detection, reconstructs explicit control flow, and aggregates multi-instruction patterns. Across eight benchmark suites comprising 24,437 GPU functions in 919 cubins, CuLifter successfully lifts 99.98% of functions to valid LLVM IR. An ablation study confirms that type recovery is the only step required to produce semantically correct IR: disabling it drops the x86 pass rate from 73.8% to 0%.

What carries the argument

Constraint propagation with conflict detection that infers register types from usage patterns across the single unified GPU register file.

Load-bearing premise

Constraint propagation with conflict detection can accurately recover register types from the unified GPU register file for the vast majority of real-world code without introducing semantic errors in the lifted IR.

What would settle it

A new benchmark suite containing GPU functions with ambiguous or conflicting type usages that the propagation rules cannot resolve would produce incorrect LLVM IR or runtime mismatches when the lifted code is executed.

Figures

Figures reproduced from arXiv: 2604.27486 by Chihyo Ahn, Huanzhi Pu, Hyesoon Kim, Jisheng Zhao, Shinnung Jeong.

**Figure 1.** Figure 1: Type recovery walkthrough for Listing 1. The floatadd definition establishes Float32. The integer use triggers an empty intersection; a bitcast is inserted at the use site. The subsequent float use requires no bitcast. 4 Solution Approach This section presents our solutions to the two key technical problems at an algorithmic level, independent of SASS-specific details. Section 5 describes the GPU-specifi… view at source ↗

**Figure 2.** Figure 2: The CuLifter lifting pipeline. SASS is transformed into LLVM IR through three stages: (1) Control flow recovery with view at source ↗

**Figure 4.** Figure 4: Iterative Propagation and Conflict Detection walk view at source ↗

**Figure 3.** Figure 3: Type lattice used by CuLifter. 5.4.1 Type Domain and Lattice. As shown in figure 3, we partition the lattice into width-based subsets to enable propagation through type-agnostic instructions. The seeding stage differentiates instructions by both the opcode and the modifier. For example, the 16-bit family contains half and bfloat datatypes, which occupies the same register width but encode different expon… view at source ↗

**Figure 5.** Figure 5: Instruction classification by recovery role per appli view at source ↗

**Figure 6.** Figure 6: Proportion of type by type recovery across domains. view at source ↗

**Figure 7.** Figure 7: Value resolution by domain (stacked percentage). view at source ↗

**Figure 8.** Figure 8: Analysis of benchmark propagation chains and view at source ↗

**Figure 9.** Figure 9: Ablation on HeCBench (229 kernels, x86 backend). view at source ↗

**Figure 11.** Figure 11: Distribution of instruction patterns at type bound view at source ↗

read the original abstract

GPU compilers merge all data types into a single unified register file, erasing the type information that binary-analysis tools rely on. We show that type recovery from this untyped register file is the central challenge of GPU binary lifting. We present CuLifter, a SASS-to-LLVM IR lifting framework that recovers register types via constraint propagation with conflict detection, reconstructs explicit control flow, and aggregates multi-instruction patterns. Across eight benchmark suites (24,437 GPU functions in 919 cubins) spanning open-source applications, vendor libraries, and optimized ML runtimes, CuLifter successfully lifts 99.98% of functions to valid LLVM IR. An ablation study confirms that type recovery is the only step required to produce semantically correct IR: disabling it drops the x86 pass rate from 73.8% to 0%, a 73.8 percentage-point drop.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

CuLifter gives a working SASS-to-LLVM lifter that recovers types via constraint propagation and hits very high lift rates on a broad set of real GPU code.

read the letter

The main point is that this paper builds a concrete SASS-to-LLVM lifting system where type recovery from the unified GPU register file is treated as the central problem. They use constraint propagation with conflict detection, add control-flow reconstruction, and aggregate multi-instruction patterns to produce typed IR. The evaluation runs across 24,437 functions in 919 cubins drawn from open-source apps, vendor libraries, and ML runtimes, reaching 99.98% success lifting to valid LLVM IR. The ablation is direct: removing type recovery drops the x86 pass rate from 73.8% to 0%, which supports their claim that types are the load-bearing piece for getting usable IR. That scale and the clean ablation are the strongest parts of the work. The approach is new in its focused handling of GPU binary specifics at this volume, and the implementation plus external benchmarks count as real evidence rather than just claims. Soft spots are modest. The x86 pass rate is an indirect proxy for semantic correctness, so it could miss some subtle mismatches even if the IR is syntactically valid. The benchmarks are diverse but still leave room for questions about how well the method covers unusual register pressure or control-flow patterns in production kernels. Edge-case handling for type conflicts would benefit from more explicit discussion or examples. This paper is for people working on GPU binary analysis, decompilation, or compiler tools that need to move from low-level GPU code to higher-level IR. A reader who cares about practical lifting infrastructure would get value from the results and the ablation. It deserves peer review because the system is implemented, the evaluation is substantial, and the core technique is testable.

Referee Report

1 major / 2 minor

Summary. The paper presents CuLifter, a SASS-to-LLVM IR lifting framework for GPU binaries. It recovers register types from the unified register file via constraint propagation with conflict detection, reconstructs explicit control flow, and aggregates multi-instruction patterns. On 24,437 GPU functions from 919 cubins across eight benchmark suites (open-source apps, vendor libraries, optimized ML runtimes), it lifts 99.98% to valid LLVM IR. An ablation study shows type recovery is the only necessary step for semantically correct IR: disabling it drops the x86 pass rate from 73.8% to 0%.

Significance. If the type recovery is sound, this would be a meaningful contribution to GPU binary analysis and decompilation, as type information is erased in SASS but required for high-level IR. The scale of the evaluation (nearly 25k functions) and the explicit ablation isolating type recovery as the key component are strengths that provide empirical grounding for the central claim.

major comments (1)

[Ablation study] Ablation study (as described): the x86 pass rate is used as the sole proxy for semantic correctness of the lifted IR, but without details on the specific test inputs, coverage, or equivalence-checking method, it is unclear whether this metric would detect all semantic errors that could arise from incorrect type assignments during constraint propagation.

minor comments (2)

[Abstract] The abstract and evaluation description would benefit from a brief statement of any limitations, such as unsupported SASS instructions or cases where conflict detection may conservatively fail.
[Methods] Notation for register types and constraint rules should be introduced with a small example early in the methods to improve readability for readers unfamiliar with SASS.

Simulated Author's Rebuttal

1 responses · 0 unresolved

Thank you for the review and the positive recommendation for minor revision. We appreciate the referee's recognition of the evaluation scale and the ablation study. We address the major comment below.

read point-by-point responses

Referee: [Ablation study] Ablation study (as described): the x86 pass rate is used as the sole proxy for semantic correctness of the lifted IR, but without details on the specific test inputs, coverage, or equivalence-checking method, it is unclear whether this metric would detect all semantic errors that could arise from incorrect type assignments during constraint propagation.

Authors: We agree that the manuscript would benefit from additional details on the ablation study to better substantiate the x86 pass rate as a proxy. The x86 pass rate is computed by compiling the lifted LLVM IR to x86, executing the resulting binaries on a collection of test inputs (derived from the original cubin kernels via random sampling and boundary-value cases), and checking output equivalence against reference results from the original GPU execution. We acknowledge that the current description does not specify the exact input generation process, achieved coverage (e.g., instruction or branch coverage), or the equivalence-checking procedure (including handling of floating-point tolerance). In the revised version we will expand the relevant section to document the test harness, input generation strategy, coverage metrics, and equivalence method. This will clarify the extent to which the metric can surface type-related semantic errors while preserving the central observation that disabling type recovery causes the pass rate to drop from 73.8% to 0%. revision: yes

Circularity Check

0 steps flagged

No significant circularity in derivation chain

full rationale

The paper describes an implemented SASS-to-LLVM IR lifting system whose central claims rest on empirical evaluation across 24,437 external GPU functions drawn from open-source applications, vendor libraries, and ML runtimes, plus an ablation study that isolates the contribution of type recovery. No equations, fitted parameters, self-referential definitions, or load-bearing self-citations appear; the success metric (99.98% valid IR) and the 73.8 percentage-point ablation drop are direct measurements on independent benchmarks rather than quantities derived from the method itself by construction. The argument is therefore self-contained as a systems-engineering result.

Axiom & Free-Parameter Ledger

0 free parameters · 2 axioms · 0 invented entities

The central claim rests on standard assumptions about binary lifting and IR semantics rather than new postulates or fitted values.

axioms (2)

domain assumption LLVM IR can serve as a semantically faithful target for lifted GPU code
Invoked when claiming the output is 'valid LLVM IR' and 'semantically correct'.
domain assumption Register types in SASS binaries are recoverable via constraint propagation without precision loss in practice
This is stated as the central challenge and the core of the solution.

pith-pipeline@v0.9.0 · 5459 in / 1441 out tokens · 109840 ms · 2026-05-07T10:04:45.504278+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

64 extracted references · 39 canonical work pages · 1 internal anchor

[1]

NVIDIA/Cuda-Samples

2026. NVIDIA/Cuda-Samples. NVIDIA Corporation

2026
[2]

Advanced Micro Devices, Inc. (AMD). 2025.HIP Documentation — HIP 7.2.53211 Documentation

2025
[3]

Chihyo Ahn, Ruobing Han, Udit Subramanya, Jisheng Zhao, Blaise Tine, and Hyesoon Kim. 2025. SoftCUDA: Running CUDA on Softcore GPU. In2025 IEEE 33rd Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). 138–142. https://doi.org/10.1109/FCCM62733.2025.00049

work page doi:10.1109/fccm62733.2025.00049 2025
[4]

Anil Altinay, Joseph Nash, Taddeus Kroes, Prabhu Rajasekaran, Dixin Zhou, Adrian Dabrowski, David Gens, Yeoul Na, Stijn Volckaert, Cristiano Giuffrida, Herbert Bos, and Michael Franz. 2020. BinRec: Dynamic Binary Lifting and Recompilation. InProceedings of the 15th European Conference on Computer Systems (EuroSys). https://doi.org/10.1145/3342195.3387550

work page doi:10.1145/3342195.3387550 2020
[5]

Kevin Andryc, Murtaza Merchant, and Russell Tessier. 2013. FlexGrip: A Soft GPGPU for FPGAs. In2013 International Conference on Field-Programmable Tech- nology (FPT). 230–237. https://doi.org/10.1109/FPT.2013.6718358

work page doi:10.1109/fpt.2013.6718358 2013
[6]

Jay Bosamiya, Maverick Woo, and Bryan Parno. 2025. TRex: Practical Type Reconstruction for Binary Code. InProceedings of the 34th USENIX Security Symposium

2025
[7]

Schwartz

David Brumley, Ivan Jager, Thanassis Avgerinos, and Edward J. Schwartz. 2011. BAP: A Binary Analysis Platform. InComputer Aided Verification, Ganesh Gopalakrishnan and Shaz Qadeer (Eds.). Vol. 6806. Springer Berlin Heidelberg, Berlin, Heidelberg, 463–469. https://doi.org/10.1007/978-3-642-22110-1_37

work page doi:10.1007/978-3-642-22110-1_37 2011
[8]

Carter, B

L. Carter, B. Simon, B. Calder, L. Carter, and J. Ferrante. 1999. Predicated Static Single Assignment. In1999 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.PR00425). 245–255. https://doi.org/10.1109/ PACT.1999.807561

work page arXiv 1999
[9]

Sang Kil Cha, Thanassis Avgerinos, Alexandre Rebert, and David Brumley. 2012. Unleashing Mayhem on Binary Code. In2012 IEEE Symposium on Security and Privacy. 380–394. https://doi.org/10.1109/SP.2012.31

work page doi:10.1109/sp.2012.31 2012
[10]

Schwartz, Claire Le Goues, Graham Neubig, and Bogdan Vasilescu

Qibin Chen, Jeremy Lacomis, Edward J. Schwartz, Claire Le Goues, Graham Neubig, and Bogdan Vasilescu. 2022. Augmenting Decompiler Output with Learned Variable Names and Types. In31st USENIX Security Symposium (USENIX Security 22). USENIX Association, Boston, MA, 4327–4343

2022
[11]

Sharan Chetlur, Cliff Woolley, Philippe Vandermersch, Jonathan Cohen, John Tran, Bryan Catanzaro, and Evan Shelhamer. 2014. cuDNN: Efficient Primitives for Deep Learning. https://doi.org/10.48550/arXiv.1410.0759 arXiv:1410.0759 [cs]

work page doi:10.48550/arxiv.1410.0759 2014
[12]

Calder, and J

Weihaw Chuang, B. Calder, and J. Ferrante. 2003. Phi-Predication for Light- Weight If-Conversion. InInternational Symposium on Code Generation and Opti- mization, 2003. CGO 2003.179–190. https://doi.org/10.1109/CGO.2003.1191544

work page doi:10.1109/cgo.2003.1191544 2003
[13]

Cifuentes and M

C. Cifuentes and M. Van Emmerik. 2000. UQBT: Adaptable Binary Translation at Low Cost.Computer33, 3 (March 2000), 60–66. https://doi.org/10.1109/2.825697

work page doi:10.1109/2.825697 2000
[14]

Rosen, Mark N

Ron Cytron, Jeanne Ferrante, Barry K. Rosen, Mark N. Wegman, and F. Kenneth Zadeck. 1991. Efficiently Computing Static Single Assignment Form and the Control Dependence Graph.ACM Trans. Program. Lang. Syst.13, 4 (Oct. 1991), 451–490. https://doi.org/10.1145/115372.115320

work page doi:10.1145/115372.115320 1991
[15]

Fu, Stefano Ermon, Atri Rudra, and Christopher Ré

Tri Dao, Daniel Y. Fu, Stefano Ermon, Atri Rudra, and Christopher Ré. 2022. FLASHATTENTION: Fast and Memory-Efficient Exact Attention with IO- awareness. InProceedings of the 36th International Conference on Neural In- formation Processing Systems (NIPS ’22). Curran Associates Inc., Red Hook, NY, USA, 16344–16359

2022
[16]

Adve, and Christopher W

Sandeep Dasgupta, Sushant Dinesh, Deepan Venkatesh, Vikram S. Adve, and Christopher W. Fletcher. 2020. Scalable Validation of Binary Lifters. InProceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2020). Association for Computing Machinery, New York, NY, USA, 655–671. https://doi.org/10.1145/3385412.3385964

work page doi:10.1145/3385412.3385964 2020
[17]

Alessandro Di Federico, Mathias Payer, and Giovanni Agosta. 2017. Rev.Ng: A Unified Binary Analysis Framework to Recover CFGs and Function Boundaries. InProceedings of the 26th International Conference on Compiler Construction (Cc 2017). Association for Computing Machinery, New York, NY, USA, 131–141. https://doi.org/10.1145/3033019.3033028

work page doi:10.1145/3033019.3033028 2017
[18]

Gregory Frederick Diamos, Andrew Robert Kerr, Sudhakar Yalamanchili, and Nathan Clark. 2010. Ocelot: A Dynamic Optimization Framework for Bulk- Synchronous Applications in Heterogeneous Systems. InProceedings of the 19th International Conference on Parallel Architectures and Compilation Techniques (Pact ’10). Association for Computing Machinery, New York,...

work page doi:10.1145/1854273.1854318 2010
[19]

Artem Dinaburg and Andrew Ruef. 2014. McSema: Static Translation of X86 Instructions to LLVM. REcon

2014
[20]

Khaled ElWazeer, Kapil Anand, Aparna Kotha, Matthew Smithson, and Rajeev Barua. 2013. Scalable Variable and Data Type Detection in a Binary Rewriter. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language De- sign and Implementation (PLDI). 51–60. https://doi.org/10.1145/2491956.2462165

work page doi:10.1145/2491956.2462165 2013
[21]

Bryan Ford and Russ Cox. 2008. Vx32: Lightweight User-Level Sandboxing on the X86. InUSENIX 2008 Annual Technical Conference (ATC’08). USENIX Association, USA, 293–306

2008
[22]

Ruobing Han, Jun Chen, Bhanu Garg, Xule Zhou, John Lu, Jeffrey Young, Jae- woong Sim, and Hyesoon Kim. 2024. CuPBoP: Making CUDA a Portable Lan- guage.ACM Trans. Des. Autom. Electron. Syst.29, 4 (June 2024), 60:1–60:25. https://doi.org/10.1145/3659949

work page doi:10.1145/3659949 2024
[23]

Ruobing Han, Jaewon Lee, Jaewoong Sim, and Hyesoon Kim. 2022. COX : Exposing CUDA Warp-level Functions to CPUs.ACM Trans. Archit. Code Optim. 19, 4 (Sept. 2022), 59:1–59:25. https://doi.org/10.1145/3554736

work page doi:10.1145/3554736 2022
[24]

Niranjan Hasabnis and R. Sekar. 2016. Lifting Assembly to Intermediate Rep- resentation: A Novel Approach Leveraging Compilers. InProceedings of the Twenty-First International Conference on Architectural Support for Programming Languages and Operating Systems (Asplos ’16). Association for Computing Ma- chinery, New York, NY, USA, 311–324. https://doi.org/...

work page doi:10.1145/2872362.2872380 2016
[25]

Hayes, Fei Hua, Jin Huang, Yanhao Chen, and Eddy Z

Ari B. Hayes, Fei Hua, Jin Huang, Yanhao Chen, and Eddy Z. Zhang. 2019. Decod- ing CUDA Binary. InProceedings of the 2019 IEEE/ACM International Symposium on Code Generation and Optimization (CGO 2019). IEEE Press, Washington, DC, USA, 229–241

2019
[26]

Guoliang He and Eiko Yoneki. 2025. CuAsmRL: Optimizing GPU SASS Sched- ules via Deep Reinforcement Learning. InProceedings of the 23rd ACM/IEEE International Symposium on Code Generation and Optimization (CGO). https: //doi.org/10.1145/3696443.3708943

work page doi:10.1145/3696443.3708943 2025
[27]

Jingxuan He, Pesho Ivanov, Petar Tsankov, Veselin Raychev, and Martin Vechev
[28]

InProceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security (CCS ’18)

Debin: Predicting Debug Information in Stripped Binaries. InProceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security (CCS ’18). Association for Computing Machinery, New York, NY, USA, 1667–1680. https://doi.org/10.1145/3243734.3243866

work page doi:10.1145/3243734.3243866 2018
[29]

Ahmed Heakl, Gustavo Bertolo Stahl, Sarim Hashmi, Seung Hun Eddie Han, Salman Khan, and Abdulrahman Mahmoud. 2025. CASS: Nvidia to AMD Tran- spilation with Data, Models, and Benchmark. (Oct. 2025)

2025
[30]

Andrzej Janik. 2026. Vosen/ZLUDA

2026
[31]

Louison Jeanmougin, Pascal Sotin, Christine Rochange, and Thomas Carle. 2023. Warp-Level CFG Construction for GPU Kernel WCET Analysis.OASIcs, Volume 114, WCET 2023114 (2023), 1:1–1:13. https://doi.org/10.4230/OASICS.WCET. 2023.1

work page doi:10.4230/oasics.wcet 2023
[32]

Shinnung Jeong, Chihyo Ahn, Huanzhi Pu, Jisheng Zhao, Hyesoon Kim, and Blaise Tine. 2026. Inside VOLT: Designing an Open-Source GPU Compiler (Tool). InProceedings of the 35th ACM SIGPLAN International Conference on Compiler Construction (Cc ’26). Association for Computing Machinery, New York, NY, USA, 155–167. https://doi.org/10.1145/3771775.3786275

work page doi:10.1145/3771775.3786275 2026
[33]

Zheming Jin and Jeffrey S. Vetter. 2023. A Benchmark Suite for Improving Perfor- mance Portability of the SYCL Programming Model. In2023 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS). 325–327. https://doi.org/10.1109/ISPASS57527.2023.00041

work page doi:10.1109/ispass57527.2023.00041 2023
[34]

Soomin Kim, Markus Faerevaag, Minkyu Jung, SeungIl Jung, DongYeop Oh, JongHyup Lee, and Sang Kil Cha. 2017. Testing Intermediate Representations for Binary Analysis. InProceedings of the 32nd IEEE/ACM International Conference on Automated Software Engineering (Ase ’17). IEEE Press, Urbana-Champaign, IL, USA, 353–364

2017
[35]

Jakub Kroužek and Peter Matula. 2017. RetDec: A Retargetable Machine-Code Decompiler. Botconf

2017
[36]

Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph Gonzalez, Hao Zhang, and Ion Stoica. 2023. Efficient Memory Management for Large Language Model Serving with PagedAtten- tion. InProceedings of the 29th Symposium on Operating Systems Principles (Sosp ’23). Association for Computing Machinery, New York, NY, USA, 611–626...

work page doi:10.1145/3600006.3613165 2023
[37]

JongHyup Lee, Thanassis Avgerinos, and David Brumley. 2011. TIE: Principled Reverse Engineering of Types in Binary Programs. InProceedings of the 18th Annual Network and Distributed System Security Symposium (NDSS)

2011
[38]

Zhibo Liu, Yuanyuan Yuan, Shuai Wang, and Yuyan Bao. 2022. SoK: Demystifying Binary Lifters Through the Lens of Downstream Applications. In2022 IEEE Symposium on Security and Privacy (SP). 1100–1119. https://doi.org/10.1109/ SP46214.2022.9833799

work page arXiv 2022
[39]

LLVM Developer Group. 2025. The LLVM Compiler Infrastructure

2025
[40]

Chris Lomont. 2003. Fast Inverse Square Root

2003
[41]

Navarro, Nancy Hitschfeld-Kahler, and Luis Mateu

Cristóbal A. Navarro, Nancy Hitschfeld-Kahler, and Luis Mateu. 2014. A Survey on Parallel Computing and Its Applications in Data-Parallel Problems Using GPU Architectures.Communications in Computational Physics15, 2 (Feb. 2014), 285–329. https://doi.org/10.4208/cicp.110113.010813a

work page doi:10.4208/cicp.110113.010813a 2014
[42]

Matt Noonan, Alexey Loginov, and David Cok. 2016. Polymorphic Type Infer- ence for Machine Code. InProceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’16). Association for Computing Machinery, New York, NY, USA, 27–41. https://doi.org/10.1145/ 2908080.2908119

work page arXiv 2016
[43]

2020.NVIDIA Ampere Architecture SASS Instruction Set

NVIDIA Corporation. 2020.NVIDIA Ampere Architecture SASS Instruction Set. Technical Report. NVIDIA Corporation

2020
[44]

2024.CUDA Binary Utilities Documentation

NVIDIA Corporation. 2024.CUDA Binary Utilities Documentation

2024
[45]

2025.CUDA Toolkit - Free Tools and Training

NVIDIA Corporation. 2025.CUDA Toolkit - Free Tools and Training

2025
[46]

2025.NVIDIA Parallel Thread Execution (PTX) ISA

NVIDIA Corporation. 2025.NVIDIA Parallel Thread Execution (PTX) ISA. CuLifter: Lifting GPU Binaries to Typed IR

2025
[47]

Stratton, Deming Chen, Jason Cong, and Wen-Mei W

Alexandros Papakonstantinou, Karthik Gururaj, John A. Stratton, Deming Chen, Jason Cong, and Wen-Mei W. Hwu. 2009. FCUDA: Enabling Efficient Compilation of CUDA Kernels onto FPGAs. In2009 IEEE 7th Symposium on Application Specific Processors. 35–42. https://doi.org/10.1109/SASP.2009.5226333

work page doi:10.1109/sasp.2009.5226333 2009
[48]

Jihee Park, Insu Yun, and Sukyoung Ryu. 2025. Bridging the Gap between Real- World and Formal Binary Lifting through Filtered-Simulation. InProceedings of the ACM on Programming Languages, Vol. 9. Article 112. https://doi.org/10.1145/ 3720524

2025
[49]

Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Edward Yang, Zach DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. 2019. PyTorch: An Imperative Style, High-Pe...

2019
[50]

Huanzhi Pu, Rishabh Ravi, Shinnung Jeong, Udit Subramanya, Euijun Chung, Jisheng Zhao, Chihyo Ahn, and Hyesoon Kim. 2025. Hardware vs. Software Implementation of Warp-Level Features in Vortex RISC-v GPU. arXiv:2505.03102 [cs.AR]

work page arXiv 2025
[51]

Soumya Sen, Stepan Vanecek, and Martin Schulz. 2023. GPUscout: Locating Data Movement-related Bottlenecks on GPUs. InProceedings of the SC ’23 Workshops of the International Conference on High Performance Computing, Network, Storage, and Analysis (SC-W ’23). Association for Computing Machinery, New York, NY, USA, 1392–1402. https://doi.org/10.1145/3624062.3624208

work page doi:10.1145/3624062.3624208 2023
[52]

Mojtaba Abaie Shoushtary, Jordi Tubella Murgadas, and Antonio Gonzalez. 2024. Control Flow Management in Modern GPUs. https://doi.org/10.48550/arXiv. 2407.02944 arXiv:2407.02944 [cs]

work page internal anchor Pith review doi:10.48550/arxiv 2024
[53]

Ian Smith. 2025. BinSub: The Simple Essence of Polymorphic Type Inference for Machine Code. InStatic Analysis, Roberto Giacobazzi and Alessandra Gorla (Eds.). Springer Nature Switzerland, Cham, 425–450. https://doi.org/10.1007/978- 3-031-74776-2_17

work page doi:10.1007/978- 2025
[54]

Johnson, David Nellans, Mike O’Connor, and Stephen W

Mark Stephenson, Siva Kumar Sastry Hari, Yunsup Lee, Eiman Ebrahimi, Daniel R. Johnson, David Nellans, Mike O’Connor, and Stephen W. Keckler. 2015. Flexible Software Profiling of GPU Architectures. InProceedings of the 42nd Annual International Symposium on Computer Architecture (ISCA ’15). Association for Computing Machinery, New York, NY, USA, 185–197. ...

work page arXiv 2015
[55]

Stoutchinin and F

A. Stoutchinin and F. de Ferriere. 2001. Efficient Static Single Assignment Form for Predication. InProceedings. 34th ACM/IEEE International Symposium on Mi- croarchitecture. MICRO-34. 172–181. https://doi.org/10.1109/MICRO.2001.991116

work page doi:10.1109/micro.2001.991116 2001
[56]

Hairer, S

John A. Stratton, Sam S. Stone, and Wen-mei W. Hwu. 2008. MCUDA: An Effi- cient Implementation of CUDA Kernels for Multi-core CPUs. InLanguages and Compilers for Parallel Computing, José Nelson Amaral (Ed.). Vol. 5335. Springer Berlin Heidelberg, Berlin, Heidelberg, 16–30. https://doi.org/10.1007/978-3-540- 89740-8_2

work page doi:10.1007/978-3-540- 2008
[57]

Vijay Thakkar, Pradeep Ramani, Cris Cecka, Aniket Shivam, Honghao Lu, Ethan Yan, Jack Kosaian, Mark Hoemmen, Haicheng Wu, Andrew Kerr, Matt Nicely, Duane Merrill, Dustyn Blasig, Aditya Atluri, Fengqi Qiao, Piotr Majcher, Paul Springer, Markus Hohnerbach, Jin Wang, and Manish Gupta. 2023. CUTLASS

2023
[58]

Oreste Villa, Mark Stephenson, David Nellans, and Stephen W. Keckler. 2019. NVBit: A Dynamic Binary Instrumentation Framework for NVIDIA GPUs. In Proceedings of the 52nd Annual IEEE/ACM International Symposium on Microar- chitecture (MICRO-52). Association for Computing Machinery, New York, NY, USA, 372–383. https://doi.org/10.1145/3352460.3358307

work page doi:10.1145/3352460.3358307 2019
[59]

Warter, Scott A

Nancy J. Warter, Scott A. Mahlke, Wen-Mei W. Hwu, and B. Ramakrishna Rau
[60]

InProceedings of the ACM SIGPLAN 1993 Conference on Programming Language Design and Implementation (PLDI ’93)

Reverse If-Conversion. InProceedings of the ACM SIGPLAN 1993 Conference on Programming Language Design and Implementation (PLDI ’93). Association for Computing Machinery, New York, NY, USA, 290–299. https://doi.org/10.1145/ 155090.155118

work page arXiv 1993
[61]

Matthias Wenzl, Georg Merzdovnik, Johanna Ullrich, and Edgar Weippl. 2019. From Hack to Elaborate Technique—A Survey on Binary Rewriting.Acm Com- puting Surveys52, 3 (June 2019), 49:1–49:37. https://doi.org/10.1145/3316415

work page doi:10.1145/3316415 2019
[62]

Chengfeng Ye, Yuandao Cai, Anshunkang Zhou, Heqing Huang, Hao Ling, and Charles Zhang. 2025. Manta: Hybrid-sensitive Type Inference toward Type- Assisted Bug Detection for Stripped Binaries. InProceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 4 (Asplos ’24). Association fo...

work page doi:10.1145/3622781.3674177 2025
[63]

Zhuo Zhang, Yapeng Ye, Wei You, Guanhong Tao, Wen-chuan Lee, Yonghwi Kwon, Yousra Aafer, and Xiangyu Zhang. 2021. OSPREY: Recovery of Vari- able and Data Structure via Probabilistic Analysis for Stripped Binary. In2021 IEEE Symposium on Security and Privacy (SP). 813–832. https://doi.org/10.1109/ SP40001.2021.00051

work page arXiv 2021
[64]

Chang Zhu, Ziyang Li, Anton Xue, Ati Priya Bajaj, Wil Gibbs, Yibo Liu, Rajeev Alur, Tiffany Bao, Hanjun Dai, Adam Doupé, Mayur Naik, Yan Shoshitaishvili, Ruoyu Wang, and Aravind Machiry. 2024. TYGR: Type Inference on Stripped Binaries Using Graph Neural Networks. In33rd USENIX Security Symposium (USENIX Security 24). 4283–4300

2024