source: src/Clight/Csyntax.ma @ 2672

(* *********************************************************************)
(*                                                                     *)
(*              The Compcert verified compiler                         *)
(*                                                                     *)
(*          Xavier Leroy, INRIA Paris-Rocquencourt                     *)
(*                                                                     *)
(*  Copyright Institut National de Recherche en Informatique et en     *)
(*  Automatique.  All rights reserved.  This file is distributed       *)
(*  under the terms of the GNU General Public License as published by  *)
(*  the Free Software Foundation, either version 2 of the License, or  *)
(*  (at your option) any later version.  This file is also distributed *)
(*  under the terms of the INRIA Non-Commercial License Agreement.     *)
(*                                                                     *)
(* *********************************************************************)

(* * Abstract syntax for the Clight language *)

(*include "Integers.ma".*)
include "common/AST.ma".
include "utilities/Coqlib.ma".
include "common/Errors.ma".
include "common/CostLabel.ma".

(* * * Abstract syntax *)

(* * ** Types *)

(* * The syntax of type expressions.  Some points to note:
- Array types [Tarray n] carry the size [n] of the array.
  Arrays with unknown sizes are represented by pointer types.
- Function types [Tfunction targs tres] specify the number and types
  of the function arguments (list [targs]), and the type of the
  function result ([tres]).  Variadic functions and old-style unprototyped
  functions are not supported.
- In C, struct and union types are named and compared by name.
  This enables the definition of recursive struct types such as
<<
  struct s1 { int n; struct * s1 next; };
>>
  Note that recursion within types must go through a pointer type.
  For instance, the following is not allowed in C.
<<
  struct s2 { int n; struct s2 next; };
>>
  In Clight, struct and union types [Tstruct id fields] and
  [Tunion id fields] are compared by structure: the [fields]
  argument gives the names and types of the members.  The identifier
  [id] is a local name which can be used in conjuction with the
  [Tcomp_ptr] constructor to express recursive types.  [Tcomp_ptr rg id]
  stands for a pointer type to the nearest enclosing [Tstruct]
  or [Tunion] type named [id] in memory region [rg].  For instance.
  the structure [s1] defined above in C is expressed by
<<
  Tstruct "s1" (Fcons "n" (Tint I32 Signed)
               (Fcons "next" (Tcomp_ptr Any "id")
               Fnil))
>>
  Note that the incorrect structure [s2] above cannot be expressed at
  all, since [Tcomp_ptr] lets us refer to a pointer to an enclosing
  structure or union, but not to the structure or union directly.
*)

inductive type : Type[0] ≝
  | Tvoid: type                         (**r the [void] type *)
  | Tint: intsize → signedness → type   (**r integer types *)
  | Tpointer: (*region →*) type → type      (**r pointer types ([*ty]) *)
  | Tarray: (*region →*) type → nat → type  (**r array types ([ty[len]]) *)
  | Tfunction: typelist → type → type   (**r function types *)
  | Tstruct: ident → fieldlist → type   (**r struct types *)
  | Tunion: ident → fieldlist → type    (**r union types *)
  | Tcomp_ptr: (*region →*) ident → type    (**r pointer to named struct or union *)

with typelist : Type[0] ≝
  | Tnil: typelist
  | Tcons: type → typelist → typelist

with fieldlist : Type[0] ≝
  | Fnil: fieldlist
  | Fcons: ident → type → fieldlist → fieldlist.

