1 / 22

LX: A Language for Flexible Type Analysis

This work explores the intricacies of type analysis in the context of compiling flexible programming languages. It addresses challenges such as polymorphic subscripts, the preservation of type semantics during compilation, and the necessity of type invariants throughout the compilation process. The collaboration between Cornell University and CMU offers pioneering insights into using types for optimization while ensuring safety in output. By introducing innovative concepts like packed arrays and typecase semantics, the research highlights both the theoretical and practical implications of type analysis in compiler design.

beulah
Télécharger la présentation

LX: A Language for Flexible Type Analysis

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. LX: A Language for Flexible Type Analysis Stephanie Weirich Cornell University joint work with Karl Crary (CMU)

  2. Typed Compilation Terms Types Source IL Machine A series of translations between typed languages, propagating a set of invariants throughout the entire compilation process. Types are used for a variety of optimizations and provide safety assurances about the output of compiler.

  3. Polymorphic Subscript Because any array may be passed to a polymorphic function, all arrays must look the same, no matter the type of their elements. A:array int B:array bool ICFP '98 sub = Fn a:Type => fn (A:array a,i:int) => wordsub(A,i) 06/08/99

  4. Monomorphic subscript In languages such as C, the type of an array is always known at compilation. We can pack boolean values into integer arrays. int A[4] bool B[4] A[2] intsub(A,2) B[2] intsub(B,0)&(1<<2) <> 0 06/08/99

  5. Type Analysis ( liML ) A:array int B:array bool type packedarray(a:Type) = typecase a of int => array int | bool => array int sub = Fn a:Type => fn (A:packedarray a,i:int) => typecase a of int => wordsub(A,i) | bool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0 06/08/99

  6. A Problem What if, during typed compilation, two source types map to the same target type? Source Language false true int bool term compilation type compilation Target Language 0 1 int

  7. An initial attempt Target language contains both source language and target language types, and has a built-in type constructor interp to translate between them. sub = Fn a:S => fn (A:array (interp a),i:int) => typecase a of [int]S=> wordsub(A,i) | [bool]S => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

  8. Issues in Compilation How do we preserve the meaning of typecase when the types themselves change? • type translation may not be injective • in TALx86,intint may be compiled into a variety of types depending on the calling convention, register allocation, etc • In closure conversion, a b converted to c. (a * c  b) * c • larger type takes longer to analyze • typecase is no longer exhaustive

  9. Goal • Need a facility to describe the types of another language, and describe a translation of those types into the types of the current language. • Need a way to examine those representations the term level

  10. Example datakind S=SInt|SBool interp :S -> Type interp = fn a:S => case a of SInt => int | SBool => int sub = Fn a:S => fn (A:array (interp a),i:int) => ccasea of SInt=> wordsub(A,i) | SBool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

  11. LX Language • Type analysis is just a programming idiom • System F augmented with building blocks for datakinds • tuples • sums • primitive recursion • Strongly Normalizing so that type checking is decidable • Term-level ccase

  12. Another Example datakind M =Int |Prodof M * M |ArrowofM * M interp : M -> Type fun interp ( a:M) = case a of Int => int | Prod (c1,c2)) => interp(c1) * interp(c2) | Arrow (c1,c2)) => interp(c1)  interp(c2)

  13. Example fun printf [a:M] (x:interp a) => ccase a of Int=> (* x is of type int *) print_int x Prod(b,c)=> print “<“; printf [b](fst x); print “,”; printf [c] (snd x); print “>” Arrow(b,c) => (* x is of type interp(b)interp(c) *) print “fun” (* x is of typeinterp(Prod(b,c))*) (* x is of typeinterp(b) * interp(c)*)

  14. Type-Analyzing Languages analyze native types analyze constructed types type-passing semantics liML LX type-erasure semantics lR LXvcase

  15. Type-Passing Semantics Types are necessary at run time Requires sophisticated machinery to describe low level languages Abstract kinds and translucent sums for polymorphic typed closure conversion [MMH 96] Type-Erasure Semantics Types may be erased prior to run time Standard type theory constructs suffice Simpler typed closure conversion [ MWCG 97][CWM 98]

  16. Type Passing Example ( liML ) type packedarray(a:Type) = typecase a of int => array int | bool => array int sub = Fn a:Type => fn (A:packedarray a,i:int) => typecase a of int => wordsub(A,i) | bool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

  17. Type Erasure Example ( lR ) type packedarray(a:Type) = typecase a of int => array int | bool => array int sub = Fn a:Type => fn (A:packedarray a, i:int, rx:R(a)) => typecase rxof Rint => wordsub(A,i) | Rbool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

  18. Example datakind S=SInt|SBool interp :S  Type interp = fn a:S => case a of SInt => int | SBool => int datatype SRep = RInt | RBool

  19. Example sub = Fn a:S => fn (A:array (interp a),i:int, rx:SRep) => case rxof RInt => ccase a of SInt => wordsub(A,i) | SBool => impossible | RBool => ccase a of SInt => impossible | SBool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

  20. Second Try datatype SRep [a:S ] = RInt of (case a of SInt => unit | SBool => void) | RBool of (case a of SInt => void | SBool => unit)

  21. Second Try sub = Fn a:S => fn (A:array (interp a),i:int, rx:SRep(a)) => case rxof RInt y => vcasea of SInt => wordsub(A,i) | SBool => dead y | RBool y => vcasea of Sint => dead y | SBool => (wordsub(A,i div 32) & (1<<(i mod 32))) <> 0

  22. Related Work Inductive Types Mendler 87, Werner 94, Howard 92, 96, Gordon 94 Type Analysis Harper/Morrisett 95, Duggan 98, etc… Type Erasure Crary/Weirich/Morrisett 98 Typed Compilation TIL - FLINT - TAL - Church

More Related