💻 computer science

GapForge: Directed Compiler Fuzzing via Coverage-Gap Analysis

GapForge es una técnica de fuzzing de compiladores basada en LLM y dirigida que identifica y cierra sistemáticamente las brechas de cobertura de cola larga mediante la priorización de archivos poco cubiertos, la inferencia de requisitos de activación de grano fino a través del análisis de diferencias de rutas, y la síntesis iterativa de prompts para superar significativamente a los métodos existentes en cobertura y descubrimiento de errores en GCC y LLVM.

Autores originales: Mingxuan Zhu, Qingyuan Liang, Junjie Chen, Zhihong Xue, Dan Hao

Publicado 2026-07-20

📖 4 min de lectura☕ Lectura para el café

CC BY 4.0

Autores originales: Mingxuan Zhu, Qingyuan Liang, Junjie Chen, Zhihong Xue, Dan Hao

Artículo original bajo licencia CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta es una explicación generada por IA del artículo a continuación. No ha sido escrita ni avalada por los autores. Para mayor precisión técnica, consulte el artículo original. Leer descargo de responsabilidad completo

Imagina que el software que hace funcionar tu teléfono, tu coche o internet es una gigantesca e invisible fábrica. Dentro de esta fábrica, hay millones de diminutos trabajadores (líneas de código) que toman tus instrucciones de alto nivel y las convierten en el lenguaje de máquina que la computadora entiende. Esta fábrica se llama compilador. Si incluso un solo trabajador es perezoso, se confunde o rompe una regla, toda la fábrica puede producir productos basura: programas que fallan, se congelan o hacen algo incorrectamente de forma secreta. Debido a que estas fábricas son tan enormes y complejas, es increíblemente difícil asegurarse de que cada uno de los trabajadores esté siendo vigilado y probado.

Entra en el mundo de las pruebas de software. Piensa en esto como enviar un equipo de inspectores para ver si la fábrica está funcionando correctamente. Durante años, los inspectores han usado dos trucos principales: o lanzan dardos al azar a la fábrica (pruebas aleatorias) o intentan romper cosas retorciendo las instrucciones existentes (pruebas de mutación). Pero aquí está el problema: los inspectores siguen golpeando las esquinas fáciles de alcanzar de la fábrica, dejando completamente ignorados los cuartos traseros polvorientos, oscuros y de difícil acceso. Estos "puntos ciegos" son donde se esconden los errores más peligrosos, esperando para causar problemas. Recientemente, los científicos comenzaron a usar Modelos de Lenguaje de Gran Escala (LLM) —IA superinteligente capaz de escribir código— para ayudar con las inspecciones. Pero incluso estos ayudantes de IA a menudo deambulan sin rumbo, sin saber exactamente qué rincones oscuros necesitan más luz.

Aquí es donde entra en juego una nueva técnica llamada GapForge, que actúa como un detective con un mapa mágico. En lugar de solo lanzar dardos o adivinar, GapForge mira un mapa de la fábrica para ver exactamente qué habitaciones nunca han sido visitadas. Luego utiliza su cerebro de IA para descifrar el "saludo secreto" específico (un tipo de código particular y un ajuste especial) necesario para abrir esas puertas cerradas. Los investigadores probaron esto en dos de las mayores fábricas de compiladores del mundo, GCC y LLVM. Descubrieron que GapForge es un maestro en encontrar estas habitaciones ocultas. En solo 72 horas, cubrió el 68.13% del código central de GCC y el 69.11% del código de LLVM. Puede que eso no parezca el 100%, pero recuerda, el mejor método de IA anterior solo logró alrededor del 64.62% y 65.02%. GapForge no solo aumentó ligeramente las cifras; encontró 24,736 líneas de código más en GCC y 19,798 más en LLVM que los otros métodos pasaron por alto por completo.

¿Cómo lo hace? Piensa en GapForge como un proceso de tres pasos. Primero, escanea el mapa de la fábrica y elige la habitación más "sucia": la que tiene más código sin probar. Segundo, en lugar de solo mirar toda la habitación, hace zoom en el punto polvoriento específico y le pregunta a la IA: "¿Qué tipo de llave necesitamos para abrir esto?". La IA analiza las áreas limpias circundantes para adivinar la combinación exacta de estructuras de código y configuraciones de la fábrica (como encender un interruptor específico) requeridas para llegar al lugar. Tercero, si la IA intenta una llave y no funciona, GapForge recuerda ese fallo. Le dice a la IA: "No intentes eso de nuevo; intenta algo diferente", y la envía de vuelta con un mejor plan. Este ciclo se repite, iluminando lenta pero firmemente cada rincón oscuro.

