Abstract and concrete categories
Abstract and concrete categories
Static analysis of linear congruence equalities among variables of a program
TAPSOFT '91 Proceedings of the international joint conference on theory and practice of software development on Colloquium on trees in algebra and programming (CAAP '91): vol 1
On the undecidability of partial polymorphic type reconstruction
Fundamenta Informaticae - Special issue: lambda calculus and type theory
Safe kernel extensions without run-time checking
OSDI '96 Proceedings of the second USENIX symposium on Operating systems design and implementation
Pizza into Java: translating theory into practice
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
First-class polymorphism with type inference
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A specification of Java loading and bytecode verification
CCS '98 Proceedings of the 5th ACM conference on Computer and communications security
From system F to typed assembly language
ACM Transactions on Programming Languages and Systems (TOPLAS)
A certifying compiler for Java
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Type-preserving compilation of Featherweight Java
ACM Transactions on Programming Languages and Systems (TOPLAS)
Java Virtual Machine Specification
Java Virtual Machine Specification
MLF: raising ML to the power of system F
ICFP '03 Proceedings of the eighth ACM SIGPLAN international conference on Functional programming
Stack-based typed assembly language
Journal of Functional Programming
Type-based verification of sssembly language for compiler debugging
TLDI '05 Proceedings of the 2005 ACM SIGPLAN international workshop on Types in languages design and implementation
A simple typed intermediate language for object-oriented languages
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Type-preserving compilation for large-scale optimizing object-oriented compilers
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
HMF: simple type inference for first-class polymorphism
Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Fissile type analysis: modular checking of almost everywhere invariants
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Hi-index | 0.00 |
A certifying compiler preserves type information through compilation to assembly language programs, producing typed assembly language (TAL) programs that can be verified for safety independently so that the compiler does not need to be trusted. There are two challenges for adopting certifying compilation in practice. First, requiring every compiler transformation and optimization to preserve types is a large burden on compilers, especially when adopting certifying compilation into existing optimizing non-certifying compilers. Second, type annotations significantly increase the size of assembly language programs. This paper proposes an alternative to traditional certifying compilers. It presents iTalX, the first inferable TAL type system that supports existential types, arrays, interfaces, and stacks. We have proved our inference algorithm is complete, meaning if an assembly language program is typeable with iTalX then our algorithm will infer an iTalX typing for that program. Furthermore, our algorithm is guaranteed to terminate even if the assembly language program is untypeable. We demonstrate that it is practical to infer such an expressive TAL by showing a prototype implementation of type inference for code compiled by Bartok, an optimizing C# compiler. Our prototype implementation infers complete type annotations for 98% of functions in a suite of realistic C# benchmarks. The type-inference time is about 8% of the compilation time. We needed to change only 2.5% of the compiler code, mostly adding new code for defining types and for writing types to object files. Most transformations are untouched. Type-annotation size is only 17% of the size of pure code and data, reducing type annotations in our previous certifying compiler [4] by 60%. The compiler needs to preserve only essential type information such as method signatures, object-layout information, and types for static data and external labels. Even non-certifying compilers have most of this information available.