(* XXX: no induction scheme! *)
let rec type_ind
  (P:type → Prop)
  (vo:P Tvoid)
  (it:∀i,s. P (Tint i s))
  (pt:∀t. P t → P (Tpointer t))
  (ar:∀t,n. P t → P (Tarray t n))
  (fn:∀tl,t. P t → P (Tfunction tl t))
  (st:∀i,fl. P (Tstruct i fl))
  (un:∀i,fl. P (Tunion i fl))
  (cp:∀i. P (Tcomp_ptr i))
  (t:type) on t : P t ≝
  match t return λt'.P t' with
  [ Tvoid ⇒ vo
  | Tint i s ⇒ it i s
  | Tpointer t' ⇒ pt t' (type_ind P vo it pt ar fn st un cp t')
  | Tarray t' n ⇒ ar t' n (type_ind P vo it pt ar fn st un cp t')
  | Tfunction tl t' ⇒ fn tl t' (type_ind P vo it pt ar fn st un cp t')
  | Tstruct i fs ⇒ st i fs
  | Tunion i fs ⇒ un i fs
  | Tcomp_ptr i ⇒ cp i
  ].
  
let rec fieldlist_ind
  (P:fieldlist → Prop)
  (nl:P Fnil)
  (cs:∀i,t,fs. P fs → P (Fcons i t fs))
  (fs:fieldlist) on fs : P fs ≝
  match fs with
  [ Fnil ⇒ nl
  | Fcons i t fs' ⇒ cs i t fs' (fieldlist_ind P nl cs fs')
  ].

(* * ** Expressions *)

(* * Arithmetic and logical operators. *)

inductive unary_operation : Type[0] ≝
  | Onotbool : unary_operation          (**r boolean negation ([!] in C) *)
  | Onotint : unary_operation           (**r integer complement ([~] in C) *)
  | Oneg : unary_operation.             (**r opposite (unary [-]) *)

inductive binary_operation : Type[0] ≝
  | Oadd : binary_operation             (**r addition (binary [+]) *)
  | Osub : binary_operation             (**r subtraction (binary [-]) *)
  | Omul : binary_operation             (**r multiplication (binary [*]) *)
  | Odiv : binary_operation             (**r division ([/]) *)
  | Omod : binary_operation             (**r remainder ([%]) *)
  | Oand : binary_operation             (**r bitwise and ([&]) *)
  | Oor : binary_operation              (**r bitwise or ([|]) *)
  | Oxor : binary_operation             (**r bitwise xor ([^]) *)
  | Oshl : binary_operation             (**r left shift ([<<]) *)
  | Oshr : binary_operation             (**r right shift ([>>]) *)
  | Oeq: binary_operation               (**r comparison ([==]) *)
  | One: binary_operation               (**r comparison ([!=]) *)
  | Olt: binary_operation               (**r comparison ([<]) *)
  | Ogt: binary_operation               (**r comparison ([>]) *)
  | Ole: binary_operation               (**r comparison ([<=]) *)
  | Oge: binary_operation.              (**r comparison ([>=]) *)

(* * Clight expressions are a large subset of those of C.
  The main omissions are string literals and assignment operators
  ([=], [+=], [++], etc).  In Clight, assignment is a statement,
  not an expression.  

  All expressions are annotated with their types.  An expression
  (type [expr]) is therefore a pair of a type and an expression
  description (type [expr_descr]).
*)

inductive expr : Type[0] ≝
  | Expr: expr_descr → type → expr

with expr_descr : Type[0] ≝
  | Econst_int: ∀sz:intsize. bvint sz → expr_descr       (**r integer literal *)
  | Evar: ident → expr_descr           (**r variable *)
  | Ederef: expr → expr_descr          (**r pointer dereference (unary [*]) *)
  | Eaddrof: expr → expr_descr         (**r address-of operator ([&]) *)
  | Eunop: unary_operation → expr → expr_descr  (**r unary operation *)
  | Ebinop: binary_operation → expr → expr → expr_descr (**r binary operation *)
  | Ecast: type → expr → expr_descr    (**r type cast ([(ty) e]) *)
  | Econdition: expr → expr → expr → expr_descr (**r conditional ([e1 ? e2 : e3]) *)
  | Eandbool: expr → expr → expr_descr (**r sequential and ([&&]) *)
  | Eorbool: expr → expr → expr_descr  (**r sequential or ([||]) *)
  | Esizeof: type → expr_descr         (**r size of a type *)
  | Efield: expr → ident → expr_descr  (**r access to a member of a struct or union *)
  | Ecost: costlabel → expr → expr_descr.




(* * Extract the type part of a type-annotated Clight expression. *)

definition typeof : expr → type ≝ λe.
  match e with [ Expr de te ⇒ te ].

(* * ** Statements *)

(* * Clight statements include all C statements.
  Only structured forms of [switch] are supported; moreover,
  the [default] case must occur last.  Blocks and block-scoped declarations
  are not supported. *)

definition label ≝ ident.

inductive statement : Type[0] ≝
  | Sskip : statement                   (**r do nothing *)
  | Sassign : expr → expr → statement   (**r assignment [lvalue = rvalue] *)
  | Scall: option expr → expr → list expr → statement (**r function call *)
  | Ssequence : statement → statement → statement  (**r sequence *)
  | Sifthenelse : expr  → statement → statement → statement (**r conditional *)
  | Swhile : expr → statement → statement   (**r [while] loop *)
  | Sdowhile : expr → statement → statement (**r [do] loop *)
  | Sfor: statement → expr → statement → statement → statement (**r [for] loop *)
  | Sbreak : statement                      (**r [break] statement *)
  | Scontinue : statement                   (**r [continue] statement *)
  | Sreturn : option expr → statement       (**r [return] statement *)
  | Sswitch : expr → labeled_statements → statement  (**r [switch] statement *)
  | Slabel : label → statement → statement
  | Sgoto : label → statement
  | Scost : costlabel → statement → statement

with labeled_statements : Type[0] ≝            (**r cases of a [switch] *)
  | LSdefault: statement → labeled_statements
  | LScase: ∀sz:intsize. bvint sz → statement → labeled_statements → labeled_statements.

let rec labeled_statements_ind
  (P:labeled_statements → Prop)
  (LSd:∀s. P (LSdefault s))
  (LSc:∀sz,i,s,tl. P tl → P (LScase sz i s tl))
  ls on ls : P ls ≝
match ls with
[ LSdefault s ⇒ LSd s
| LScase sz i s tl ⇒ LSc sz i s tl (labeled_statements_ind P LSd LSc tl)
].

let rec statement_ind2
  (P:statement → Prop) (Q:labeled_statements → Prop)
  (Ssk:P Sskip)
  (Sas:∀e1,e2. P (Sassign e1 e2))
  (Sca:∀eo,e,args. P (Scall eo e args))
  (Ssq:∀s1,s2. P s1 → P s2 → P (Ssequence s1 s2))
  (Sif:∀e,s1,s2. P s1 → P s2 → P (Sifthenelse e s1 s2))
  (Swh:∀e,s. P s → P (Swhile e s))
  (Sdo:∀e,s. P s → P (Sdowhile e s))
  (Sfo:∀s1,e,s2,s3. P s1 → P s2 → P s3 → P (Sfor s1 e s2 s3))
  (Sbr:P Sbreak)
  (Sco:P Scontinue)
  (Sre:∀eo. P (Sreturn eo))
  (Ssw:∀e,ls. Q ls → P (Sswitch e ls))
  (Sla:∀l,s. P s → P (Slabel l s))
  (Sgo:∀l. P (Sgoto l))
  (Scs:∀l,s. P s → P (Scost l s))
  (LSd:∀s. P s → Q (LSdefault s))
  (LSc:∀sz,i,s,t. P s → Q t → Q (LScase sz i s t))
  (s:statement) on s : P s ≝
match s with
[ Sskip ⇒ Ssk
| Sassign e1 e2 ⇒ Sas e1 e2
| Scall eo e args ⇒ Sca eo e args
| Ssequence s1 s2 ⇒ Ssq s1 s2
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s1)
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s2)
| Sifthenelse e s1 s2 ⇒ Sif e s1 s2
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s1)
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s2)
| Swhile e s ⇒ Swh e s
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s)
| Sdowhile e s ⇒ Sdo e s
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s)
| Sfor s1 e s2 s3 ⇒ Sfo s1 e s2 s3
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s1)
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s2)
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s3)
| Sbreak ⇒ Sbr
| Scontinue ⇒ Sco
| Sreturn eo ⇒ Sre eo
| Sswitch e ls ⇒ Ssw e ls
    (labeled_statements_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc ls)
