{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-llvm-mirror--llvm","slug":"llvm-mirror--llvm","name":"llvm","type":"repo","url":"http://llvm.org","page_url":"https://unfragile.ai/llvm-mirror--llvm","categories":["frameworks-sdks"],"tags":["code-generation","intermediate-representation","llvm","optimization","virtual-machine"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-llvm-mirror--llvm__cap_0","uri":"capability://code.generation.editing.llvm.ir.parsing.and.ast.construction.from.text","name":"llvm ir parsing and ast construction from text","description":"Parses LLVM IR assembly language text into an in-memory Abstract Syntax Tree using a hand-written lexer (LLLexer.cpp) and recursive descent parser (LLParser.cpp) that tokenizes input and builds IR objects. The parser validates syntax during construction and integrates with LLVMContext for type and value interning, enabling downstream optimization and code generation passes to operate on a unified IR representation.","intents":["I need to load LLVM IR from a .ll file and convert it into an in-memory representation my compiler can manipulate","I want to programmatically construct LLVM IR by parsing text input from a frontend compiler","I need to validate LLVM IR syntax and report parsing errors with line/column information"],"best_for":["compiler frontend developers targeting LLVM","language implementers building custom IR loaders","optimization framework builders needing IR introspection"],"limitations":["Parser is single-pass and does not support forward references to undefined values without explicit declaration","No incremental parsing — entire IR module must be parsed before optimization passes can run","Error recovery is minimal; first parse error halts processing"],"requires":["LLVM C++ API headers (include/llvm/IR/)","LLVMContext instance for type/value interning","Valid LLVM IR syntax conforming to LangRef.rst specification"],"input_types":["LLVM IR assembly text (.ll files)","LLVM IR string buffers in memory"],"output_types":["Module object containing Functions, BasicBlocks, and Instructions","Diagnostic messages with source location information"],"categories":["code-generation-editing","parser-infrastructure"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_1","uri":"capability://data.processing.analysis.llvm.ir.bitcode.serialization.and.deserialization","name":"llvm ir bitcode serialization and deserialization","description":"Encodes LLVM IR modules into a compact binary bitcode format (BitcodeWriter.cpp) and decodes them back (BitcodeReader.cpp) using a custom variable-length integer encoding and block-based structure. The bitcode format preserves all IR semantics while reducing file size by 80-90% compared to text IR, enabling efficient caching and transmission of compiled modules across the toolchain.","intents":["I need to serialize LLVM IR to disk in a compact binary format for fast loading in later compilation stages","I want to cache compiled LLVM IR modules to avoid re-parsing and re-optimizing identical source code","I need to transmit LLVM IR between distributed compilation nodes without text serialization overhead"],"best_for":["build system integrators using LLVM for incremental compilation","distributed compiler infrastructure teams","embedded systems developers optimizing for storage constraints"],"limitations":["Bitcode format is version-specific; modules compiled with LLVM 14 may not load in LLVM 13 without compatibility shims","No streaming deserialization — entire bitcode file must be loaded into memory before IR construction begins","Bitcode format is not human-readable; debugging requires llvm-dis tool to convert back to text"],"requires":["LLVM bitcode reader/writer libraries (lib/Bitcode/)","Module object to serialize or target LLVMContext for deserialization","Bitcode compatibility version matching (checked via BitcodeReader::getVersionNumber)"],"input_types":["LLVM Module objects (for writing)","Bitcode binary files (.bc files) or memory buffers (for reading)"],"output_types":["Bitcode binary data","LLVM Module objects reconstructed from bitcode"],"categories":["data-processing-analysis","serialization-infrastructure"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_10","uri":"capability://planning.reasoning.attributor.framework.for.interprocedural.analysis.and.attribute.inference","name":"attributor framework for interprocedural analysis and attribute inference","description":"Implements a generic interprocedural analysis framework (Attributor) that infers function and value attributes (e.g., 'nonnull', 'noalias', 'returned') by analyzing call graphs and data flow. Uses a fixpoint iteration algorithm to propagate attribute information across function boundaries, enabling optimizations that depend on global properties (e.g., eliminating null checks for provably non-null values, removing redundant synchronization).","intents":["I want to infer that a function parameter is always non-null and eliminate null checks at call sites","I need to prove that two pointers don't alias and enable aggressive optimization","I want to determine that a function always returns one of its arguments and optimize away temporary variables"],"best_for":["compiler developers building interprocedural optimizers","static analysis tool builders inferring program properties","optimization framework designers extending attribute inference"],"limitations":["Attributor analysis is expensive and may not scale to very large programs; typically run only on hot functions or with limited iteration depth","Attribute inference is conservative and may miss opportunities if function implementations are unavailable (e.g., external libraries)","Fixpoint iteration can be slow for programs with complex call graphs; heuristics are needed to limit analysis scope"],"requires":["LLVM Module with function definitions","CallGraph or similar call graph representation","Optional: custom attribute definitions and inference rules"],"input_types":["LLVM Module or Function objects"],"output_types":["Inferred attributes on functions and values (e.g., 'nonnull', 'noalias', 'returned')","Optimized IR with redundant checks and operations eliminated"],"categories":["planning-reasoning","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_11","uri":"capability://data.processing.analysis.llvm.readobj.binary.inspection.and.metadata.extraction","name":"llvm-readobj binary inspection and metadata extraction","description":"Provides a command-line tool (llvm-readobj) that parses and displays information from compiled object files and executables in multiple formats (ELF, Mach-O, COFF, WebAssembly). Extracts metadata such as symbol tables, relocation information, section headers, and debug information, enabling inspection of compiled code without disassembly. Supports multiple output formats (raw, JSON, YAML) for integration with other tools.","intents":["I need to inspect the symbol table and relocation information in an object file to debug linking issues","I want to extract debug information from a compiled binary to understand code layout and variable locations","I need to analyze the structure of a compiled executable to understand code generation decisions"],"best_for":["systems programmers debugging linker and loader issues","compiler developers analyzing code generation output","reverse engineers and security researchers analyzing compiled binaries"],"limitations":["llvm-readobj is a read-only inspection tool; it cannot modify object files or executables","Output format varies significantly across object file formats (ELF, Mach-O, COFF), making it difficult to write portable analysis scripts","Debug information extraction requires symbol table and DWARF/CodeView parsing, which may be incomplete for stripped binaries"],"requires":["Compiled object file or executable (ELF, Mach-O, COFF, or WebAssembly format)","llvm-readobj binary or LLVM libraries for programmatic access"],"input_types":["Object files (.o, .obj)","Executables (.elf, .exe, .mach-o)","Shared libraries (.so, .dll, .dylib)"],"output_types":["Human-readable text output (symbol tables, sections, relocations)","Structured output (JSON, YAML) for programmatic processing"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_12","uri":"capability://automation.workflow.pass.management.and.optimization.pipeline.orchestration","name":"pass management and optimization pipeline orchestration","description":"Provides a PassManager infrastructure that orchestrates the execution of optimization passes (InstCombine, LoopUnroll, etc.) in a specified order, managing dependencies between passes and invalidating cached analysis results when IR is modified. Supports both legacy PassManager (function-pass and module-pass based) and new PassManager (analysis-driven) architectures, enabling flexible composition of optimization pipelines.","intents":["I need to run a sequence of optimization passes on LLVM IR in the correct order, respecting dependencies","I want to customize the optimization pipeline for my use case (e.g., aggressive optimization for performance, minimal optimization for fast compilation)","I need to debug optimization passes by running them selectively and inspecting intermediate IR"],"best_for":["compiler developers building custom optimization pipelines","JIT compiler engineers tuning optimization levels","LLVM infrastructure maintainers extending pass management"],"limitations":["Legacy PassManager has implicit dependencies that are difficult to reason about; new PassManager is more explicit but less mature","Pass ordering can significantly affect optimization quality; finding optimal orderings requires empirical tuning","Some passes have high compilation overhead and may not be suitable for JIT compilation; careful selection is needed"],"requires":["LLVM Module or Function to optimize","PassManager instance (legacy or new)","Registered optimization passes (InstCombine, LoopUnroll, etc.)"],"input_types":["LLVM Module or Function objects"],"output_types":["Optimized LLVM Module or Function"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_2","uri":"capability://safety.moderation.ir.verification.and.type.checking","name":"ir verification and type checking","description":"Validates LLVM IR correctness by traversing the Module/Function/BasicBlock/Instruction hierarchy and checking invariants such as type consistency, use-def chains, dominance properties, and instruction legality via the Verifier pass (lib/IR/Verifier.cpp). The verifier reports violations as diagnostic messages and can optionally abort compilation, preventing invalid IR from reaching code generation.","intents":["I need to validate that IR generated by my frontend is well-formed before passing it to optimization passes","I want to detect type mismatches, undefined values, and structural violations in LLVM IR","I need to ensure IR invariants are maintained after each optimization pass to catch bugs in pass implementations"],"best_for":["compiler frontend developers building custom IR generators","optimization pass developers debugging pass correctness","LLVM infrastructure maintainers validating IR transformations"],"limitations":["Verifier is conservative and may reject valid IR in edge cases involving complex type systems or target-specific attributes","Verification adds 5-15% overhead to compilation time and is typically disabled in production builds","Does not verify semantic correctness (e.g., that a function's behavior matches its specification), only structural and type correctness"],"requires":["LLVM Module object to verify","Verifier pass infrastructure (FunctionPass or ModulePass)","Optional: custom verification rules via Attribute metadata"],"input_types":["LLVM Module, Function, or BasicBlock objects"],"output_types":["Diagnostic messages (errors or warnings)","Boolean result indicating whether IR is valid"],"categories":["safety-moderation","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_3","uri":"capability://code.generation.editing.instcombine.peephole.optimization.with.pattern.matching","name":"instcombine peephole optimization with pattern matching","description":"Implements a pattern-driven peephole optimizer (lib/Transforms/InstCombine/) that matches instruction sequences and replaces them with semantically equivalent but more efficient instructions. Uses the PatternMatch.h infrastructure to express patterns declaratively (e.g., 'match (a + b) + c and replace with a + (b + c)'), iteratively applying transformations until a fixed point is reached. Handles arithmetic, logical, comparison, and shift operations across integer and floating-point types.","intents":["I want to eliminate redundant instructions and simplify arithmetic expressions generated by my frontend","I need to fold constant expressions and propagate known values through the IR","I want to canonicalize instruction sequences to enable downstream optimizations like loop unrolling or vectorization"],"best_for":["compiler developers targeting performance-critical code","JIT compiler builders needing fast, lightweight optimization","language implementers optimizing generated IR before code generation"],"limitations":["InstCombine is greedy and may not find globally optimal instruction sequences; some patterns require multiple passes or interaction with other passes","Pattern matching overhead can be significant for large functions; typically runs in O(n²) time in worst case due to iterative refinement","Does not handle memory operations (loads/stores) or function calls; requires separate passes for alias analysis and interprocedural optimization"],"requires":["LLVM Function or Module to optimize","InstCombine pass registered in PassManager","Optional: TargetLibraryInfo for library function recognition"],"input_types":["LLVM Function or Module containing Instructions"],"output_types":["Optimized LLVM Function or Module with simplified instructions"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_4","uri":"capability://data.processing.analysis.constant.range.analysis.and.value.range.propagation","name":"constant range analysis and value range propagation","description":"Analyzes the possible range of values that variables can hold at each program point using interval arithmetic and constraint propagation (ConstantRange analysis). Tracks lower and lower bounds for integers and uses this information to optimize comparisons, bounds checks, and conditional branches. Integrates with InstCombine and other passes to eliminate dead code and simplify control flow based on proven value ranges.","intents":["I want to prove that a bounds check is always true or always false and eliminate it","I need to determine the range of possible values for a variable to optimize conditional branches","I want to detect integer overflow/underflow conditions statically and warn or optimize accordingly"],"best_for":["systems programmers optimizing safety-critical code with bounds checks","compiler developers building optimizing JITs","static analysis tool builders detecting integer overflow vulnerabilities"],"limitations":["Range analysis is conservative and may not track ranges through complex control flow or loops without additional loop analysis","Assumes two's complement integer arithmetic; behavior is undefined for signed overflow, limiting optimization opportunities","Does not track ranges for floating-point values or non-integer types"],"requires":["LLVM IR with integer operations","Optional: ScalarEvolution pass for loop-aware range analysis","Optional: DominatorTree for control flow-aware range refinement"],"input_types":["LLVM Value objects representing integer variables"],"output_types":["ConstantRange objects representing [lower, upper) bounds","Optimized IR with eliminated bounds checks and simplified branches"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_5","uri":"capability://code.generation.editing.selectiondag.based.code.generation.with.target.specific.lowering","name":"selectiondag-based code generation with target-specific lowering","description":"Converts LLVM IR into a Directed Acyclic Graph (DAG) of operations (SelectionDAG) that represents computation at a level closer to target machine instructions. The SelectionDAG Builder (lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp) translates IR instructions into DAG nodes, the DAG Combiner optimizes the DAG, and target-specific instruction selection lowers DAG nodes to machine instructions. This multi-phase approach enables target-independent optimization before target-specific lowering.","intents":["I need to generate efficient machine code from LLVM IR for a specific target architecture (x86, ARM, AMDGPU, etc.)","I want to perform target-independent optimizations (DAG combining) before target-specific instruction selection","I need to handle target-specific instruction patterns and constraints (e.g., x86 addressing modes, ARM conditional execution)"],"best_for":["backend developers implementing new target architectures","compiler engineers optimizing code generation for specific CPUs","LLVM infrastructure maintainers extending code generation capabilities"],"limitations":["SelectionDAG construction and optimization adds 20-40% to compilation time compared to direct IR-to-machine-code lowering","DAG size can explode for complex IR patterns, requiring heuristics to limit DAG node count and prevent memory exhaustion","Target-specific lowering requires detailed knowledge of instruction sets and calling conventions; porting to new targets is labor-intensive"],"requires":["LLVM IR Function to lower","Target-specific TargetLowering implementation (e.g., X86TargetLowering, ARMTargetLowering)","MachineFunction and MachineBasicBlock objects for code generation","Register allocation and instruction scheduling passes"],"input_types":["LLVM IR Functions"],"output_types":["MachineInstructions organized into MachineBasicBlocks","Machine code ready for assembly or object file generation"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_6","uri":"capability://code.generation.editing.global.instruction.selection.gisel.framework.for.machine.independent.code.generation","name":"global instruction selection (gisel) framework for machine-independent code generation","description":"Provides an alternative to SelectionDAG that uses a machine-independent intermediate representation (MachineIR) to lower LLVM IR to target machine instructions. GISel separates lowering into distinct phases: legalization (ensuring all operations are legal on the target), register bank selection (assigning values to register classes), and instruction selection (matching IR patterns to machine instructions). Enables more modular and extensible code generation compared to SelectionDAG.","intents":["I want to implement code generation for a new target with less boilerplate than SelectionDAG requires","I need to support complex instruction patterns and constraints that are difficult to express in SelectionDAG","I want to reuse code generation logic across multiple related target architectures"],"best_for":["backend developers implementing new or experimental target architectures","compiler teams building custom code generators with domain-specific optimizations","LLVM contributors extending code generation infrastructure"],"limitations":["GISel is still under active development and not all targets are fully ported; some features may be incomplete or unstable","Compilation time can be higher than SelectionDAG due to additional legalization and register bank selection phases","Debugging GISel issues requires understanding multiple intermediate representations (MachineIR, legalized IR, selected instructions)"],"requires":["LLVM IR Function to lower","Target-specific GISel implementation (LegalizerInfo, RegisterBankInfo, InstructionSelector)","MachineFunction and MachineBasicBlock objects","Optional: custom legalization rules and instruction patterns"],"input_types":["LLVM IR Functions"],"output_types":["MachineInstructions organized into MachineBasicBlocks","Machine code ready for assembly or object file generation"],"categories":["code-generation-editing","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_7","uri":"capability://code.generation.editing.x86.target.specific.instruction.selection.and.avx.512.support","name":"x86 target-specific instruction selection and avx-512 support","description":"Implements x86 and x86-64 code generation via X86TargetLowering and X86ISelDAGToDAG, handling complex addressing modes, instruction encoding, and calling conventions. Includes specialized support for AVX-512 SIMD instructions with mask registers, enabling vectorization of loops and data-parallel operations. Handles x86-specific constraints such as two-operand instruction format and limited register availability.","intents":["I need to generate efficient x86-64 machine code from LLVM IR, including SIMD vectorization with AVX-512","I want to leverage x86-specific instruction patterns (e.g., LEA for address computation, conditional moves) to optimize code","I need to handle x86 calling conventions and ABI requirements for function calls and returns"],"best_for":["compiler developers targeting x86-64 processors","performance engineers optimizing code for Intel/AMD CPUs","systems programmers building high-performance runtime systems"],"limitations":["X86 instruction selection is complex and the implementation is large (~10k lines); changes require careful testing to avoid regressions","AVX-512 support is incomplete for some instruction patterns and may fall back to AVX2 in edge cases","x86-specific optimizations (e.g., LEA fusion, register pressure heuristics) may not generalize to other architectures"],"requires":["LLVM IR Function to lower","X86TargetMachine and X86TargetLowering instances","Target CPU specification (e.g., 'skylake-avx512') to enable appropriate instruction sets","Optional: SIMD intrinsics or vectorization metadata in IR"],"input_types":["LLVM IR Functions with scalar or vector operations"],"output_types":["x86-64 MachineInstructions (including AVX-512 instructions if supported)","Machine code ready for assembly or object file generation"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_8","uri":"capability://code.generation.editing.arm.target.code.generation.with.conditional.execution.and.neon.simd","name":"arm target code generation with conditional execution and neon simd","description":"Implements ARM and ARM64 (AArch64) code generation via ARMTargetLowering, handling ARM-specific features such as conditional execution (predicated instructions), Thumb-2 encoding, and NEON SIMD instructions. Supports both 32-bit and 64-bit ARM variants with appropriate calling conventions and ABI requirements. Includes optimizations for ARM's limited instruction set and register constraints.","intents":["I need to generate efficient ARM/ARM64 machine code from LLVM IR for mobile and embedded systems","I want to use ARM conditional execution to eliminate branches and improve code density","I need to vectorize code using NEON SIMD instructions for ARM processors"],"best_for":["mobile app developers building performance-critical code for iOS/Android","embedded systems engineers targeting ARM microcontrollers","compiler developers optimizing for ARM-based cloud infrastructure"],"limitations":["ARM conditional execution is limited to 16 instructions; longer sequences require explicit branches","NEON SIMD support is less mature than x86 AVX support; some vector operations may not be optimized","32-bit ARM instruction set is limited compared to 64-bit AArch64; some optimizations are only available on 64-bit"],"requires":["LLVM IR Function to lower","ARMTargetMachine or AArch64TargetMachine instance","Target CPU specification (e.g., 'cortex-a72') to enable appropriate instruction sets","Optional: NEON intrinsics or vectorization metadata in IR"],"input_types":["LLVM IR Functions with scalar or vector operations"],"output_types":["ARM or AArch64 MachineInstructions (including NEON instructions if supported)","Machine code ready for assembly or object file generation"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-llvm-mirror--llvm__cap_9","uri":"capability://code.generation.editing.amdgpu.target.code.generation.with.register.bank.selection.and.wave.level.parallelism","name":"amdgpu target code generation with register bank selection and wave-level parallelism","description":"Implements AMDGPU (AMD Radeon GPU) code generation via AMDGPUTargetLowering and GISel-based instruction selection. Handles GPU-specific features such as wave-level parallelism (64 or 32 work items executing in lockstep), LDS (local data share) memory, and complex register constraints. Includes register bank selection (AMDGPU Register Bank Selection) to assign values to SGPR (scalar) or VGPR (vector) registers based on usage patterns.","intents":["I need to generate efficient AMDGPU machine code from LLVM IR for GPU compute kernels","I want to optimize register allocation for GPU constraints (limited SGPR/VGPR counts, wave-level execution)","I need to handle GPU-specific memory hierarchies (LDS, global memory, cache) and synchronization primitives"],"best_for":["GPU compute developers building HPC and machine learning kernels","compiler engineers optimizing for AMD Radeon GPUs","LLVM infrastructure maintainers extending GPU code generation"],"limitations":["AMDGPU code generation is complex and target-specific; optimizations may not generalize to other GPU architectures","Register bank selection is a separate phase that adds compilation overhead; incorrect selection can severely degrade performance","LDS memory management requires explicit synchronization and careful layout; incorrect usage can cause deadlocks or data races"],"requires":["LLVM IR Function to lower (typically a GPU kernel)","AMDGPUTargetMachine instance with GPU model specification (e.g., 'gfx906')","GISel infrastructure for instruction selection","Optional: GPU intrinsics for LDS access, synchronization, and wave-level operations"],"input_types":["LLVM IR Functions representing GPU kernels"],"output_types":["AMDGPU MachineInstructions (RDNA or CDNA ISA)","Machine code ready for GPU driver compilation"],"categories":["code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":44,"verified":false,"data_access_risk":"high","permissions":["LLVM C++ API headers (include/llvm/IR/)","LLVMContext instance for type/value interning","Valid LLVM IR syntax conforming to LangRef.rst specification","LLVM bitcode reader/writer libraries (lib/Bitcode/)","Module object to serialize or target LLVMContext for deserialization","Bitcode compatibility version matching (checked via BitcodeReader::getVersionNumber)","LLVM Module with function definitions","CallGraph or similar call graph representation","Optional: custom attribute definitions and inference rules","Compiled object file or executable (ELF, Mach-O, COFF, or WebAssembly format)"],"failure_modes":["Parser is single-pass and does not support forward references to undefined values without explicit declaration","No incremental parsing — entire IR module must be parsed before optimization passes can run","Error recovery is minimal; first parse error halts processing","Bitcode format is version-specific; modules compiled with LLVM 14 may not load in LLVM 13 without compatibility shims","No streaming deserialization — entire bitcode file must be loaded into memory before IR construction begins","Bitcode format is not human-readable; debugging requires llvm-dis tool to convert back to text","Attributor analysis is expensive and may not scale to very large programs; typically run only on hot functions or with limited iteration depth","Attribute inference is conservative and may miss opportunities if function implementations are unavailable (e.g., external libraries)","Fixpoint iteration can be slow for programs with complex call graphs; heuristics are needed to limit analysis scope","llvm-readobj is a read-only inspection tool; it cannot modify object files or executables","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.6294741993318955,"quality":0.35,"ecosystem":0.55,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.550Z","last_scraped_at":"2026-05-03T13:58:37.060Z","last_commit":"2020-09-02T21:11:24Z"},"community":{"stars":4589,"forks":2070,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=llvm-mirror--llvm","compare_url":"https://unfragile.ai/compare?artifact=llvm-mirror--llvm"}},"signature":"qdGtx708tJeQcRNhyC/Fhv4UYBIL68rsYoWf7VTthKwP1WC5n6kwGPLVtzghnL4f92zU9HAQ9An6yLQnSE+7DQ==","signedAt":"2026-06-21T01:11:34.244Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/llvm-mirror--llvm","artifact":"https://unfragile.ai/llvm-mirror--llvm","verify":"https://unfragile.ai/api/v1/verify?slug=llvm-mirror--llvm","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}