1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
|
(* *********************************************************************)
(* *)
(* 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 INRIA Non-Commercial License Agreement. *)
(* *)
(* *********************************************************************)
(** The LTL intermediate language: abstract syntax and semantics.
LTL (``Location Transfer Language'') is the target language
for register allocation and the source language for linearization. *)
Require Import Coqlib.
Require Import Maps.
Require Import AST.
Require Import Integers.
Require Import Values.
Require Import Events.
Require Import Memory.
Require Import Globalenvs.
Require Import Smallstep.
Require Import Op.
Require Import Locations.
Require Import Conventions.
(** * Abstract syntax *)
(** LTL is close to RTL, but uses locations instead of pseudo-registers. *)
Definition node := positive.
Inductive instruction: Type :=
| Lnop: node -> instruction
| Lop: operation -> list loc -> loc -> node -> instruction
| Lload: memory_chunk -> addressing -> list loc -> loc -> node -> instruction
| Lstore: memory_chunk -> addressing -> list loc -> loc -> node -> instruction
| Lcall: signature -> loc + ident -> list loc -> loc -> node -> instruction
| Ltailcall: signature -> loc + ident -> list loc -> instruction
| Lbuiltin: external_function -> list loc -> loc -> node -> instruction
| Lcond: condition -> list loc -> node -> node -> instruction
| Ljumptable: loc -> list node -> instruction
| Lreturn: option loc -> instruction.
Definition code: Type := PTree.t instruction.
Record function: Type := mkfunction {
fn_sig: signature;
fn_params: list loc;
fn_stacksize: Z;
fn_code: code;
fn_entrypoint: node
}.
Definition fundef := AST.fundef function.
Definition program := AST.program fundef unit.
Definition funsig (fd: fundef) :=
match fd with
| Internal f => fn_sig f
| External ef => ef_sig ef
end.
(** * Operational semantics *)
Definition genv := Genv.t fundef unit.
Definition locset := Locmap.t.
Definition locmap_optget (ol: option loc) (dfl: val) (ls: locset) : val :=
match ol with
| None => dfl
| Some l => ls l
end.
Fixpoint init_locs (vl: list val) (rl: list loc) {struct rl} : locset :=
match rl, vl with
| r1 :: rs, v1 :: vs => Locmap.set r1 v1 (init_locs vs rs)
| _, _ => Locmap.init Vundef
end.
(** [postcall_locs ls] returns the location set [ls] after a function
call. Caller-save registers and temporary registers
are set to [undef], reflecting the fact that the called
function can modify them freely. *)
Definition postcall_locs (ls: locset) : locset :=
fun (l: loc) =>
match l with
| R r =>
if In_dec Loc.eq (R r) temporaries then
Vundef
else if In_dec Loc.eq (R r) destroyed_at_call then
Vundef
else
ls (R r)
| S s => ls (S s)
end.
(** Temporaries destroyed across instructions *)
Definition undef_temps (ls: locset) := Locmap.undef temporaries ls.
(** LTL execution states. *)
Inductive stackframe : Type :=
| Stackframe:
forall (res: loc) (**r where to store the result *)
(f: function) (**r calling function *)
(sp: val) (**r stack pointer in calling function *)
(ls: locset) (**r location state in calling function *)
(pc: node), (**r program point in calling function *)
stackframe.
Inductive state : Type :=
| State:
forall (stack: list stackframe) (**r call stack *)
(f: function) (**r function currently executing *)
(sp: val) (**r stack pointer *)
(pc: node) (**r current program point *)
(ls: locset) (**r location state *)
(m: mem), (**r memory state *)
state
| Callstate:
forall (stack: list stackframe) (**r call stack *)
(f: fundef) (**r function to call *)
(args: list val) (**r arguments to the call *)
(m: mem), (**r memory state *)
state
| Returnstate:
forall (stack: list stackframe) (**r call stack *)
(v: val) (**r return value for the call *)
(m: mem), (**r memory state *)
state.
Section RELSEM.
Variable ge: genv.
Definition find_function (los: loc + ident) (rs: locset) : option fundef :=
match los with
| inl l => Genv.find_funct ge (rs l)
| inr symb =>
match Genv.find_symbol ge symb with
| None => None
| Some b => Genv.find_funct_ptr ge b
end
end.
(** The LTL transition relation is very similar to that of RTL,
with locations being used in place of pseudo-registers.
The main difference is for the [call] instruction: caller-save
registers are set to [Vundef] across the call, using the [postcall_locs]
function defined above. This forces the LTL producer to avoid
storing values live across the call in a caller-save register. *)
Inductive step: state -> trace -> state -> Prop :=
| exec_Lnop:
forall s f sp pc rs m pc',
(fn_code f)!pc = Some(Lnop pc') ->
step (State s f sp pc rs m)
E0 (State s f sp pc' rs m)
| exec_Lop:
forall s f sp pc rs m op args res pc' v,
(fn_code f)!pc = Some(Lop op args res pc') ->
eval_operation ge sp op (map rs args) m = Some v ->
step (State s f sp pc rs m)
E0 (State s f sp pc' (Locmap.set res v (undef_temps rs)) m)
| exec_Lload:
forall s f sp pc rs m chunk addr args dst pc' a v,
(fn_code f)!pc = Some(Lload chunk addr args dst pc') ->
eval_addressing ge sp addr (map rs args) = Some a ->
Mem.loadv chunk m a = Some v ->
step (State s f sp pc rs m)
E0 (State s f sp pc' (Locmap.set dst v (undef_temps rs)) m)
| exec_Lstore:
forall s f sp pc rs m chunk addr args src pc' a m',
(fn_code f)!pc = Some(Lstore chunk addr args src pc') ->
eval_addressing ge sp addr (map rs args) = Some a ->
Mem.storev chunk m a (rs src) = Some m' ->
step (State s f sp pc rs m)
E0 (State s f sp pc' (undef_temps rs) m')
| exec_Lcall:
forall s f sp pc rs m sig ros args res pc' f',
(fn_code f)!pc = Some(Lcall sig ros args res pc') ->
find_function ros rs = Some f' ->
funsig f' = sig ->
step (State s f sp pc rs m)
E0 (Callstate (Stackframe res f sp (postcall_locs rs) pc' :: s)
f' (List.map rs args) m)
| exec_Ltailcall:
forall s f stk pc rs m sig ros args f' m',
(fn_code f)!pc = Some(Ltailcall sig ros args) ->
find_function ros rs = Some f' ->
funsig f' = sig ->
Mem.free m stk 0 f.(fn_stacksize) = Some m' ->
step (State s f (Vptr stk Int.zero) pc rs m)
E0 (Callstate s f' (List.map rs args) m')
| exec_Lbuiltin:
forall s f sp pc rs m ef args res pc' t v m',
(fn_code f)!pc = Some(Lbuiltin ef args res pc') ->
external_call ef ge (map rs args) m t v m' ->
step (State s f sp pc rs m)
t (State s f sp pc' (Locmap.set res v rs) m')
| exec_Lcond:
forall s f sp pc rs m cond args ifso ifnot b pc',
(fn_code f)!pc = Some(Lcond cond args ifso ifnot) ->
eval_condition cond (map rs args) m = Some b ->
pc' = (if b then ifso else ifnot) ->
step (State s f sp pc rs m)
E0 (State s f sp pc' (undef_temps rs) m)
| exec_Ljumptable:
forall s f sp pc rs m arg tbl n pc',
(fn_code f)!pc = Some(Ljumptable arg tbl) ->
rs arg = Vint n ->
list_nth_z tbl (Int.unsigned n) = Some pc' ->
step (State s f sp pc rs m)
E0 (State s f sp pc' (undef_temps rs) m)
| exec_Lreturn:
forall s f stk pc rs m or m',
(fn_code f)!pc = Some(Lreturn or) ->
Mem.free m stk 0 f.(fn_stacksize) = Some m' ->
step (State s f (Vptr stk Int.zero) pc rs m)
E0 (Returnstate s (locmap_optget or Vundef rs) m')
| exec_function_internal:
forall s f args m m' stk,
Mem.alloc m 0 f.(fn_stacksize) = (m', stk) ->
step (Callstate s (Internal f) args m)
E0 (State s f (Vptr stk Int.zero) f.(fn_entrypoint) (init_locs args f.(fn_params)) m')
| exec_function_external:
forall s ef t args res m m',
external_call ef ge args m t res m' ->
step (Callstate s (External ef) args m)
t (Returnstate s res m')
| exec_return:
forall res f sp rs pc s vres m,
step (Returnstate (Stackframe res f sp rs pc :: s) vres m)
E0 (State s f sp pc (Locmap.set res vres rs) m).
End RELSEM.
(** Execution of a whole program boils down to invoking its main
function. The result of the program is the return value of the
main function, to be found in the machine register dictated
by the calling conventions. *)
Inductive initial_state (p: program): state -> Prop :=
| initial_state_intro: forall b f m0,
let ge := Genv.globalenv p in
Genv.init_mem p = Some m0 ->
Genv.find_symbol ge p.(prog_main) = Some b ->
Genv.find_funct_ptr ge b = Some f ->
funsig f = mksignature nil (Some Tint) ->
initial_state p (Callstate nil f nil m0).
Inductive final_state: state -> int -> Prop :=
| final_state_intro: forall n m,
final_state (Returnstate nil (Vint n) m) n.
Definition semantics (p: program) :=
Semantics step (initial_state p) final_state (Genv.globalenv p).
(** * Operations over LTL *)
(** Computation of the possible successors of an instruction.
This is used in particular for dataflow analyses. *)
Definition successors_instr (i: instruction) : list node :=
match i with
| Lnop s => s :: nil
| Lop op args res s => s :: nil
| Lload chunk addr args dst s => s :: nil
| Lstore chunk addr args src s => s :: nil
| Lcall sig ros args res s => s :: nil
| Ltailcall sig ros args => nil
| Lbuiltin ef args res s => s :: nil
| Lcond cond args ifso ifnot => ifso :: ifnot :: nil
| Ljumptable arg tbl => tbl
| Lreturn optarg => nil
end.
Definition successors (f: function): PTree.t (list node) :=
PTree.map1 successors_instr f.(fn_code).
|
