Finding typing compiler bugs

Stefanos Chaliasos; Thodoris Sotiropoulos; Diomidis Spinellis; Arthur Gervais; Benjamin Livshits; Dimitris Mitropoulos

doi:10.1145/3519939.3523427

Finding typing compiler bugs

Stefanos Chaliasos, Thodoris Sotiropoulos, Diomidis Spinellis, Arthur Gervais, Benjamin Livshits, Dimitris Mitropoulos

Software Engineering

Research output: Chapter in Book/Conference proceedings/Edited volume › Conference contribution › Scientific › peer-review

2 Citations (Scopus)

12 Downloads (Pure)

Abstract

We propose a testing framework for validating static typing procedures in compilers. Our core component is a program generator suitably crafted for producing programs that are likely to trigger typing compiler bugs. One of our main contributions is that our program generator gives rise to transformation-based compiler testing for finding typing bugs. We present two novel approaches (type erasure mutation and type overwriting mutation) that apply targeted transformations to an input program to reveal type inference and soundness compiler bugs respectively. Both approaches are guided by an intra-procedural type inference analysis used to capture type information flow. We implement our techniques as a tool, which we call Hephaestus. The extensibility of Hephaestus enables us to test the compilers of three popular JVM languages: Java, Kotlin, and Groovy. Within nine months of testing, we have found 156 bugs (137 confirmed and 85 fixed) with diverse manifestations and root causes in all the examined compilers. Most of the discovered bugs lie in the heart of many critical components related to static typing, such as type inference.

Original language	English
Title of host publication	PLDI 2022 - Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation
Editors	Ranjit Jhala, Isil Dillig
Publisher	Association for Computing Machinery (ACM)
Pages	183-198
Number of pages	16
ISBN (Electronic)	9781450392655
DOIs	https://doi.org/10.1145/3519939.3523427
Publication status	Published - 2022
Event	43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2022 - Virtual, Online, United States Duration: 13 Jun 2022 → 17 Jun 2022

Publication series

Name	Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

Conference

Conference	43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2022
Country/Territory	United States
City	Virtual, Online
Period	13/06/22 → 17/06/22

Bibliographical note

Green Open Access added to TU Delft Institutional Repository ‘You share, we take care!’ – Taverne project https://www.openaccess.nl/en/you-share-we-take-care
Otherwise as indicated in the copyright section: the publisher is the copyright holder of this work and the author uses the Dutch legislation to make this work public.

Keywords

compiler bugs
compiler testing
Groovy
Java
Kotlin
static typing

Access to Document

10.1145/3519939.3523427

3519939.3523427-1Final published version, 326 KB

Cite this

Chaliasos, S., Sotiropoulos, T., Spinellis, D., Gervais, A., Livshits, B., & Mitropoulos, D. (2022). Finding typing compiler bugs. In R. Jhala, & I. Dillig (Eds.), PLDI 2022 - Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation (pp. 183-198). (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)). Association for Computing Machinery (ACM). https://doi.org/10.1145/3519939.3523427

Chaliasos, Stefanos ; Sotiropoulos, Thodoris ; Spinellis, Diomidis et al. / Finding typing compiler bugs. PLDI 2022 - Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. editor / Ranjit Jhala ; Isil Dillig. Association for Computing Machinery (ACM), 2022. pp. 183-198 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)).

@inproceedings{8661c4855d4b48c5bba98bb21f72ff72,

title = "Finding typing compiler bugs",

abstract = "We propose a testing framework for validating static typing procedures in compilers. Our core component is a program generator suitably crafted for producing programs that are likely to trigger typing compiler bugs. One of our main contributions is that our program generator gives rise to transformation-based compiler testing for finding typing bugs. We present two novel approaches (type erasure mutation and type overwriting mutation) that apply targeted transformations to an input program to reveal type inference and soundness compiler bugs respectively. Both approaches are guided by an intra-procedural type inference analysis used to capture type information flow. We implement our techniques as a tool, which we call Hephaestus. The extensibility of Hephaestus enables us to test the compilers of three popular JVM languages: Java, Kotlin, and Groovy. Within nine months of testing, we have found 156 bugs (137 confirmed and 85 fixed) with diverse manifestations and root causes in all the examined compilers. Most of the discovered bugs lie in the heart of many critical components related to static typing, such as type inference.",

keywords = "compiler bugs, compiler testing, Groovy, Java, Kotlin, static typing",

author = "Stefanos Chaliasos and Thodoris Sotiropoulos and Diomidis Spinellis and Arthur Gervais and Benjamin Livshits and Dimitris Mitropoulos",

note = "Green Open Access added to TU Delft Institutional Repository {\textquoteleft}You share, we take care!{\textquoteright} – Taverne project https://www.openaccess.nl/en/you-share-we-take-care Otherwise as indicated in the copyright section: the publisher is the copyright holder of this work and the author uses the Dutch legislation to make this work public. ; 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2022 ; Conference date: 13-06-2022 Through 17-06-2022",

year = "2022",

doi = "10.1145/3519939.3523427",

language = "English",

series = "Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)",

publisher = "Association for Computing Machinery (ACM)",

pages = "183--198",

editor = "Ranjit Jhala and Isil Dillig",

booktitle = "PLDI 2022 - Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation",

address = "United States",

}

