编译领域仅限通用传统编译与 AI 编译大类，不包括量子编译，WebAssembly，不包括编程语言相关

2024编译领域论文 (LLVM)

ASPLOS

Volume1

Automatic Generation of Vectorizing Compilers for Customizable Digital Signal Processors

Volume2

Avoiding Instruction-Centric Microarchitectural Timing Channels Via Binary-Code Transformations
Compiling Loop-Based Nested Parallelism for Irregular Workloads
Efficient Microsecond-scale Blind Scheduling with Tiny Quanta
Lightweight Fault Isolation: Practical, Efficient, and Secure Software Sandboxing
METAL: Caching Multi-level Indexes in Domain-Specific Architectures
Multi-Dimensional and Message-Guided Fuzzing for Robotic Programs in Robot Operating System
Plankton: Reconciling Binary Code and Debug Information
Hydride: A Retargetable and Extensible Synthesis-based Compiler for Modern Hardware Architectures
RPG $^2$ : Robust Profile-Guided Runtime Prefetch Generation
Verifying Rust Implementation of Page Tables in a Software Enclave Hypervisor
What You Trace is What You Get: Dynamic Stack-Layout Recovery for Binary Recompilation
SEER: Super-Optimization Explorer for High-Level Synthesis using E-graph Rewriting

Volume3

A shared compilation stack for distributed-memory parallelism in stencil DSLs
Boost Linear Algebra Computation Performance via Efficient VNNI Utilization
C4CAM: A Compiler for CAM-based In-memory Accelerators
Enforcing C/C++ Type and Scope at Runtime for Control-Flow and Data-Flow Integrity
☆Explainable Port Mapping Inference with Sparse Performance Counters
Getting a Handle on Unmanaged Memory
Kaleidoscope: Precise Invariant-Guided Pointer Analysis
Limoncello: Prefetchers for Scale
Longnail: High-Level Synthesis of Portable Custom Instruction Set Extensions
MemSnap μCheckpoints: A Data Single Level Store for Fearless Persistence
Merlin: Multi-tier Optimization of eBPF Code for Performance and Compactness
Pythia: Compiler-Guided Defense Against Non-Control Data Attacks
Siro: Empowering Version Compatibility in Intermediate Representations via Program Synthesis

Volume4

CINM: Compilation for Heterogeneous CINM Systems
Manta: Hybrid-Sensitive Type Inference Toward Type-Assisted Bug Detection for Stripped Binaries
Proactive Runtime Detection of Aging-Related Silent Data Corruptions: A Bottom-Up Approach
The Mutators Reloaded: Fuzzing Compilers with Large Language Model Generated Mutation Operators
Validating JVM Compilers via Maximizing Optimization Interactions

TOSEM

Adonis: Practical andEfficientControl Flow Recovery through OS-level Traces
Finding Near-optimal Configurations inColossal Spaces with Statistical Guarantees
The Human Side of Fuzzing: Challenges Faced by Developers during Fuzzing Activities
On the Caching Schemes toSpeed UpProgram Reduction
Characterizing and Detecting WebAssembly Runtime Bugs
CLFuzz: Vulnerability Detection of Cryptographic Algorithm Implementation via Semantic-awareFuzzing
☆Survey of CodeSearch Based on Deep Learning
Measurement of EmbeddingChoices on Cryptographic API Completion Tasks
Algorithm Selection for Software Verification using GraphNeural Networks
ARCTURUS: Full Coverage Binary Similarity Analysis with Reachability-guided Emulation
Compiler Autotuning through Multiple-phase Learning
A Survey of Source Code Search: A 3-dimensional Perspective
Unveiling Code Pre-Trained Models: Investigating Syntax and Semantics Capacities
Graphuzz: Data-driven Seed Schedulingfor Coverage-guided Greybox Fuzzing
Bitmap-Based Security Monitoring for Deeply Embedded Systems
Timing Side-Channel Mitigation via Automated Program Repair