| Slabel l s ⇒ Sla l s
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s)
| Sgoto l ⇒ Sgo l
| Scost l s ⇒ Scs l s
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s)
]
and labeled_statements_ind2
  (P:statement → Prop) (Q:labeled_statements → Prop)
  (Ssk:P Sskip)
  (Sas:∀e1,e2. P (Sassign e1 e2))
  (Sca:∀eo,e,args. P (Scall eo e args))
  (Ssq:∀s1,s2. P s1 → P s2 → P (Ssequence s1 s2))
  (Sif:∀e,s1,s2. P s1 → P s2 → P (Sifthenelse e s1 s2))
  (Swh:∀e,s. P s → P (Swhile e s))
  (Sdo:∀e,s. P s → P (Sdowhile e s))
  (Sfo:∀s1,e,s2,s3. P s1 → P s2 → P s3 → P (Sfor s1 e s2 s3))
  (Sbr:P Sbreak)
  (Sco:P Scontinue)
  (Sre:∀eo. P (Sreturn eo))
  (Ssw:∀e,ls. Q ls → P (Sswitch e ls))
  (Sla:∀l,s. P s → P (Slabel l s))
  (Sgo:∀l. P (Sgoto l))
  (Scs:∀l,s. P s → P (Scost l s))
  (LSd:∀s. P s → Q (LSdefault s))
  (LSc:∀sz,i,s,t. P s → Q t → Q (LScase sz i s t))
  (ls:labeled_statements) on ls : Q ls ≝
