Home /Modules/decompiler/EXECUTABLE.LIBRARY.SOURCE.REFERENCE.md

EXECUTABLE.LIBRARY.SOURCE.REFERENCE.md

lib/decompiler/EXECUTABLE.LIBRARY.SOURCE.REFERENCE.md · 82 line(s) · markdown

<p align="center"><img src="https://github.com/mearvk/SLeeLa/blob/master/images/sleela/sleela-decompiler-logo-001.jpeg" alt="SLeeLa Decompiler" width="100%"></p>

SLeeLa Executable, Library, and Object to Source Reference Matrix

Max Rupplin - MEARVK LLC - 2026

This is the reverse-reference catalog: artifact -> binary/object/library format -> platform/ABI -> producer/toolchain -> language family -> source forms -> likely source-level reconstruction targets.

Core rule

A binary rarely identifies its original source exactly. The matrix records reference candidates and evidence, not claims of exact provenance. Debug information, symbols, DWARF, PDB/CodeView, source maps, compiler metadata, build IDs, import/export tables, runtime metadata, package manifests, signatures, and reproducible-build/provenance records can strengthen a mapping.

When evidence is insufficient, the result must remain a candidate set.

Native executable and library matrix

Artifact / libraryFormat evidencePlatform evidenceProducer evidenceSource-language candidatesSource references
Linux executableELF ET_EXEC/ET_DYNLinux/Unix ABIGCC/Clang/rustc/go/etc.C, C++, Rust, Go, Fortran, Ada, D, Zig, Haskell, OCaml, Assembly.c, .cpp/.cc/.cxx, .rs, .go, .f*, .adb/.ads, .d, .zig, .hs/.lhs, .ml/.mli, .s/.asm
Linux shared libraryELF ET_DYNLinux/Unix ABIGCC/Clang/rustc/go/etc.C, C++, Rust, Go, Fortran, Ada, D, Zig, Haskell, OCaml, AssemblySame native source families
Windows executablePEWindows PE/COFF + subsystemMSVC, Clang, GCC/MinGW, rustc, Go, .NETC, C++, Rust, Go, C#, F#, VB.NET, Assembly and others.c, .cpp, .rs, .go, .cs, .fs, .vb, .asm
Windows DLLPE DLLWindowsMSVC/Clang/GCC/rustc/Go/.NETC, C++, Rust, Go, C#, F#, VB.NETNative source or managed assembly references
macOS executableMach-ODarwin/macOSClang, Swift, rustc, Go and othersC, C++, Objective-C, Objective-C++, Swift, Rust, Go, Assembly.c, .cpp, .m, .mm, .swift, .rs, .go, .s/.asm
macOS dylibMach-O dylibDarwin/macOSClang/Swift/rustc/etc.C-family, Swift, Rust, Go, AssemblyCorresponding source families
Unix static libraryAR archive containing objectsUnix/toolchainGCC/Clang/other native toolchainsLanguage determined from contained objects and metadataSource family depends on member objects
JVM classClass-file magic/versionJVMjavac, kotlinc, scalac, Eclipse/compiler pluginsJava, Kotlin, Scala and JVM languages.java, .kt/.kts, .scala plus debug/source attributes
JARZIP + JVM metadataJVMjavac/kotlinc/scalac/build systemsJava/Kotlin/Scala/other JVM languagesSource mappings depend on contained classes and metadata
.NET assemblyPE + CLR metadata.NETcsc, fsc, vbc, dotnetC#, F#, Visual Basic .NET and other CLI languages.cs, .fs/.fsi/.fsx, .vb and metadata/PDB
BEAM moduleBEAM VM metadataErlang/BEAMerlc/elixircErlang, Elixir and BEAM languages.erl/.hrl, .ex/.exs and debug chunks
Lua bytecodeLua bytecode signature/versionLua runtimeluac / Lua toolchainLua.lua
WebAssembly moduleWASM magic/versionWASM runtimerustc, clang/LLVM, Go, language-specific compilerRust, C/C++, Go, AssemblyScript and other WASM producersDepends on custom/name/debug sections and producer metadata
LLVM bitcodeLLVM bitcodeLLVM target metadataclang/LLVM frontendsC, C++, Rust, Swift, Fortran, and other LLVM-backed languagesSource mapping strengthened by debug metadata
Raw firmware/imageno universal containerarchitecture/platform evidence requiredtoolchain-specificC, C++, Rust, Assembly and firmware-specific languagesRequires external build/provenance evidence

What can map an executable back to source?

The decompiler should inspect these evidence classes:

  1. Embedded source/debug metadata — DWARF, CodeView/PDB references, JVM source/debug attributes, .NET metadata/PDB, BEAM debug chunks, WASM DWARF/name sections.
  2. Build and provenance metadata — build IDs, reproducible-build identifiers, package metadata, compiler version strings, linker records, signed provenance.
  3. Symbol and linkage information — symbol names, mangling, exports, imports, relocation patterns, runtime helper names.
  4. Compiler fingerprints — code-generation patterns, section conventions, runtime libraries, exception/RTTI models, ABI conventions.
  5. Binary format and OS/ABI — ELF/PE/Mach-O/managed runtime plus architecture and calling convention.
  6. Code structure — control-flow graphs, type recovery, data-flow, calling relationships, strings, constants, and recognizable library implementations.
  7. Filename/extension alone — weak evidence and never sufficient.

Library-to-source resolution

A library should be decomposed before language attribution:

container -> members -> object/code/data members -> symbols/debug/provenance -> producer -> language candidates -> source candidates

An AR archive does not itself imply C. Its members may have been produced from C, C++, Rust, Fortran, Ada, or assembly. Likewise, an ELF shared object does not by itself identify its source language.

Source reconstruction levels

The output should retain which level produced each conclusion.

Reference artifact classes

The decompiler reference system should maintain mappings for executable, shared library, dynamic library, static library, object file, archive, JVM class, JVM archive, .NET assembly, BEAM module, Lua bytecode, WebAssembly module, LLVM IR/bitcode, firmware/raw image, and core/crash artifacts where supported.

Safety

Reverse mapping is analysis-only by default. The system must not load or execute a library merely to identify it. Any sandboxed dynamic analysis must be a separately governed capability with explicit policy, isolation, provenance checks, and resource limits.

Reverse resolution model

artifact -> container/format -> architecture -> OS/ABI -> library/object members -> debug/provenance -> producer -> language candidates -> version candidates -> source references -> reconstructed output

The result is an evidence graph, not a single guessed source language.

SLeeLa — MEARVK LLC — 2026