💻 computer science

GapForge: Directed Compiler Fuzzing via Coverage-Gap Analysis

GapForge is een gerichte, op LLM gebaseerde compiler-fuzzingtechniek die systematisch de 'long-tail' coverage-gaten identificeert en overbrugt door onderbedekte bestanden te prioriteren, gedetailleerde triggervereisten af te leiden via padverschilanalyse, en iteratief prompts te synthetiseren om bestaande methoden aanzienlijk te overtreffen in zowel coverage als het ontdekken van bugs op GCC en LLVM.

Oorspronkelijke auteurs: Mingxuan Zhu, Qingyuan Liang, Junjie Chen, Zhihong Xue, Dan Hao

Gepubliceerd 2026-07-20

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Mingxuan Zhu, Qingyuan Liang, Junjie Chen, Zhihong Xue, Dan Hao

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je de software die je telefoon, je auto of het internet aanstuurt voor als een gigantische, onzichtbare fabriek. Binnen deze fabriek zijn miljoenen kleine arbeiders (regels code) die jouw instructies op hoog niveau omzetten in de machinetaal die de computer begrijpt. Deze fabriek wordt een compiler genoemd. Als zelfs maar één arbeider lui is, in de war raakt of een regel overtreedt, kan de hele fabriek rommelige producten produceren—programma's die crashen, vastlopen of stiekem het verkeerde doen. Omdat deze fabrieken zo groot en complex zijn, is het ongelooflijk moeilijk om ervoor te zorgen dat elke enkele arbeider wordt gecontroleerd en getest.

Welkom in de wereld van softwaretesten. Zie dit als het sturen van een team inspecteurs om te zien of de fabriek wel goed functioneert. Jarenlang hebben inspecteurs twee belangrijke trucs gebruikt: of ze gooien met willekeurige pijltjes naar de fabriek (random testing), of ze proberen dingen kapot te maken door bestaande instructies te verdraaien (mutation testing). Maar hier is het probleem: de inspecteurs raken steeds de gemakkelijke, makkelijk bereikbare hoekjes van de fabriek, waardoor de stoffige, donkere, moeilijk bereikbare achterkamers volledig genegeerd worden. In deze "blinde vlekken" schuilen de gevaarlijkste bugs, wachtend om problemen te veroorzaken. Onlangs begonnen wetenschappers Large Language Models (LLMs) te gebruiken—superintelligente AI die code kan schrijven—om te helpen bij de inspecties. Maar zelfs deze AI-helpers dwalen vaak doelloos rond, zonder precies te weten welke donkere hoekjes het meeste licht nodig hebben.

Dit is waar een nieuwe techniek genaamd GapForge in beeld komt, die fungeert als een detective met een magische kaart. In plaats van alleen maar met pijltjes te gooien of te gokken, kijkt GapForge naar een kaart van de fabriek om precies te zien welke kamers nog nooit zijn bezocht. Vervolgens gebruikt het zijn AI-brein om uit te vogelen wat de specifieke "geheime handdruk" is (een specifiek type code en een speciale instelling) die nodig is om die gesloten deuren te openen. De onderzoekers testten dit op twee van de grootste compiler-fabrieken ter wereld, GCC en LLVM. Ze ontdekten dat GapForge een meester is in het vinden van deze verborgen kamers. In slechts 72 uur dekte het 68,13% van de kerncode van GCC en 69,11% van de LLVM-code. Dat klinkt misschien niet als 100%, maar onthoud dat de vorige beste AI-methode slechts ongeveer 64,62% en 65,02% wist te halen. GapForge tilde de cijfers niet alleen een beetje op; het vond 24.736 extra regels code in GCC en 19.798 extra in LLVM die de andere methoden volledig over het hoofd hadden gezien.

Hoe doet het dit? Denk aan GapForge als een proces van drie stappen. Eerst scant het de kaart van de fabriek en kiest het de "viesste" kamer—de kamer met de meeste ongeteste code. Ten tweede, in plaats van alleen maar naar de hele kamer te kijken, zoomt het in op de specifieke stoffige plek en vraagt het de AI: "Wat voor soort sleutel hebben we nodig om deze te openen?" De AI analyseert de omliggende schone gebieden om de exacte combinatie van codestructuren en fabrieksinstellingen (zoals het omzetten van een specifieke schakelaar) te raden die nodig zijn om die plek te bereiken. Derde, als de AI een sleutel probeert en deze niet werkt, onthoudt GapForge deze mislukking. Het vertelt de AI: "Probeer dat niet nog een keer; probeer iets anders," en stuurt het terug met een beter plan. Deze cyclus herhaalt zich, stap voor stap, terwijl het langzaam maar zeker elke donkere hoek verlicht.