match ls with
[ LSdefault s ⇒ LSd s
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s)
| LScase sz i s t ⇒ LSc sz i s t
    (statement_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc s)
    (labeled_statements_ind2 P Q Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs LSd LSc t)
].

definition statement_ind ≝ λP,Ssk,Sas,Sca,Ssq,Sif,Swh,Sdo,Sfo,Sbr,Sco,Sre,Ssw,Sla,Sgo,Scs.
  statement_ind2 P (λ_.True) Ssk Sas Sca Ssq Sif Swh Sdo Sfo Sbr Sco Sre Ssw Sla Sgo Scs
  (λ_,_. I) (λ_,_,_,_,_,_.I).

(* * ** Functions *)

(* * A function definition is composed of its return type ([fn_return]),
  the names and types of its parameters ([fn_params]), the names
  and types of its local variables ([fn_vars]), and the body of the
  function (a statement, [fn_body]). *)

record function : Type[0] ≝ {
  fn_return: type;
  fn_params: list (ident × type);
  fn_vars: list (ident × type);
  fn_body: statement
}.

(* * Functions can either be defined ([CL_Internal]) or declared as
  external functions ([CL_External]).  Similar to the AST definition, but
  with high level type information for external functions. *)

inductive clight_fundef : Type[0] ≝
  | CL_Internal: function → clight_fundef
  | CL_External: ident → typelist → type → clight_fundef.

(* * ** Programs *)

(* * A program is a collection of named functions, plus a collection
  of named global variables, carrying their types and optional initialization 
  data.  See module [AST] for more details. *)

definition clight_program : Type[0] ≝ program (λ_.clight_fundef) (list init_data × type).

(* * * Operations over types *)

(* * The type of a function definition. *)

let rec type_of_params (params: list (ident × type)) : typelist ≝
  match params with
  [ nil ⇒ Tnil
  | cons h rem ⇒ let 〈id,ty〉 ≝ h in Tcons ty (type_of_params rem)
  ].

definition type_of_function : function → type ≝ λf.
  Tfunction (type_of_params (fn_params f)) (fn_return f).

definition type_of_fundef : clight_fundef → type ≝ λf.
  match f with
  [ CL_Internal fd ⇒ type_of_function fd
  | CL_External id args res ⇒ Tfunction args res
  ].

(* * Natural alignment of a type, in bytes. *)
let rec alignof (t: type) : nat ≝ (*1*) 
(* these are old values for 32 bit machines *)
  match t with
  [ Tvoid ⇒ 1
  | Tint sz _ ⇒ match sz with [ I8 ⇒ 1 | I16 ⇒ 2 | I32 ⇒ 4 ]
  | Tpointer _ ⇒ 4
  | Tarray t' n ⇒ alignof t'
  | Tfunction _ _ ⇒ 1
  | Tstruct _ fld ⇒ alignof_fields fld
  | Tunion _ fld ⇒ alignof_fields fld
  | Tcomp_ptr _ ⇒ 4
  ]

and alignof_fields (f: fieldlist) : nat ≝
  match f with
  [ Fnil ⇒ 1
  | Fcons id t f' ⇒ max (alignof t) (alignof_fields f')
  ].

(*
Scheme type_ind2 := Induction for type Sort Prop
  with fieldlist_ind2 := Induction for fieldlist Sort Prop.
*)