TOPLAS

Homeostasis: Design andImplementation ofa Self-StabilizingCompiler

TOCS

Effective OS BugDetection with Summary-Based, Alias-Aware

TACO

Autovesk: Automatic Vectorized Code Generatio
COWS for High Performance: Cost Aware Work Stealing for IrregularParallelLoop
Improving Utilization of Dataflow Unitfor Multi-Batch Processing
An Instruction Inflation Analyzing Framework for Dynamic Binary Translators
Orchard: Heterogeneous Parallelism and Fine-grained Fusion for ComplexTreeTraversals
☆A Survey of General-purposePolyhedralCompilers
Asynchronous Memory Access Unit: Exploiting Massive Parallelism for Far Memory Access

PPoPP

A Holistic Approach to Automatic Mixed-Precision Code Generation and Tuning for Affine Programs

PACT

Toast: A Heterogeneous Memory Management System

OSDI

Enabling Tensor Language Model to Assist in Generating High-Performance Tensor Programs for Deep Learning
Data-flow Availability: Achieving Timing Assurance on Autonomous Systems
Automatically Reasoning About How Systems Code Uses the CPU Cache

ISSTA

Fortify Patch: Towards Tamper-Resistant Live Patching in Linux-Based Hypervisor
Precise Compositional Buffer Overflow Detection via Heap Disjointness
Total Recall? How Good AreStatic Call Graphs Really?
☆LPR: Large Language Models-Aided Program Reduction
Evaluating the Effectiveness of Decompilers
Scalable,Sound,and Accurate Jump Table Analysis
An Empirical Study of Static Analysis Tools for Secure Code Review
Sleuth: A Switchable Dual-Mode Fuzzerto Investigate Bug Impacts Following a Single PoC
DDGF: Dynamic Directed Greybox Fuzzing with Path Profiling
Wapplique: Testing WebAssembly Runtime viaExecution Context-Aware Bytecode Mutation
AsFuzzer: Differential Testing of Assemblers with Error-Driven Grammar Inference
Better Not Together: Staged Solving for Context-Free Language Reachability
How Effective Are They? Exploring Large Language Model Based Fuzz Driver Generation
WASMaker: Differential Testing of WebAssembly Runtimes via Semantic-Aware Binary Generation
Fuzzing MLIR Compiler Infrastructure via Operation Dependency Analysis
Towards Understanding the Bugs in Solidity Compiler
Prospector: Boosting Directed Greybox Fuzzing for Large-Scale Target Sets with Iterative Prioritization
An Empirical Examination of Fuzzer Mutator Performance
Logos: Log Guided Fuzzing for Protocol Implementations
PolyTracker: Whole-Input Dynamic Information Flow Tracing
Panda: A Concurrent Scheduler for Compiler-Based Tools

ICSE

Dataflow Analysis-Inspired Deep Learning for Efficient Vulnerability Detection
Reorder Pointer Flow in Sound Concurrency Bug Prediction
☆FAIR: Flow Type-Aware Pre-Training of Compiler Intermediate Representations
Toward Improved Deep Learning-based Vulnerability Detection
FuzzSlice: Pruning False Positives in Static Analysis Warnings Through Function-Level Fuzzing
LibAlchemy: A Two-Layer Persistent Summary Design for Taming Third-Party Libraries in Static Bug-Finding Systems
Precise Sparse Abstract Execution via Cross-Domain Interaction
Concrete Constraint Guided Symbolic Execution
Translation Validation for JIT Compiler in the V8 JavaScript Engine
Prism: Decomposing Program Semantics for Code Clone Detection through Compilation
BinaryAI: Binary Software Composition Analysis via Intelligent Binary Source Code Matching

ICS

Exploiting Vector Code Semantics for Efficient Data Cache Prefetching
Soft Error Resilience at Near-Zero Cost
RTT: Reuse Time Tracking for Use-After-Free Detection
Tile Size and Loop Order Selection using Machine Learning for Multi-/Many-Core Architectures