Los resultados fueron impresionantes. No solo GapForge cubrió más terreno que otras ocho técnicas de primer nivel, sino que también encontró 12 errores del mundo real que se habían estado escondiendo en las sombras. Estos incluyeron 8 fallos de ejecución (donde el compilador simplemente se rindió y se detuvo) y 4 errores de compilación (donde el compilador construyó silenciosamente un programa defectuoso que parecía perfecto). Los investigadores demostraron que cada parte del proceso de GapForge era importante; si eliminaban la "lectura del mapa", la "adivinación de la llave" o el "aprendizaje del error", los resultados empeoraban significativamente. Mientras que otros métodos estaban ocupados generando miles de programas de prueba, GapForge generó menos, pero mucho más inteligentes, demostrando que en el mundo de las pruebas de software, la calidad y la dirección suelen vencer a la pura cantidad.

Resumen Técnico: GapForge

Planteamiento del Problema

Las bases de código de los compiladores modernos, como GCC y LLVM, se caracterizan por una escala y complejidad inmensas, lo que dificulta lograr una cobertura de código exhaustiva. Las técnicas actuales de generación de pruebas —que van desde métodos asistidos por gramática y basados en mutación hasta enfoques recientes basados en Modelos de Lenguaje de Gran Escala (LLM)— operan principalmente de una manera "impulsada por programas". Se centran en generar entradas diversas o en activar errores sin modelar explícitamente qué regiones específicas del compilador están ejercitando. En consecuencia, estos métodos tienden a ejercitar repetidamente rutas de "puntos calientes" (hotspots) activadas con frecuencia, dejando brechas sustanciales de cobertura en la "cola larga" de archivos poco probados y regiones de bordes difíciles de alcanzar. Aunque las técnicas de caja blanca como WhiteFox han intentado abordar esto resumiendo el código de optimización, a menudo dependen de un resumen a nivel de archivo que es demasiado grueso, lo que impide proporcionar la guía detallada necesaria para alcanzar regiones no cubiertas específicas, particularmente aquellas que requieren opciones de compilación o estructuras de programas particulares.

Metodología: GapForge

GapForge es una técnica de generación de pruebas de compilador dirigida por LLM, diseñada para mejorar sistemáticamente la cobertura del código fuente mediante el razonamiento sobre las brechas de cobertura. A diferencia de los fuzzers generales, GapForge trata las regiones de código no cubiertas como objetivos explícitos e itera a través de un proceso de tres pasos para generar programas de prueba que ejerciten estas brechas específicas.

1. Selección de Objetivos Impulsada por la Cobertura

Para abordar el potencial de cobertura desigual a través de miles de archivos fuente, GapForge emplea un mecanismo de selección probabilística en lugar de un muestreo aleatorio.

Puntuación de Exploración: A cada archivo $f$ se le asigna una puntuación $S_f = L_f \times (1 - C_f)^2$ , donde $L_f$ es el recuento de líneas y $C_f$ es la relación de cobertura actual. El término cuadrático amplifica la prioridad de los archivos con baja cobertura.
Probabilidad de Selección: Para evitar que los archivos con alta puntuación dominen el proceso de selección indefinidamente, las puntuaciones se normalizan y transforman en una probabilidad de selección $P_f = 1 - (1 - W_f)^k$ . Esta transformación no lineal asegura que, si bien se favorecen los archivos de alto potencial, los archivos de menor potencial aún reciban una oportunidad de ser seleccionados, equilibrando la exploración y la explotación.

2. Resumen Dirigido

En lugar de resumir un archivo completo, GapForge realiza un análisis detallado en intervalos de líneas no cubiertas específicas.

Emparejamiento de Contexto: Para cada región no cubierta, el sistema la empareja con su "contexto cubierto" inmediatamente envolvente (el código que rodea la brecha).
Análisis de Diferencia de Ruta: Un LLM analiza el contraste entre el contexto cubierto y el objetivo no cubierto. Infiere:
- Rol Funcional: El propósito de alto nivel del archivo dentro del pipeline del compilador.
- Requisitos de Activación: Estructuras de programa específicas (por ejemplo, tipos de datos, patrones de flujo de control) necesarias para dirigir la ejecución hacia el bloque no cubierto.
- Opciones de Compilación: Flags específicos (por ejemplo, -fsanitize, -fdump-ada-spec) requeridos para activar la ruta de código.
Salida: Este proceso produce "Requisitos del Objetivo" estructurados que sirven como instrucciones precisas para el siguiente paso de generación.