(* XXX: automatic generation? *)
let rec type_ind2
  (P:type → Prop) (Q:fieldlist → Prop)
  (vo:P Tvoid)
  (it:∀i,s. P (Tint i s))
  (pt:∀t. P t → P (Tpointer t))
  (ar:∀t,n. P t → P (Tarray t n))
  (fn:∀tl,t. P t → P (Tfunction tl t))
  (st:∀i,fl. Q fl → P (Tstruct i fl))
  (un:∀i,fl. Q fl → P (Tunion i fl))
  (cp:∀i. P (Tcomp_ptr i))
  (nl:Q Fnil)
  (cs:∀i,t,f'. P t → Q f' → Q (Fcons i t f'))
 (t:type) on t : P t ≝
  match t return λt'.P t' with
  [ Tvoid ⇒ vo
  | Tint i s ⇒ it i s
  | Tpointer t' ⇒ pt t' (type_ind2 P Q vo it pt ar fn st un cp nl cs t')
  | Tarray t' n ⇒ ar t' n (type_ind2 P Q vo it pt ar fn st un cp nl cs t')
  | Tfunction tl t' ⇒ fn tl t' (type_ind2 P Q vo it pt ar fn st un cp nl cs t')
  | Tstruct i fs ⇒ st i fs (fieldlist_ind2 P Q vo it pt ar fn st un cp nl cs fs)
  | Tunion i fs ⇒ un i fs (fieldlist_ind2 P Q vo it pt ar fn st un cp nl cs fs)
  | Tcomp_ptr i ⇒ cp i
  ]
and fieldlist_ind2
  (P:type → Prop) (Q:fieldlist → Prop)
  (vo:P Tvoid)
  (it:∀i,s. P (Tint i s))
  (pt:∀t. P t → P (Tpointer t))
  (ar:∀t,n. P t → P (Tarray t n))
  (fn:∀tl,t. P t → P (Tfunction tl t))
  (st:∀i,fl. Q fl → P (Tstruct i fl))
  (un:∀i,fl. Q fl → P (Tunion i fl))
  (cp:∀i. P (Tcomp_ptr i))
  (nl:Q Fnil)
  (cs:∀i,t,f'. P t → Q f' → Q (Fcons i t f'))
  (fs:fieldlist) on fs : Q fs ≝
  match fs return λfs'.Q fs' with
  [ Fnil ⇒ nl
  | Fcons i t f' ⇒ cs i t f' (type_ind2 P Q vo it pt ar fn st un cp nl cs t)
                        (fieldlist_ind2 P Q vo it pt ar fn st un cp nl cs f')
  ].

lemma alignof_fields_pos:
  ∀f. alignof_fields f > 0.
@fieldlist_ind //;
#i #t #fs' #IH @max_r @IH qed. 

lemma alignof_pos:
  ∀t. alignof t > 0.
#t elim t; normalize; //;
[ 1,2: #z cases z; /2/;
| 3,4: #i @alignof_fields_pos
] qed.

(* * Size of a type, in bytes. *)

let rec sizeof (t: type) : nat ≝
  match t with
  [ Tvoid ⇒ 1
  | Tint i _ ⇒ match i with [ I8 ⇒ 1 | I16 ⇒ 2 | I32 ⇒ 4 ]
  | Tpointer _ ⇒ size_pointer 
  | Tarray t' n ⇒ sizeof t' * max 1 n
  | Tfunction _ _ ⇒ 1
  | Tstruct _ fld ⇒ align (max 1 (sizeof_struct fld 0)) (alignof t)
  | Tunion _ fld ⇒ align (max 1 (sizeof_union fld)) (alignof t)
  | Tcomp_ptr _ ⇒ size_pointer 
  ]

and sizeof_struct (fld: fieldlist) (pos: nat) on fld : nat ≝
  match fld with
  [ Fnil ⇒ pos
  | Fcons id t fld' ⇒ sizeof_struct fld' (align pos (alignof t) + sizeof t)
  ]

and sizeof_union (fld: fieldlist) : nat ≝
  match fld with
  [ Fnil ⇒ 0
  | Fcons id t fld' ⇒ max (sizeof t) (sizeof_union fld')
  ].
(* TODO: needs some Z_times results
lemma sizeof_pos:
  ∀t. sizeof t > 0.
#t0
napply (type_ind2 (λt. sizeof t > 0)
                  (λf. sizeof_union f ≥ 0 ∧ ∀pos:Z. pos ≥ 0 → sizeof_struct f pos ≥ 0));
[ 1,4,6,9: //;
| #i cases i;#s //;
| #f cases f;//
| #t #n #H whd in ⊢ (?%?);
Proof.
  intro t0.
  apply (type_ind2 (fun t => sizeof t > 0)
                   (fun f => sizeof_union f >= 0 /\ forall pos, pos >= 0 -> sizeof_struct f pos >= 0));
  intros; simpl; auto; try omega.
  destruct i; omega.
  destruct f; omega.
  apply Zmult_gt_0_compat. auto. generalize (Zmax1 1 z); omega.
  destruct H. 
  generalize (align_le (Zmax 1 (sizeof_struct f 0)) (alignof_fields f) (alignof_fields_pos f)). 
  generalize (Zmax1 1 (sizeof_struct f 0)). omega. 
  generalize (align_le (Zmax 1 (sizeof_union f)) (alignof_fields f) (alignof_fields_pos f)). 
  generalize (Zmax1 1 (sizeof_union f)). omega. 
  split. omega. auto.
  destruct H0. split; intros.
  generalize (Zmax2 (sizeof t) (sizeof_union f)). omega.
  apply H1. 
  generalize (align_le pos (alignof t) (alignof_pos t)). omega.
Qed.

Lemma sizeof_struct_incr:
  forall fld pos, pos <= sizeof_struct fld pos.
Proof.
  induction fld; intros; simpl. omega. 
  eapply Zle_trans. 2: apply IHfld.
  apply Zle_trans with (align pos (alignof t)). 
  apply align_le. apply alignof_pos. 
  assert (sizeof t > 0) by apply sizeof_pos. omega.
Qed.

(** Byte offset for a field in a struct or union.
  Field are laid out consecutively, and padding is inserted
  to align each field to the natural alignment for its type. *)

Open Local Scope string_scope.
*)

let rec field_offset_rec (id: ident) (fld: fieldlist) (pos: nat)
                              on fld : res nat ≝
  match fld with
  [ Fnil ⇒ Error ? [MSG UnknownField (*"Unknown field "*); CTX ? id]
  | Fcons id' t fld' ⇒
      match ident_eq id id' with
      [ inl _ ⇒ OK ? (align pos (alignof t))
      | inr _ ⇒ field_offset_rec id fld' (align pos (alignof t) + sizeof t)
      ]
  ].

definition field_offset ≝ λid: ident. λfld: fieldlist.
  field_offset_rec id fld 0.

let rec field_type (id: ident) (fld: fieldlist) on fld : res type :=
  match fld with
  [ Fnil ⇒ Error ? [MSG UnknownField (*"Unknown field "*); CTX ? id]
  | Fcons id' t fld' ⇒ match ident_eq id id' with [ inl _ ⇒ OK ? t | inr _ ⇒ field_type id fld']
  ].

(* * Some sanity checks about field offsets.  First, field offsets are 
  within the range of acceptable offsets. *)
(*
Remark field_offset_rec_in_range:
  forall id ofs ty fld pos,
  field_offset_rec id fld pos = OK ofs → field_type id fld = OK ty →
  pos <= ofs /\ ofs + sizeof ty <= sizeof_struct fld pos.
Proof.
  intros until ty. induction fld; simpl.
  congruence.
  destruct (ident_eq id i); intros.
  inv H. inv H0. split. apply align_le. apply alignof_pos. apply sizeof_struct_incr.
  exploit IHfld; eauto. intros [A B]. split; auto. 
  eapply Zle_trans; eauto. apply Zle_trans with (align pos (alignof t)).
  apply align_le. apply alignof_pos. generalize (sizeof_pos t). omega. 
Qed.

Lemma field_offset_in_range:
  forall id fld ofs ty,
  field_offset id fld = OK ofs → field_type id fld = OK ty →
  0 <= ofs /\ ofs + sizeof ty <= sizeof_struct fld 0.
Proof.
  intros. eapply field_offset_rec_in_range. unfold field_offset in H; eauto. eauto.
Qed.

(** Second, two distinct fields do not overlap *)

Lemma field_offset_no_overlap:
  forall id1 ofs1 ty1 id2 ofs2 ty2 fld,
  field_offset id1 fld = OK ofs1 → field_type id1 fld = OK ty1 →
  field_offset id2 fld = OK ofs2 → field_type id2 fld = OK ty2 →
  id1 <> id2 →
  ofs1 + sizeof ty1 <= ofs2 \/ ofs2 + sizeof ty2 <= ofs1.
Proof.
  intros until ty2. intros fld0 A B C D NEQ.
  assert (forall fld pos,
  field_offset_rec id1 fld pos = OK ofs1 -> field_type id1 fld = OK ty1 ->
  field_offset_rec id2 fld pos = OK ofs2 -> field_type id2 fld = OK ty2 ->
  ofs1 + sizeof ty1 <= ofs2 \/ ofs2 + sizeof ty2 <= ofs1).
  induction fld; intro pos; simpl. congruence.
  destruct (ident_eq id1 i); destruct (ident_eq id2 i).
  congruence. 
  subst i. intros. inv H; inv H0.
  exploit field_offset_rec_in_range. eexact H1. eauto. tauto.  
  subst i. intros. inv H1; inv H2.
  exploit field_offset_rec_in_range. eexact H. eauto. tauto. 
  intros. eapply IHfld; eauto.

  apply H with fld0 0; auto.
Qed.

(** Third, if a struct is a prefix of another, the offsets of fields
  in common is the same. *)

Fixpoint fieldlist_app (fld1 fld2: fieldlist) {struct fld1} : fieldlist :=
  match fld1 with
  | Fnil ⇒ fld2
  | Fcons id ty fld ⇒ Fcons id ty (fieldlist_app fld fld2)
  end.

Lemma field_offset_prefix:
  forall id ofs fld2 fld1,
  field_offset id fld1 = OK ofs →
  field_offset id (fieldlist_app fld1 fld2) = OK ofs.
Proof.
  intros until fld2.
  assert (forall fld1 pos, 
    field_offset_rec id fld1 pos = OK ofs ->
    field_offset_rec id (fieldlist_app fld1 fld2) pos = OK ofs).
  induction fld1; intros pos; simpl. congruence.
  destruct (ident_eq id i); auto.
  intros. unfold field_offset; auto. 
Qed.
*)


(* * Translating Clight types to Cminor types, function signatures,
  and external functions. *)

definition typ_of_type : type → typ ≝ λt.
  match t with
  [ Tvoid ⇒ ASTint I32 Unsigned
  | Tint sz sg ⇒ ASTint sz sg
  | Tpointer _ ⇒ ASTptr
  | Tarray _ _ ⇒ ASTptr
  | Tfunction _ _ ⇒ ASTptr
  | Tcomp_ptr _ ⇒ ASTptr
  | _ ⇒ ASTint I32 Unsigned (* structs and unions shouldn't be converted? *)
  ].

definition opttyp_of_type : type → option typ ≝ λt.
  match t with
  [ Tvoid ⇒ None ?
  | Tint sz sg ⇒ Some ? (ASTint sz sg)
  | Tpointer _ ⇒ Some ? ASTptr
  | Tarray _ _ ⇒ Some ? ASTptr
  | Tfunction _ _ ⇒ Some ? ASTptr
  | Tcomp_ptr _ ⇒ Some ? ASTptr
  | _ ⇒ None ? (* structs and unions shouldn't be converted? *)
  ].

let rec typlist_of_typelist (tl: typelist) : list typ ≝
  match tl with
  [ Tnil ⇒ nil ?
  | Tcons hd tl ⇒ typ_of_type hd :: typlist_of_typelist tl
  ].


(* * The [access_mode] function describes how a variable of the given
type must be accessed:
- [By_value ch]: access by value, i.e. by loading from the address
  of the variable using the memory chunk [ch];
- [By_reference]: access by reference, i.e. by just returning
  the address of the variable;
- [By_nothing]: no access is possible, e.g. for the [void] type.

We currently do not support 64-bit integers and 128-bit floats, so these
have an access mode of [By_nothing].
*)

inductive mode: typ → Type[0] ≝
  | By_value: ∀t:typ. mode t
  | By_reference: (*∀r:region.*) mode ASTptr
  | By_nothing: ∀t. mode t.

definition access_mode : ∀ty. mode (typ_of_type ty) ≝ λty.
  match ty return λty. mode (typ_of_type ty) with
  [ Tint i s ⇒ By_value (ASTint i s)
  | Tvoid ⇒ By_nothing …
  | Tpointer _ ⇒ By_value ASTptr
  | Tarray _ _ ⇒ By_reference
  | Tfunction _ _ ⇒ By_reference
  | Tstruct _ fList ⇒ By_nothing …
  | Tunion _ fList ⇒ By_nothing …
  | Tcomp_ptr _ ⇒ By_value ASTptr
  ].

definition signature_of_type : typelist → type → signature ≝ λargs. λres.
  mk_signature (typlist_of_typelist args) (opttyp_of_type res).

definition external_function
    : ident → typelist → type → external_function ≝ λid. λtargs. λtres.
  mk_external_function id (signature_of_type targs tres).