EuroSys

☆Priority Sampling of Large Language Models for Compilers
LSGraph: A Locality-centric High-performance Streaming Graph Engine
Effective Bug Detection with Unused Definitions
Polynima - Practical Hybrid Recompilation for Multithreaded Binaries

CGO

Energy-Aware Tile Size Selection for Affine Programs on GPUs
AskIt: Unified Programming Interface for Programming with Large Language Models
Revealing Compiler Heuristics through Automated Discovery and Optimization
SLaDe: A Portable Small Language Model Decompiler for Optimized Assembly
Enhancing Performance through Control-Flow Unmerging and Loop Unrolling on GPUs
Retargeting and Respecializing GPU Workloads for Performance Portability
AXI4MLIR: User-Driven Automatic Host Code Generation for Custom AXI-Based Accelerators
PresCount: Effective Register Allocation for Bank Conflict Reduction
Whose Baseline Compiler Is It Anyway?
Enabling Fine-Grained Incremental Builds by Making Compiler Stateful
Compile-Time Analysis of Compiler Frameworks for Query Compilation
Latent Idiom Recognition for a Minimalist Functional Array Language using Equality Saturation
Boosting the Performance of Multi-solver IFDS Algorithms with Flow-Sensitivity Optimizations
Representing Data Collections in an SSA Form
Revamping Sampling-Based PGO with Context-Sensitivity and Pseudo-instrumentation’
Compiler Testing with Relaxed Memory Models
High-Throughput, Formal-Methods-Assisted Fuzzing for LLVM
Experiences Building an MLIR-Based SYCL Compiler
Instruction Scheduling for the GPU on the GPU

ASE

Language-Agnostic Static Analysis of Probabilistic Programs
UFront: Toward A Unified MLIR Frontend for Deep Learning
MaskDroid: Robust Android Malware Detection with Masked Graph Representations
REACT: IR-Level Patch Presence Test for Binary
Semantic-Enhanced Indirect Call Analysis with Large Language Models
WaDec: Decompiling WebAssembly Using Large Language Model
Rust-twins: Automatic Rust Compiler Testing through Program Mutation and Dual Macros Generation
Differential Fuzzing for Data Distribution Service Programs with Dynamic Configuration
Blackbox Observability of Features and Feature Interactions
AXA: Cross-Language Analysis through Integration of Single-Language Analyses
LeanBin: Harnessing Lifting and Recompilation to Debloat Binaries
STASE: Static Analysis Guided Symbolic Execution for UEFI Vulnerability Signature Generation
Shoot Yourself in the Foot — Efficient Code Causes Inefficiency in Compiler Optimizations
Applying Fuzz Driver Generation to Native C/C++ Libraries of OEM Android Framework: Obstacles and Solutions
Industry Practice of Directed Kernel Fuzzing for Open-source Linux Distribution
Efficient Code Causes Inefficiency in Compiler Optimizations

PLDI

A Tensor Compiler with Automatic Data Packing for Simple and Efficient Fully Homomorphic Encryption
A Proof Recipe for Linearizability in Relaxed Memory Separation Logic
Diffy: Data-Driven Bug Finding for Configurations
Boosting Compiler Testing by Injecting Real-World Code
SMT Theory Arbitrage: Approximating Unbounded Constraints using Bounded Theories
Optimistic Stack Allocation and Dynamic Heapification for Managed Runtimes
A Verified Compiler for a Functional Tensor Language
Compiling with Abstract Interpretation
Compilation of Modular and General Sparse Workspaces
Towards Trustworthy Automated Program Verifiers: Formally Validating Translations into an Intermediate Verification Language
GiantSan: Efficient Memory Sanitization with Segment Folding
Greybox Fuzzing for Concurrency Testing
Hydride: A Retargetable and Extensible Synthesis-based Compiler for Modern Hardware Architectures