Chaliasos, S, Sotiropoulos, T, Spinellis, D, Gervais, A, Livshits, B & Mitropoulos, D 2022, Finding typing compiler bugs. in R Jhala & I Dillig (eds), PLDI 2022 - Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Association for Computing Machinery (ACM), pp. 183-198, 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2022, Virtual, Online, United States, 13/06/22. https://doi.org/10.1145/3519939.3523427

Finding typing compiler bugs. / Chaliasos, Stefanos; Sotiropoulos, Thodoris; Spinellis, Diomidis et al.
PLDI 2022 - Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. ed. / Ranjit Jhala; Isil Dillig. Association for Computing Machinery (ACM), 2022. p. 183-198 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)).

Research output: Chapter in Book/Conference proceedings/Edited volume › Conference contribution › Scientific › peer-review

TY - GEN

T1 - Finding typing compiler bugs

AU - Chaliasos, Stefanos

AU - Sotiropoulos, Thodoris

AU - Spinellis, Diomidis

AU - Gervais, Arthur

AU - Livshits, Benjamin

AU - Mitropoulos, Dimitris

N1 - Green Open Access added to TU Delft Institutional Repository ‘You share, we take care!’ – Taverne project https://www.openaccess.nl/en/you-share-we-take-care Otherwise as indicated in the copyright section: the publisher is the copyright holder of this work and the author uses the Dutch legislation to make this work public.

PY - 2022

Y1 - 2022

N2 - We propose a testing framework for validating static typing procedures in compilers. Our core component is a program generator suitably crafted for producing programs that are likely to trigger typing compiler bugs. One of our main contributions is that our program generator gives rise to transformation-based compiler testing for finding typing bugs. We present two novel approaches (type erasure mutation and type overwriting mutation) that apply targeted transformations to an input program to reveal type inference and soundness compiler bugs respectively. Both approaches are guided by an intra-procedural type inference analysis used to capture type information flow. We implement our techniques as a tool, which we call Hephaestus. The extensibility of Hephaestus enables us to test the compilers of three popular JVM languages: Java, Kotlin, and Groovy. Within nine months of testing, we have found 156 bugs (137 confirmed and 85 fixed) with diverse manifestations and root causes in all the examined compilers. Most of the discovered bugs lie in the heart of many critical components related to static typing, such as type inference.

AB - We propose a testing framework for validating static typing procedures in compilers. Our core component is a program generator suitably crafted for producing programs that are likely to trigger typing compiler bugs. One of our main contributions is that our program generator gives rise to transformation-based compiler testing for finding typing bugs. We present two novel approaches (type erasure mutation and type overwriting mutation) that apply targeted transformations to an input program to reveal type inference and soundness compiler bugs respectively. Both approaches are guided by an intra-procedural type inference analysis used to capture type information flow. We implement our techniques as a tool, which we call Hephaestus. The extensibility of Hephaestus enables us to test the compilers of three popular JVM languages: Java, Kotlin, and Groovy. Within nine months of testing, we have found 156 bugs (137 confirmed and 85 fixed) with diverse manifestations and root causes in all the examined compilers. Most of the discovered bugs lie in the heart of many critical components related to static typing, such as type inference.

KW - compiler bugs

KW - compiler testing

KW - Groovy

KW - Java

KW - Kotlin

KW - static typing

UR - http://www.scopus.com/inward/record.url?scp=85132309560&partnerID=8YFLogxK

U2 - 10.1145/3519939.3523427

DO - 10.1145/3519939.3523427

M3 - Conference contribution

AN - SCOPUS:85132309560

T3 - Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

SP - 183

EP - 198

BT - PLDI 2022 - Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation

A2 - Jhala, Ranjit

A2 - Dillig, Isil

PB - Association for Computing Machinery (ACM)

T2 - 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2022

Y2 - 13 June 2022 through 17 June 2022

ER -

Chaliasos S, Sotiropoulos T, Spinellis D, Gervais A, Livshits B, Mitropoulos D. Finding typing compiler bugs. In Jhala R, Dillig I, editors, PLDI 2022 - Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation. Association for Computing Machinery (ACM). 2022. p. 183-198. (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)). doi: 10.1145/3519939.3523427

Finding typing compiler bugs

Abstract

Publication series

Conference

Bibliographical note

Keywords

Access to Document

Other files and links

Fingerprint

Cite this