De resultaten waren indrukwekkend. Niet alleen dekte GapForge meer terrein dan acht andere toptechnieken, maar het vond ook 12 echte bugs die in de schaduwen verborgen lagen. Dit omvatte 8 crashes (waarbij de compiler simpelweg opgaf en stopte) en 4 miscompilaties (waarbij de compiler stiekem een defect programma bouwde dat er perfect uitzag). De onderzoekers lieten zien dat elk deel van het proces van GapForge ertoe deed; als ze het "lezen van de kaart", het "raden van de sleutel" of het "leren van fouten" zouden verwijderen, werden de resultaten aanzienlijk slechter. Terwijl andere methoden bezig waren met het genereren van duizenden testprogramma's, genereerde GapForge er minder, maar veel intelligentere, wat bewees dat in de wereld van softwaretesten kwaliteit en richting vaak belangrijker zijn dan pure kwantiteit.

Technische Samenvatting: GapForge

Probleemstelling

Moderne compiler-codebases, zoals GCC en LLVM, worden gekenmerkt door een enorme schaal en complexiteit, wat het moeilijk maakt om een uitgebreide code-dekking te bereiken. Bestaande technieken voor testgeneratie—variërend van grammatica-ondersteunde en mutatiegebaseerde methoden tot recente Large Language Model (LLM) benaderingen—werken primair op een "programma-gestuurde" manier. Ze richten zich op het genereren van diverse inputs of het triggeren van bugs zonder expliciet te modelleren welke specifieke compiler-regio's ze exerceren. Gevolgelijk hebben deze methoden de neiging om herhaaldelijk veelgevraagde "hotspot"-paden te exerceren, waardoor substantiële "long-tail" dekkingskloven in ondergeteste bestanden en moeilijk bereikbare randgebieden overblijven. Hoewel white-box technieken zoals WhiteFox geprobeerd hebben dit aan te pakken door optimalisatiecode te sommeren, vertrouwen zij vaak op grove samenvattingen op bestandsniveau die er niet in slagen de fijnmazige sturing te bieden die nodig is om specifieke ongedekte regio's te bereiken, met name die die specifieke compilatie-opties of programmastructuren vereisen.

Methodologie: GapForge

GapForge is een gerichte, LLM-gebaseerde compiler-testgeneratietechniek die ontworpen is om de broncode-dekking systematisch te verbeteren door te redeneren over dekkingskloven. In tegenstelling tot algemene fuzzers behandelt GapForge ongedekte code-regio's als expliciete doelen en doorloopt het een driestapsproces om testprogramma's te genereren die deze specifieke gaten exerceren.

1. Dekkingsgestuurde Doelselectie

Om de ongelijke dekkingspotentie over duizenden bronbestanden aan te pakken, gebruikt GapForge een probabilistisch selectiemechanisme in plaats van willekeurige sampling.

Exploratiescore: Elk bestand $f$ krijgt een score $S_f = L_f \times (1 - C_f)^2$ , waarbij $L_f$ het aantal regels is en $C_f$ de huidige dekkingsratio. De kwadratische term versterkt de prioriteit van bestanden met een lage dekking.
Selectiekans: Om te voorkomen dat bestanden met een hoge score de selectieprocedure oneindig domineren, worden de scores genormaliseerd en getransformeerd naar een selectiekans $P_f = 1 - (1 - W_f)^k$ . Deze niet-lineaire transformatie zorgt ervoor dat hoewel bestanden met een hoog potentieel worden bevoordeeld, bestanden met een lager potentieel nog steeds een kans krijgen om geselecteerd te worden, wat exploratie en exploitatie in evenwicht brengt.

2. Gerichte Samenvatting

In plaats van een heel bestand samen te vatten, voert GapForge een fijnmazige analyse uit op specifieke ongedekte regelbereiken.

Context Koppeling: Voor elke ongedekte regio koppelt het systeem deze aan de direct omliggende "gedekte context" (de code rondom de kloof).
Pad-verschilanalyse: Een LLM analyseert het contrast tussen de gedekte context en de ongedekte doelstelling. Het concludeert:
- Functionele Rol: Het hoogwaardige doel van het bestand binnen de compiler-pipeline.
- Triggervereisten: Specifieke programmastructuren (bijv. datatypen, controleflowpatronen) die nodig zijn om de executie naar het ongedekte blok te sturen.
- Compilatie-opties: Specifieke vlaggen (bijv. -fsanitize, -fdump-ada-spec) die vereist zijn om het codepad te activeren.
Output: Dit proces levert gestructureerde "Doelvereisten" op die dienen als precieze instructies voor de volgende generatiestap.