3. Síntesis de Prompts con Reflexión de Fallos

GapForge sintetiza un prompt estructurado para el LLM de generación de pruebas integrando tres componentes:

Restricciones Generales: Reglas que aseguran que los programas generados sean válidos, deterministas y lo suficientemente complejos estructuralmente para activar rutas profundas del compilador.
Requisitos del Objetivo: Los objetivos y restricciones específicos derivados del paso de resumen dirigido.
Reflexión de Fallos: Un registro por archivo de los prompts fallidos previos (aquellos que resultaron en errores de compilación o no lograron cubrir nuevas regiones). El sistema recupera un caso de fallo reciente e instruye al LLM para que evite programas estructuralmente similares, creando un bucle de refinamiento iterativo que aleja la generación de estrategias improductivas.

Principales Contribuciones

Marco de Trabajo GapForge: Una técnica basada en LLM que apunta explícitamente a las brechas de cobertura a través de un flujo de trabajo de tres pasos: selección de archivos impulsada por la cobertura, análisis de región detallado (combinando el código no cubierto con el contexto cubierto) y síntesis de prompts consciente de los fallos.
Razonamiento Detallado: A diferencia de los enfoques previos de caja blanca que resumen archivos de forma holística, GapForge infiere requisitos de activación específicos (estructuras de programa y opciones de compilación) para bloques básicos individuales no cubiertos.
Validación Empírica: Experimentos extensos en GCC 14.3.0 y LLVM 19.1.0 que demuestran mejoras significativas sobre las técnicas de vanguardia.
Reproducibilidad: Un paquete público que contiene el código fuente y los datos de la técnica.

Resultados Experimentales

Los autores evaluaron GapForge contra ocho técnicas de vanguardia (incluyendo Csmith, WhiteFox, LegoFuzz y Fuzz4All) en GCC y LLVM durante un periodo de 72 horas.

Mejora de la Cobertura: GapForge logró un 68.13% de cobertura en módulos centrales de GCC y un 69.11% en módulos centrales de LLVM. Esto superó a la técnica de caja blanca de vanguardia previa (WhiteFox) al cubrir 24,736 líneas adicionales en GCC y 19,798 líneas en LLVM.
Ganancias Incrementales: GapForge mejoró las suites de pruebas oficiales de los compiladores añadiendo 3,452 nuevas líneas cubiertas en GCC y 531 en LLLLVM, mientras que varias bases de comparación añadieron cero líneas nuevas a las suites oficiales.
Eficiencia: GapForge logró estos resultados con un consumo de tokens significativamente menor (976K tokens para GCC) en comparación con WhiteFox (2.30M tokens) y LegoFuzz (3.63M tokens).
Descubrimiento de Bugs: La técnica descubrió 12 fallos reales de compiladores (5 en GCC, 7 en LLVM), incluyendo 8 crashes y 4 errores de de compilación incorrecta (miscompilations).
Estudios de Ablación: Eliminar cualquiera de los tres componentes principales (selección de objetivos, resumen dirigido o reflexión de fallos) resultó en una degradación medible del rendimiento, confirmando la necesidad de cada módulo. Específicamente, la ausencia de resumen dirigido o de recomendaciones de opciones de compilación causó las caídas más significativas en la cobertura.

Significancia

El artículo postula que GapForge aborda una limitación crítica en las pruebas de compiladores actuales: la incapacidad de las técnicas existentes para alcanzar sistemáticamente las brechas de cobertura de la "cola larga". Al cambiar de un enfoque impulsado por el programa a uno impulsado por la brecha de cobertura, GapForge proporciona un mecanismo para razonar explícitamente sobre cómo alcanzar regiones de código específicas no probadas. Los resultados sugieren que combinar la retroalimentación de cobertura con el razonamiento detallado de LLM permite probar de manera más eficiente y efectiva sistemas de software complejos y de gran escala como los compiladores, lo que conduce finalmente a una mayor fiabilidad y al descubrimiento de defectos sutiles que permanecen ocultos para los métodos de fuzzing tradicionales.