Towards Analyzing N-language Polyglot Programs

Technical Summary: Towards Analyzing N-language Polyglot Programs

Problem Statement
The paper addresses a critical gap in static analysis research: the inability of current methodologies to effectively handle polyglot programs involving three or more programming languages. While existing research has made progress on two-language interoperability (e.g., Java-C, Java-JavaScript), modern systems increasingly utilize complex chains involving three languages, such as Android hybrid applications (Java, JavaScript, WebAssembly) or web systems (JavaScript, WebAssembly, Rust).

The authors argue that extending two-language analysis techniques to three or more languages is not merely an engineering scaling issue but a fundamental theoretical and methodological gap. In three-language systems, dataflows traverse multiple runtime abstractions, creating mutual dependencies, cyclic interactions, and "multi-hop" dependencies that traditional frameworks cannot capture. Specifically, the complexity arises from the need to compute mutual fixed points across multiple language boundaries and the difficulty in generating precise inter-procedural call graphs that account for dynamic interactions across the chain.

Methodology and Conceptual Framework
The paper proposes a conceptual framework rather than a specific implemented tool. It categorizes multilingual programs into three communication models:

1. Model I (Different Runtimes): A host language invokes a guest language via a Foreign Function Interface (FFI), with the guest runtime embedded within the host.
2. Model II (Common IR): Multiple languages compile to a shared Intermediate Representation (IR) and execute within a single runtime (e.g., GraalVM, Java/Scala/Kotlin).
3. Model III (Shared Libraries): A guest language is compiled into a shared library (e.g., JNI) and linked with the host.

The authors focus specifically on three-language chains, identifying two primary scenarios:

• One Host, Two Guests: A single host invokes two distinct guests.
• Two Hosts, Two Guests (The Focus): A chain where Language A (Entry) invokes Language B (Middle), which in turn acts as a host for Language C (Bottom). Here, the middle language acts as both a guest and a host.

To formalize this, the authors introduce a MiniDSL (Mini Domain Specific Language) with two abstract components:

• Abstract Language for FFI: Includes constructs like eval(program) for dynamic guest execution and asmcall(program) for low-level calls sharing the host's IR. It introduces BridgeVariables to model shared objects exposing host methods to guests.
• Abstract Assembly Language: Represents the common IR execution model.

The paper analyzes Summary-Based Static Analysis as the primary approach for scalability. It breaks down the challenges into two categories based on the communication model:

1. With Bridge Variables: Analysis must propagate function summaries across language boundaries. A key challenge is the Mutual Fixed Point problem, where incremental updates to dataflows in one language require re-evaluation of dependent languages, leading to combinatorial complexity in convergence.
2. With Common IR: While a shared IR simplifies some aspects, generating a precise Call Graph remains difficult. It requires control flow analysis that is mutually recursive with data flow analysis, particularly when handling callbacks and dynamic dispatch that alter control flow across language semantics.

Key Contributions
The paper makes three primary contributions:

1. Landscape Characterization: It defines the communication models for three-language polyglot systems, distinguishing between direct FFI calls, common IR execution, and shared library integration.
2. Challenge Identification: It identifies specific static analysis hurdles, including:
   • The need for mutual fixed-point computation across multiple language boundaries.
   • The difficulty of incremental propagation of resolved dataflows without full re-analysis.
   • The complexity of generating inter-procedural call graphs that account for cross-boundary dependencies (e.g., eval calls and bridge variable method invocations).
3. Research Roadmap: It proposes a vision for n-language analysis, advocating for a shift from customized two-language tools to unified, language-agnostic frameworks.

Results and Claims
As a conceptual position paper, the work does not present experimental results, benchmarks, or a working prototype. Instead, its "results" are the identification of open research questions and the articulation of a necessary paradigm shift. The authors claim that:

• Three-language systems introduce emergent semantic phenomena (e.g., cyclic shared variables, emergent dataflow transformations) that existing two-language models cannot capture.
• Current two-language analyses fail to scale naturally because they rely on isolated semantic boundaries, which collapse in multi-hop chains.
• Future analysis must move toward modular summary representations that work across boundaries, incremental fixed-point algorithms for efficient convergence, and Intermediate Representations that retain strong language provenance.

Significance
The paper's significance lies in its call to action for the research community to address the "n-language" problem. It argues that the future of software analysis depends on understanding interactions among languages rather than analyzing them in isolation. By highlighting the theoretical gaps in handling multi-hop dependencies and mutual fixed points, the authors aim to stimulate new research directions toward scalable, language-agnostic frameworks capable of reasoning over entire multilingual ecosystems. The work serves as a foundational conceptual map for developing the next generation of static analysis tools for complex, polyglot software systems.