3. Prompt Synthese met Falen-reflectie

GapForge synthetiseert een gestructureerde prompt voor de testgeneratie-LLM door drie componenten te integreren:

Algemene Beperkingen: Regels die garanderen dat gegenereerde programma's geldig, deterministisch en structureel complex genoeg zijn om diepe compiler-paden te triggeren.
Doelvereisten: De specifieke doelen en beperkingen afgeleid van de gerichte samenvattingsstap.
Falen-reflectie: Een per-bestand logboek van eerder gefaalde prompts (die resulteerden in compilatiefouten of er niet in slaagden nieuwe regio's te dekken). Het systeem haalt een recent geval van falen op en instrueert de LLM om structureel gelijkaardige programma's te vermijden, wat een iteratieve verfijningslus creëert die de generatie wegstuurt van onproductieve strategieën.

Belangrijkste Bijdragen

GapForge Framework: Een LLM-gebaseerde techniek die expliciet dekkingskloven target via een driestaps workflow: dekkingsgestuurde bestalselectie, fijnmazige regio-analyse (combinatie van ongedekte code met gedekte context), en falen-bewuste prompt synthese.
Fijnmazig Redeneren: In tegenstelling tot eerdere white-box benaderingen die bestanden holistisch sommeren, concludeert GapForge specifieke triggervereisten (programmastructuren en compilatie-opties) voor individuele ongedekte basic blocks.
Empirische Validatie: Uitgebreide experimenten op GCC 14.3.0 en LLVM 19.1.0 die significante verbeteringen laten zien ten opzichte van de huidige state-of-the-art baselines.
Reproduceerbaarheid: Een publieke package met de broncode en data van de techniek.

Experimentele Resultaten

De auteurs evalueerden GapForge tegen acht state-of-the-art technieken (inclusief Csmith, WhiteFox, LegoFuzz en Fuzz4All) op GCC en LLVM over een periode van 72 uur.

Verbetering van Dekking: GapForge bereikte 68,13% dekking op kernmodules van GCC en 69,11% op kernmodules van LLVM. Dit overtrof de vorige state-of-the-art white-box techniek (WhiteFox) door een extra 24.736 regels in GCC en 19.798 regels in LLVM te dekken.
Incrementele Winsten: GapForge verbeterde de officiële testsuites van de compilers door 3.452 nieuwe gedekte regels toe te voegen aan GCC en 531 aan LLVM, terwijl verschillende baselines nul nieuwe regels aan de officiële suites toevoegden.
Efficiëntie: GapForge behaalde deze resultaten met aanzienlijk lager tokenverbruik (976K tokens voor GCC) vergeleken met WhiteFox (2,30M tokens) en LegoFuzz (3,63M tokens).
Bugontdekking: De techniek ontdekte 12 real-world compilerfouten (5 in GCC, 7 in LLVM), inclus_ief 8 crashes en 4 miscompilaties.
Ablatie-studies: Het verwijderen van een van de drie kerncomponenten (doelselectie, gerichte samenvatting of falen-reflectie) resulteerde in een meetbare prestatieverslechtering, wat de noodzaak van elke module bevestigt. Met name de afwezigheid van gerichte samenvatting of aanbevelingen voor compilatie-opties veroorzaakte de meest significante dalingen in dekking.

Betekenis

Het artikel stelt dat GapForge een kritieke beperking in huidige compiler-testen aanpakt: het onvermogen van bestaande technieken om systematisch "long-tail" dekkingskloven te bereiken. Door over te stappen van een programma-gestuurde benadering naar een dekkingskloof-gestuurde benadering, biedt GapForge een mechanisme om expliciet te redeneren over hoe specifieke, ongeteste code-regio's te bereiken. De resultaten suggereren dat het combineren van dekkingsfeedback met fijnmazige LLM-redenering een efficiëntere en effectievere test van grootschalige, complexe softwaresystemen zoals compilers mogelijk maakt, wat uiteindelijk leidt tot een hogere betrouwbaarheid en de ontdekking van subtiele defecten die verborgen blijven voor traditionele fuzzing-methoden.