From 2ae43be7b9d4118335c9d2cef6e098f9b9f807fe Mon Sep 17 00:00:00 2001 From: xleroy Date: Thu, 9 Feb 2006 14:55:48 +0000 Subject: Initial import of compcert git-svn-id: https://yquem.inria.fr/compcert/svn/compcert/trunk@1 fca1b0fc-160b-0410-b1d3-a4f43f01ea2e --- doc/compcert.html | 250 ++ doc/index.html | 8295 +++++++++++++++++++++++++++++++++++++++++++++++++++++ doc/removeproofs | 8 + doc/style.css | 32 + 4 files changed, 8585 insertions(+) create mode 100644 doc/compcert.html create mode 100644 doc/index.html create mode 100755 doc/removeproofs create mode 100644 doc/style.css (limited to 'doc') diff --git a/doc/compcert.html b/doc/compcert.html new file mode 100644 index 0000000..c778632 --- /dev/null +++ b/doc/compcert.html @@ -0,0 +1,250 @@ + + + +The Compcert certified compiler back-end + + + + + + + + +

The Compcert certified compiler back-end

+

Commented Coq development

+

Version 0.2, 2006-01-07

+ +

Introduction

+ +

The Compcert back-end is a compiler that generates PowerPC assembly +code from a low-level intermediate language called Cminor and a +slightly more expressive intermediate language called Csharpminor. +The particularity of this compiler is that it is written mostly within +the specification language of the Coq proof assistant, and its +correctness --- the fact that the generated assembly code is +semantically equivalent to its source program --- was entirely proved +within the Coq proof assistant.

+ +

A high-level overview of the Compcert back-end and its proof of +correctness can be found in the following paper:

+Xavier Leroy, Formal +certification of a compiler back-end, or: programming a compiler with +a proof assistant. Proceedings of the POPL 2006 symposium. + +

This Web site gives a commented listing of the underlying Coq +specifications and proofs. Proof scripts and the parts of the +compiler written directly in Caml are omitted. This development is a +work in progress; some parts may have changed since the overview paper +above was written.

+ +

This document and all Coq source files referenced from it are +copyright 2005, 2006 Institut National de Recherche en Informatique et +en Automatique (INRIA) and distributed under the terms of the GNU General Public +License version 2.

+ +

Table of contents

+ +

Libraries, algorithms, data structures

+ + + +

Source, intermediate and target languages: syntax and semantics

+ + + +

Compiler passes

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
PassSource & targetCompiler codeCorrectness proof
Recognition of operators and addressing modesCsharpminor to CminorCmconstrCmconstrproof
Stack allocation of local variables
whose address is taken		Csharpminor to CminorCminorgenCminorgenproof
Construction of the CFG,
3-address code generation		Cminor to RTLRTLgenRTLgenproof1
+ RTLgenproof
Constant propagationRTL to RTLConstpropConstpropproof
Common subexpression eliminationRTL to RTLCSECSEproof
Register allocation by coloring
of an interference graph		RTL to LTLConventions
+ InterfGraph
+ Coloring
+ Parallelmove
+ Allocation
+
+ Coloringproof
+ Allocproof_aux
+ Allocproof
Branch tunnelingLTL to LTLTunnelingTunnelingproof
Linearization of the CFGLTL to LinearLinearizeLinearizeproof
Laying out the activation recordsLinear to MachStackingStackingproof
Storing the activation records in memoryMach to Mach(none) + Machabstr2mach
Emission of PowerPC assemblyMach to PPCPPCgenPPCgenproof1
+ PPCgenproof
+ +

Type systems

+ +Trivial type systems are used to statically capture well-formedness +conditions on the intermediate languages. + +Proofs that compiler passes are type-preserving: + + +

All together

+ + + +
+
Xavier.Leroy@inria.fr
+
+ + + diff --git a/doc/index.html b/doc/index.html new file mode 100644 index 0000000..33afe85 --- /dev/null +++ b/doc/index.html @@ -0,0 +1,8295 @@ + + +Index + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Global IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(3806 entries)
Axiom IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(39 entries)
Lemma IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(1753 entries)
Constructor IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(700 entries)
Inductive IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(155 entries)
Definition IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(1017 entries)
Module IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(78 entries)
Library IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(64 entries)
+
+

Global Index

+

A

+a [inductive, in backend.Op]
+a [inductive, in backend.Op]
+Abased [constructor, in backend.Op]
+abs [axiom, in lib.Floats]
+absf [definition, in backend.Values]
+absfloat [definition, in backend.Cmconstr]
+add [axiom, in lib.Floats]
+add [definition, in backend.Values]
+add [definition, in lib.Sets]
+add [definition, in backend.Cmconstr]
+add [definition, in backend.RTLtyping]
+add [definition, in lib.Integers]
+addf [definition, in backend.Cmconstr]
+addf [definition, in backend.Values]
+addf_cases [inductive, in backend.Cmconstr]
+addf_case1 [constructor, in backend.Cmconstr]
+addf_case2 [constructor, in backend.Cmconstr]
+addf_commut [axiom, in lib.Floats]
+addf_commut [lemma, in backend.Values]
+addf_default [constructor, in backend.Cmconstr]
+addf_match [definition, in backend.Cmconstr]
+addf_match_aux [definition, in backend.Cmconstr]
+addimm [definition, in backend.PPCgen]
+addimm [definition, in backend.Cmconstr]
+addimm_cases [inductive, in backend.Cmconstr]
+addimm_case1 [constructor, in backend.Cmconstr]
+addimm_case2 [constructor, in backend.Cmconstr]
+addimm_case3 [constructor, in backend.Cmconstr]
+addimm_case4 [constructor, in backend.Cmconstr]
+addimm_correct [lemma, in backend.PPCgenproof1]
+addimm_default [constructor, in backend.Cmconstr]
+addimm_match [definition, in backend.Cmconstr]
+addimm_1 [definition, in backend.PPCgen]
+addimm_1_correct [lemma, in backend.PPCgenproof1]
+addimm_2 [definition, in backend.PPCgen]
+addimm_2_correct [lemma, in backend.PPCgenproof1]
+addressing [definition, in backend.Cmconstr]
+addressing [inductive, in backend.Op]
+addressing_cases [inductive, in backend.Cmconstr]
+addressing_case1 [constructor, in backend.Cmconstr]
+addressing_case2 [constructor, in backend.Cmconstr]
+addressing_case3 [constructor, in backend.Cmconstr]
+addressing_case4 [constructor, in backend.Cmconstr]
+addressing_case5 [constructor, in backend.Cmconstr]
+addressing_default [constructor, in backend.Cmconstr]
+addressing_match [definition, in backend.Cmconstr]
+address_inject [lemma, in backend.Mem]
+addr_strength_reduction [definition, in backend.Constprop]
+addr_strength_reduction_cases [inductive, in backend.Constprop]
+addr_strength_reduction_case1 [constructor, in backend.Constprop]
+addr_strength_reduction_case2 [constructor, in backend.Constprop]
+addr_strength_reduction_case3 [constructor, in backend.Constprop]
+addr_strength_reduction_correct [lemma, in backend.Constpropproof]
+addr_strength_reduction_default [constructor, in backend.Constprop]
+addr_strength_reduction_match [definition, in backend.Constprop]
+addr_taken_expr [definition, in backend.Cminorgen]
+addr_taken_stmt [definition, in backend.Cminorgen]
+add_and [lemma, in lib.Integers]
+add_assoc [lemma, in lib.Integers]
+add_assoc [lemma, in backend.Values]
+add_call [definition, in backend.Allocation]
+add_call_correct [lemma, in backend.Allocproof]
+add_cases [inductive, in backend.Cmconstr]
+add_case1 [constructor, in backend.Cmconstr]
+add_case2 [constructor, in backend.Cmconstr]
+add_case3 [constructor, in backend.Cmconstr]
+add_case4 [constructor, in backend.Cmconstr]
+add_case5 [constructor, in backend.Cmconstr]
+add_commut [lemma, in lib.Integers]
+add_commut [lemma, in backend.Values]
+add_cond [definition, in backend.Allocation]
+add_cond_correct [lemma, in backend.Allocproof]
+add_default [constructor, in backend.Cmconstr]
+add_edges_instr [definition, in backend.Coloring]
+add_edges_instrs [definition, in backend.Coloring]
+add_edges_instrs_correct [lemma, in backend.Coloringproof]
+add_edges_instrs_correct_aux [lemma, in backend.Coloringproof]
+add_edges_instrs_incl_aux [lemma, in backend.Coloringproof]
+add_edges_instr_correct [lemma, in backend.Coloringproof]
+add_edges_instr_incl [lemma, in backend.Coloringproof]
+add_entry [definition, in backend.Allocation]
+add_entry_correct [lemma, in backend.Allocproof]
+add_funct [definition, in backend.Globalenvs]
+add_functs [definition, in backend.Globalenvs]
+add_functs_transf [lemma, in backend.Globalenvs]
+add_globals [definition, in backend.Globalenvs]
+add_instr [definition, in backend.RTLgen]
+add_instr_at [lemma, in backend.RTLgenproof1]
+add_instr_incr [lemma, in backend.RTLgenproof1]
+add_instr_wf [lemma, in backend.RTLgen]
+add_interf [definition, in backend.InterfGraph]
+add_interf_call [definition, in backend.Coloring]
+add_interf_call_correct [lemma, in backend.Coloringproof]
+add_interf_call_correct_aux_1 [lemma, in backend.Coloringproof]
+add_interf_call_correct_aux_2 [lemma, in backend.Coloringproof]
+add_interf_call_incl [lemma, in backend.Coloringproof]
+add_interf_call_incl_aux_1 [lemma, in backend.Coloringproof]
+add_interf_call_incl_aux_2 [lemma, in backend.Coloringproof]
+add_interf_correct [lemma, in backend.InterfGraph]
+add_interf_entry [definition, in backend.Coloring]
+add_interf_entry_correct [lemma, in backend.Coloringproof]
+add_interf_entry_incl [lemma, in backend.Coloringproof]
+add_interf_incl [lemma, in backend.InterfGraph]
+add_interf_live [definition, in backend.Coloring]
+add_interf_live_correct [lemma, in backend.Coloringproof]
+add_interf_live_correct_aux [lemma, in backend.Coloringproof]
+add_interf_live_incl [lemma, in backend.Coloringproof]
+add_interf_live_incl_aux [lemma, in backend.Coloringproof]
+add_interf_move [definition, in backend.Coloring]
+add_interf_move_correct [lemma, in backend.Coloringproof]
+add_interf_move_incl [lemma, in backend.Coloringproof]
+add_interf_mreg [definition, in backend.InterfGraph]
+add_interf_mreg_correct [lemma, in backend.InterfGraph]
+add_interf_mreg_incl [lemma, in backend.InterfGraph]
+add_interf_op [definition, in backend.Coloring]
+add_interf_op_correct [lemma, in backend.Coloringproof]
+add_interf_op_incl [lemma, in backend.Coloringproof]
+add_interf_params [definition, in backend.Coloring]
+add_interf_params_correct [lemma, in backend.Coloringproof]
+add_interf_params_correct_aux [lemma, in backend.Coloringproof]
+add_interf_params_incl [lemma, in backend.Coloringproof]
+add_interf_params_incl_aux [lemma, in backend.Coloringproof]
+add_letvar [definition, in backend.RTLgen]
+add_letvar_wf [lemma, in backend.RTLgenproof1]
+add_load [definition, in backend.CSE]
+add_load [definition, in backend.Allocation]
+add_load_correct [lemma, in backend.Allocproof]
+add_load_satisfiable [lemma, in backend.CSEproof]
+add_match [definition, in backend.Cmconstr]
+add_match_aux [definition, in backend.Cmconstr]
+add_move [definition, in backend.RTLgen]
+add_move [definition, in backend.Allocation]
+add_move_correct [lemma, in backend.RTLgenproof]
+add_move_correct [lemma, in backend.Allocproof]
+add_move_incr [lemma, in backend.RTLgenproof1]
+add_neg_zero [lemma, in lib.Integers]
+add_op [definition, in backend.Allocation]
+add_op [definition, in backend.CSE]
+add_op_correct [lemma, in backend.Allocproof]
+add_op_satisfiable [lemma, in backend.CSEproof]
+add_permut [lemma, in backend.Values]
+add_permut [lemma, in lib.Integers]
+add_permut_4 [lemma, in backend.Values]
+add_pref [definition, in backend.InterfGraph]
+add_prefs_call [definition, in backend.Coloring]
+add_prefs_call_incl [lemma, in backend.Coloringproof]
+add_pref_incl [lemma, in backend.InterfGraph]
+add_pref_mreg [definition, in backend.InterfGraph]
+add_pref_mreg_incl [lemma, in backend.InterfGraph]
+add_reload [definition, in backend.Allocation]
+add_reloads [definition, in backend.Allocation]
+add_reloads_correct [lemma, in backend.Allocproof]
+add_reloads_correct_rec [lemma, in backend.Allocproof]
+add_reload_correct [lemma, in backend.Allocproof]
+add_return [definition, in backend.Allocation]
+add_return_correct [lemma, in backend.Allocproof]
+add_rhs [definition, in backend.CSE]
+add_rhs_satisfiable [lemma, in backend.CSEproof]
+add_signed [lemma, in lib.Integers]
+add_spill [definition, in backend.Allocation]
+add_spill_correct [lemma, in backend.Allocproof]
+add_store [definition, in backend.Allocation]
+add_store_correct [lemma, in backend.Allocproof]
+add_successors [definition, in backend.Kildall]
+add_successors_correct [lemma, in backend.Kildall]
+add_symbol [definition, in backend.Globalenvs]
+add_to_worklist [definition, in backend.Kildall]
+add_to_worklist_1 [lemma, in backend.Kildall]
+add_to_worklist_2 [lemma, in backend.Kildall]
+add_undefs [definition, in backend.Allocation]
+add_undefs_correct [lemma, in backend.Allocproof]
+add_unsigned [lemma, in lib.Integers]
+add_var [definition, in backend.RTLgen]
+add_vars [definition, in backend.RTLgen]
+add_vars_incr [lemma, in backend.RTLgenproof1]
+add_vars_letenv [lemma, in backend.RTLgenproof1]
+add_vars_valid [lemma, in backend.RTLgenproof1]
+add_vars_wf [lemma, in backend.RTLgenproof1]
+add_var_find [lemma, in backend.RTLgenproof1]
+add_var_incr [lemma, in backend.RTLgenproof1]
+add_var_letenv [lemma, in backend.RTLgenproof1]
+add_var_valid [lemma, in backend.RTLgenproof1]
+add_var_wf [lemma, in backend.RTLgenproof1]
+add_zero [lemma, in lib.Integers]
+Aglobal [constructor, in backend.Op]
+agree [inductive, in backend.Stackingproof]
+agree [definition, in backend.Allocproof]
+agree [definition, in backend.PPCgenproof1]
+agree_assign_dead [lemma, in backend.Allocproof]
+agree_assign_live [lemma, in backend.Allocproof]
+agree_call [lemma, in backend.Allocproof]
+agree_eval_reg [lemma, in backend.Stackingproof]
+agree_eval_reg [lemma, in backend.Allocproof]
+agree_eval_regs [lemma, in backend.Stackingproof]
+agree_eval_regs [lemma, in backend.Allocproof]
+agree_exten [lemma, in backend.Allocproof]
+agree_exten_1 [lemma, in backend.PPCgenproof1]
+agree_exten_2 [lemma, in backend.PPCgenproof1]
+agree_increasing [lemma, in backend.Allocproof]
+agree_init_regs [lemma, in backend.Allocproof]
+agree_move_live [lemma, in backend.Allocproof]
+agree_nextinstr [lemma, in backend.PPCgenproof1]
+agree_nextinstr_commut [lemma, in backend.PPCgenproof1]
+agree_parameters [lemma, in backend.Allocproof]
+agree_reg_list_live [lemma, in backend.Allocproof]
+agree_reg_live [lemma, in backend.Allocproof]
+agree_reg_sum_live [lemma, in backend.Allocproof]
+agree_return_regs [lemma, in backend.Stackingproof]
+agree_set_commut [lemma, in backend.PPCgenproof1]
+agree_set_local [lemma, in backend.Stackingproof]
+agree_set_mfreg [lemma, in backend.PPCgenproof1]
+agree_set_mireg [lemma, in backend.PPCgenproof1]
+agree_set_mireg_exten [lemma, in backend.PPCgenproof1]
+agree_set_mireg_twice [lemma, in backend.PPCgenproof1]
+agree_set_mreg [lemma, in backend.PPCgenproof1]
+agree_set_other [lemma, in backend.PPCgenproof1]
+agree_set_outgoing [lemma, in backend.Stackingproof]
+agree_set_reg [lemma, in backend.Stackingproof]
+agree_set_twice_mireg [lemma, in backend.PPCgenproof1]
+Aindexed [constructor, in backend.Op]
+Aindexed2 [constructor, in backend.Op]
+Ainstack [constructor, in backend.Op]
+align [definition, in lib.Coqlib]
+align_le [lemma, in lib.Coqlib]
+align_16_top [definition, in backend.Mach]
+alloc [definition, in backend.Mem]
+Allocation [library]
+Allocproof [library]
+Allocproof_aux [library]
+allocs_write_ok [lemma, in backend.Alloctyping]
+Alloctyping [library]
+Alloctyping_aux [library]
+alloc_extends [lemma, in backend.Mem]
+alloc_mapped_inject [lemma, in backend.Mem]
+alloc_of_coloring [definition, in backend.Coloring]
+alloc_of_coloring_correct_1 [lemma, in backend.Coloringproof]
+alloc_of_coloring_correct_2 [lemma, in backend.Coloringproof]
+alloc_of_coloring_correct_3 [lemma, in backend.Coloringproof]
+alloc_of_coloring_correct_4 [lemma, in backend.Coloringproof]
+alloc_reg [definition, in backend.RTLgen]
+alloc_regs [definition, in backend.RTLgen]
+alloc_regs_fresh_or_in_map [lemma, in backend.RTLgenproof1]
+alloc_regs_incr [lemma, in backend.RTLgenproof1]
+alloc_regs_target_ok [lemma, in backend.RTLgenproof1]
+alloc_regs_valid [lemma, in backend.RTLgenproof1]
+alloc_reg_fresh_or_in_map [lemma, in backend.RTLgenproof1]
+alloc_reg_incr [lemma, in backend.RTLgenproof1]
+alloc_reg_target_ok [lemma, in backend.RTLgenproof1]
+alloc_reg_valid [lemma, in backend.RTLgenproof1]
+alloc_right_inject [lemma, in backend.Mem]
+alloc_type [lemma, in backend.Alloctyping]
+alloc_types [lemma, in backend.Alloctyping]
+alloc_unmapped_inject [lemma, in backend.Mem]
+alloc_variables [inductive, in backend.Csharpminor]
+alloc_variables_cons [constructor, in backend.Csharpminor]
+alloc_variables_list_block [lemma, in backend.Cminorgenproof]
+alloc_variables_nextblock_incr [lemma, in backend.Cminorgenproof]
+alloc_variables_nil [constructor, in backend.Csharpminor]
+alloc_write_ok [lemma, in backend.Alloctyping]
+all_interf_regs [definition, in backend.InterfGraph]
+all_interf_regs_correct_aux_1 [lemma, in backend.InterfGraph]
+all_interf_regs_correct_aux_2 [lemma, in backend.InterfGraph]
+all_interf_regs_correct_aux_3 [lemma, in backend.InterfGraph]
+all_interf_regs_correct_1 [lemma, in backend.InterfGraph]
+all_interf_regs_correct_2 [lemma, in backend.InterfGraph]
+analysis_correct_entry [lemma, in backend.CSEproof]
+analysis_correct_N [lemma, in backend.CSEproof]
+analysis_correct_1 [lemma, in backend.CSEproof]
+analyze [definition, in backend.Allocation]
+analyze [definition, in backend.Constprop]
+analyze [definition, in backend.CSE]
+analyze_correct [lemma, in backend.Allocproof]
+analyze_correct_1 [lemma, in backend.Constpropproof]
+analyze_correct_2 [lemma, in backend.Constpropproof]
+analyze_correct_3 [lemma, in backend.Constpropproof]
+analyze_invariant [lemma, in backend.Kildall]
+analyze_P [lemma, in backend.Kildall]
+and [definition, in lib.Integers]
+and [definition, in backend.Cmconstr]
+and [definition, in backend.Values]
+andimm [definition, in backend.Cmconstr]
+andimm [definition, in backend.PPCgen]
+andimm_correct [lemma, in backend.PPCgenproof1]
+and_assoc [lemma, in backend.Values]
+and_assoc [lemma, in lib.Integers]
+and_commut [lemma, in lib.Integers]
+and_commut [lemma, in backend.Values]
+and_idem [lemma, in lib.Integers]
+and_mone [lemma, in lib.Integers]
+and_or_distrib [lemma, in lib.Integers]
+and_shl [lemma, in lib.Integers]
+and_shru [lemma, in lib.Integers]
+and_xor_distrib [lemma, in lib.Integers]
+and_zero [lemma, in lib.Integers]
+appcons_length [lemma, in backend.Parallelmove]
+append [definition, in lib.Maps]
+append_assoc_0 [lemma, in lib.Maps]
+append_assoc_1 [lemma, in lib.Maps]
+append_injective [lemma, in lib.Maps]
+append_neutral_l [lemma, in lib.Maps]
+append_neutral_r [lemma, in lib.Maps]
+apply_partial [definition, in backend.Main]
+apply_total [definition, in backend.Main]
+apply_total_transf_program [lemma, in backend.Main]
+approx [inductive, in backend.Constprop]
+Approx [module, in backend.Constprop]
+approx_regs [definition, in backend.Constprop]
+approx_regs_val_list [lemma, in backend.Constpropproof]
+app_app [lemma, in backend.Parallelmove]
+app_cons [lemma, in backend.Parallelmove]
+app_nil [lemma, in backend.Parallelmove]
+app_rewrite [lemma, in backend.Parallelmove]
+app_rewriter [lemma, in backend.Parallelmove]
+app_rewrite2 [lemma, in backend.Parallelmove]
+arguments_not_preserved [lemma, in backend.Conventions]
+assign_variable [definition, in backend.Cminorgen]
+assign_variables [definition, in backend.Cminorgen]
+AST [library]
+

B

+BACKWARD_DATAFLOW_SOLVER [module, in backend.Kildall]
+Backward_Dataflow_Solver [module, in backend.Kildall]
+base_case_Pmov_dec [definition, in backend.Parallelmove]
+basic_block_list [definition, in backend.Kildall]
+basic_block_map [definition, in backend.Kildall]
+BBlock_solver [module, in backend.Kildall]
+BBLOCK_SOLVER [module, in backend.Kildall]
+bbmap [definition, in backend.Kildall]
+Bcall [constructor, in backend.LTL]
+Bcond [constructor, in backend.LTL]
+Bgetstack [constructor, in backend.LTL]
+Bgoto [constructor, in backend.LTL]
+bin [inductive, in lib.Inclusion]
+bind [definition, in backend.RTLgen]
+bind [definition, in backend.Cminorgen]
+bind2 [definition, in backend.RTLgen]
+bind_parameters [inductive, in backend.Csharpminor]
+bind_parameters_cons [constructor, in backend.Csharpminor]
+bind_parameters_length [lemma, in backend.Cminorgenproof]
+bind_parameters_nil [constructor, in backend.Csharpminor]
+bin_A [definition, in lib.Inclusion]
+bits_of_Z [definition, in lib.Integers]
+bits_of_Z_above [lemma, in lib.Integers]
+bits_of_Z_below [lemma, in lib.Integers]
+bits_of_Z_mone [lemma, in lib.Integers]
+bits_of_Z_of_bits [lemma, in lib.Integers]
+bits_of_Z_zero [lemma, in lib.Integers]
+bitwise_binop [definition, in lib.Integers]
+bitwise_binop_assoc [lemma, in lib.Integers]
+bitwise_binop_commut [lemma, in lib.Integers]
+bitwise_binop_idem [lemma, in lib.Integers]
+bitwise_binop_rol [lemma, in lib.Integers]
+bitwise_binop_shl [lemma, in lib.Integers]
+bitwise_binop_shru [lemma, in lib.Integers]
+Bload [constructor, in backend.LTL]
+block [inductive, in backend.LTL]
+block [definition, in backend.Values]
+block_agree [definition, in backend.Mem]
+block_agree_refl [lemma, in backend.Mem]
+block_agree_sym [lemma, in backend.Mem]
+block_agree_trans [lemma, in backend.Mem]
+block_contents [inductive, in backend.Mem]
+block_contents_agree [definition, in backend.Mem]
+block_contents_exten [lemma, in backend.Mem]
+block_contents_extends [definition, in backend.Mem]
+block_contents_inject [inductive, in backend.Mem]
+block_contents_inject_incr [lemma, in backend.Mem]
+block_cont_val [lemma, in backend.Mem]
+bool_of_false_val [lemma, in backend.Values]
+bool_of_false_val2 [lemma, in backend.Values]
+bool_of_false_val_inv [lemma, in backend.Values]
+bool_of_true_val [lemma, in backend.Values]
+bool_of_true_val2 [lemma, in backend.Values]
+bool_of_true_val_inv [lemma, in backend.Values]
+bool_of_val [inductive, in backend.Values]
+bool_of_val_int_true [constructor, in backend.Values]
+Bop [constructor, in backend.LTL]
+bot [definition, in lib.Lattice]
+Bot [constructor, in lib.Lattice]
+bot [definition, in lib.Lattice]
+bot [definition, in backend.Constprop]
+bot [definition, in lib.Sets]
+bot [definition, in lib.Lattice]
+Bot_except [constructor, in lib.Lattice]
+bounds [inductive, in backend.Lineartyping]
+bounds_free_block [lemma, in backend.Mem]
+bound_float_callee_save_pos [lemma, in backend.Lineartyping]
+bound_float_local_pos [lemma, in backend.Lineartyping]
+bound_int_callee_save_pos [lemma, in backend.Lineartyping]
+bound_int_local_pos [lemma, in backend.Lineartyping]
+bound_outgoing_pos [lemma, in backend.Lineartyping]
+branch_target [definition, in backend.Tunneling]
+branch_target_characterization [lemma, in backend.Tunnelingproof]
+branch_target_rec [definition, in backend.Tunneling]
+branch_target_rec_1 [lemma, in backend.Tunnelingproof]
+branch_target_rec_2 [lemma, in backend.Tunnelingproof]
+Breturn [constructor, in backend.LTL]
+Bsetstack [constructor, in backend.LTL]
+Bstore [constructor, in backend.LTL]
+build_compilenv [definition, in backend.Cminorgen]
+

C

+callstack [definition, in backend.Machabstr2mach]
+callstack [definition, in backend.Cminorgenproof]
+callstack_dom [inductive, in backend.Machabstr2mach]
+callstack_dom_cons [constructor, in backend.Machabstr2mach]
+callstack_dom_diff [lemma, in backend.Machabstr2mach]
+callstack_dom_incr [lemma, in backend.Machabstr2mach]
+callstack_dom_less [lemma, in backend.Machabstr2mach]
+callstack_dom_nil [constructor, in backend.Machabstr2mach]
+callstack_exten [lemma, in backend.Machabstr2mach]
+callstack_function_entry [lemma, in backend.Machabstr2mach]
+callstack_function_return [lemma, in backend.Machabstr2mach]
+callstack_get_parent [lemma, in backend.Machabstr2mach]
+callstack_get_slot [lemma, in backend.Machabstr2mach]
+callstack_init [lemma, in backend.Machabstr2mach]
+callstack_invariant [inductive, in backend.Machabstr2mach]
+callstack_linked [inductive, in backend.Machabstr2mach]
+callstack_linked_cons [constructor, in backend.Machabstr2mach]
+callstack_linked_nil [constructor, in backend.Machabstr2mach]
+callstack_linked_one [constructor, in backend.Machabstr2mach]
+callstack_load [lemma, in backend.Machabstr2mach]
+callstack_set_slot [lemma, in backend.Machabstr2mach]
+callstack_store [lemma, in backend.Machabstr2mach]
+callstack_store_aux [lemma, in backend.Machabstr2mach]
+callstack_store_ok [lemma, in backend.Machabstr2mach]
+call_regs [definition, in backend.LTL]
+call_regs_param_of_arg [lemma, in backend.Allocproof]
+CARRY [constructor, in backend.PPC]
+cast [definition, in backend.Csharpminor]
+cast16signed [definition, in lib.Integers]
+cast16signed [definition, in backend.Values]
+cast16signed [definition, in backend.Cmconstr]
+cast16unsigned [definition, in backend.Cmconstr]
+cast16unsigned [definition, in backend.Values]
+cast16unsigned [definition, in lib.Integers]
+cast16unsigned_and [lemma, in lib.Integers]
+cast16unsigned_and [lemma, in backend.Values]
+cast16_signed_equal_if_unsigned_equal [lemma, in lib.Integers]
+cast16_signed_idem [lemma, in lib.Integers]
+cast16_unsigned_idem [lemma, in lib.Integers]
+cast16_unsigned_signed [lemma, in lib.Integers]
+cast8signed [definition, in backend.Cmconstr]
+cast8signed [definition, in lib.Integers]
+cast8signed [definition, in backend.Values]
+cast8unsigned [definition, in backend.Cmconstr]
+cast8unsigned [definition, in backend.Values]
+cast8unsigned [definition, in lib.Integers]
+cast8unsigned_and [lemma, in lib.Integers]
+cast8unsigned_and [lemma, in backend.Values]
+cast8_signed_equal_if_unsigned_equal [lemma, in lib.Integers]
+cast8_signed_idem [lemma, in lib.Integers]
+cast8_signed_unsigned [lemma, in lib.Integers]
+cast8_unsigned_idem [lemma, in lib.Integers]
+cast8_unsigned_signed [lemma, in lib.Integers]
+Ccomp [constructor, in backend.Op]
+Ccompf [constructor, in backend.Op]
+Ccompimm [constructor, in backend.Op]
+Ccompu [constructor, in backend.Op]
+Ccompuimm [constructor, in backend.Op]
+CEcond [constructor, in backend.Cminor]
+CEcondition [constructor, in backend.Cminor]
+CEfalse [constructor, in backend.Cminor]
+Ceq [constructor, in backend.AST]
+CEtrue [constructor, in backend.Cminor]
+Cge [constructor, in backend.AST]
+Cgt [constructor, in backend.AST]
+check_all_leaves [definition, in lib.Inclusion]
+check_all_leaves_sound [lemma, in lib.Inclusion]
+check_coloring [definition, in backend.Coloring]
+check_coloring_1 [definition, in backend.Coloring]
+check_coloring_1_correct [lemma, in backend.Coloringproof]
+check_coloring_2 [definition, in backend.Coloring]
+check_coloring_2_correct [lemma, in backend.Coloringproof]
+check_coloring_3 [definition, in backend.Coloring]
+check_coloring_3_correct [lemma, in backend.Coloringproof]
+check_cont [definition, in backend.Mem]
+check_cont_agree [lemma, in backend.Mem]
+check_cont_false [lemma, in backend.Mem]
+check_cont_inject [lemma, in backend.Mem]
+check_cont_inv [lemma, in backend.Mem]
+check_cont_true [lemma, in backend.Mem]
+check_equal_on_range [definition, in lib.Integers]
+check_equal_on_range_correct [lemma, in lib.Integers]
+chunk_of_type [definition, in backend.Mach]
+Cint [constructor, in backend.PPC]
+Cle [constructor, in backend.AST]
+cleanup_code [definition, in backend.Linearize]
+cleanup_code_conservation [lemma, in backend.Linearizetyping]
+cleanup_code_conservation_2 [lemma, in backend.Linearizetyping]
+cleanup_code_correct_1 [lemma, in backend.Linearizeproof]
+cleanup_code_correct_2 [lemma, in backend.Linearizeproof]
+cleanup_function [definition, in backend.Linearize]
+cleanup_function_conservation [lemma, in backend.Linearizetyping]
+cleanup_function_conservation_2 [lemma, in backend.Linearizetyping]
+cleanup_function_correct [lemma, in backend.Linearizeproof]
+Clt [constructor, in backend.AST]
+Cmasknotzero [constructor, in backend.Op]
+Cmaskzero [constructor, in backend.Op]
+Cmconstr [library]
+Cmconstrproof [library]
+Cminor [library]
+Cminorgen [library]
+Cminorgenproof [library]
+cmp [axiom, in lib.Floats]
+cmp [definition, in backend.Cmconstr]
+cmp [definition, in backend.Values]
+cmp [definition, in lib.Integers]
+cmpf [definition, in backend.Cmconstr]
+cmpf [definition, in backend.Values]
+cmpf_ge [lemma, in backend.Values]
+cmpf_is_bool [lemma, in backend.Values]
+cmpf_le [lemma, in backend.Values]
+cmpu [definition, in backend.Values]
+cmpu [definition, in backend.Cmconstr]
+cmpu [definition, in lib.Integers]
+cmpu_is_bool [lemma, in backend.Values]
+cmp_ge_gt_eq [axiom, in lib.Floats]
+cmp_is_bool [lemma, in backend.Values]
+cmp_le_lt_eq [axiom, in lib.Floats]
+cmp_mismatch [definition, in backend.Values]
+cmp_mismatch_is_bool [lemma, in backend.Values]
+cmp_ne_eq [axiom, in lib.Floats]
+Cne [constructor, in backend.AST]
+Cnotcompf [constructor, in backend.Op]
+code [definition, in backend.LTL]
+code [definition, in backend.PPC]
+code [definition, in backend.RTL]
+code [definition, in backend.Linear]
+code [definition, in backend.Mach]
+code_size [definition, in backend.PPCgen]
+code_tail [definition, in backend.PPCgenproof]
+code_tail_next [lemma, in backend.PPCgenproof]
+code_tail_next_int [lemma, in backend.PPCgenproof]
+Coloring [library]
+Coloringproof [library]
+combine [definition, in lib.Maps]
+combine_commut [lemma, in lib.Maps]
+compare [lemma, in lib.Ordered]
+compare [lemma, in lib.Ordered]
+compare [lemma, in lib.Ordered]
+compare_float [definition, in backend.PPC]
+compare_float_spec [lemma, in backend.PPCgenproof1]
+compare_sint [definition, in backend.PPC]
+compare_sint_spec [lemma, in backend.PPCgenproof1]
+compare_uint [definition, in backend.PPC]
+compare_uint_spec [lemma, in backend.PPCgenproof1]
+comparison [inductive, in backend.AST]
+compilenv [definition, in backend.Cminorgen]
+condexpr [inductive, in backend.Cminor]
+condexpr_of_expr [definition, in backend.Cmconstr]
+condition [inductive, in backend.Op]
+conditionalexpr [definition, in backend.Cmconstr]
+cond_strength_reduction [definition, in backend.Constprop]
+cond_strength_reduction_cases [inductive, in backend.Constprop]
+cond_strength_reduction_correct [lemma, in backend.Constpropproof]
+cond_strength_reduction_match [definition, in backend.Constprop]
+consistent [definition, in backend.RTLtyping]
+consistent_not_eq [lemma, in backend.RTLtyping]
+constant [inductive, in backend.PPC]
+Constprop [library]
+Constpropproof [library]
+const_high [definition, in backend.PPC]
+const_low [definition, in backend.PPC]
+cons_replace [lemma, in backend.Parallelmove]
+Cont [constructor, in backend.LTL]
+Cont [constructor, in backend.Mem]
+content [inductive, in backend.Mem]
+contentmap [definition, in backend.Mem]
+contentmap_agree [definition, in backend.Mem]
+contentmap_inject [definition, in backend.Mem]
+contentmap_inject_incr [lemma, in backend.Mem]
+content_inject [inductive, in backend.Mem]
+content_inject_cont [constructor, in backend.Mem]
+content_inject_datum16 [constructor, in backend.Mem]
+content_inject_datum32 [constructor, in backend.Mem]
+content_inject_datum64 [constructor, in backend.Mem]
+content_inject_datum8 [constructor, in backend.Mem]
+content_inject_incr [lemma, in backend.Mem]
+content_inject_undef [constructor, in backend.Mem]
+cont_for_outcome [inductive, in backend.Linearizeproof]
+Conventions [library]
+Coqlib [library]
+correct_alloc_instr [definition, in backend.Coloringproof]
+correct_interf_alloc_instr [lemma, in backend.Coloringproof]
+correct_interf_instr [definition, in backend.Coloringproof]
+correct_interf_instr_incl [lemma, in backend.Coloringproof]
+crbit [inductive, in backend.PPC]
+crbit_for_cond [definition, in backend.PPCgen]
+crbit_for_fcmp [definition, in backend.PPCgen]
+crbit_for_icmp [definition, in backend.PPCgen]
+CRbit_0 [constructor, in backend.PPC]
+CRbit_1 [constructor, in backend.PPC]
+CRbit_2 [constructor, in backend.PPC]
+CRbit_3 [constructor, in backend.PPC]
+CR0_0 [constructor, in backend.PPC]
+CR0_1 [constructor, in backend.PPC]
+CR0_2 [constructor, in backend.PPC]
+CR0_3 [constructor, in backend.PPC]
+CSE [library]
+CSEproof [library]
+Csharpminor [library]
+csr_case1 [constructor, in backend.Constprop]
+csr_case2 [constructor, in backend.Constprop]
+csr_default [constructor, in backend.Constprop]
+Csymbol_high_signed [constructor, in backend.PPC]
+Csymbol_high_unsigned [constructor, in backend.PPC]
+Csymbol_low_signed [constructor, in backend.PPC]
+Csymbol_low_unsigned [constructor, in backend.PPC]
+CTR [constructor, in backend.PPC]
+

D

+D [module, in backend.Constprop]
+Dataflow_Solver [module, in backend.Kildall]
+DATAFLOW_SOLVER [module, in backend.Kildall]
+Datum16 [constructor, in backend.Mem]
+Datum32 [constructor, in backend.Mem]
+Datum64 [constructor, in backend.Mem]
+Datum8 [constructor, in backend.Mem]
+decode [definition, in backend.RTLtyping]
+def [definition, in backend.Parallelmove]
+definite [definition, in backend.RTLtyping]
+definite_included [lemma, in backend.RTLtyping]
+destroyed_at_call [definition, in backend.Conventions]
+destroyed_at_call_regs [definition, in backend.Conventions]
+diff [definition, in backend.Locations]
+diff_dec [definition, in backend.Parallelmove]
+diff_not_eq [lemma, in backend.Locations]
+diff_sym [lemma, in backend.Locations]
+discard_top_worklist_invariant [lemma, in backend.Kildall]
+disc1 [lemma, in backend.Parallelmove]
+disc2 [lemma, in backend.Parallelmove]
+disjoint [definition, in backend.Locations]
+disjoint_cons_left [lemma, in backend.Locations]
+disjoint_cons_right [lemma, in backend.Locations]
+disjoint_notin [lemma, in backend.Locations]
+disjoint_sym [lemma, in backend.Locations]
+disjoint_tmp__noTmp [lemma, in backend.Parallelmove]
+dis_dsttmp1_pnilnil [lemma, in backend.Allocproof_aux]
+dis_srctmp1_pnilnil [lemma, in backend.Allocproof_aux]
+div [axiom, in lib.Floats]
+divf [definition, in backend.Values]
+divf [definition, in backend.Cmconstr]
+divs [definition, in backend.Cmconstr]
+divs [definition, in lib.Integers]
+divs [definition, in backend.Values]
+divs_pow2 [lemma, in lib.Integers]
+divs_pow2 [lemma, in backend.Values]
+divu [definition, in backend.Cmconstr]
+divu [definition, in backend.Values]
+divu [definition, in lib.Integers]
+divu_cases [inductive, in backend.Cmconstr]
+divu_case1 [constructor, in backend.Cmconstr]
+divu_default [constructor, in backend.Cmconstr]
+divu_match [definition, in backend.Cmconstr]
+divu_pow2 [lemma, in backend.Values]
+divu_pow2 [lemma, in lib.Integers]
+Done_notmp1src_inv [lemma, in backend.Allocproof_aux]
+Done_notmp1src_invf [lemma, in backend.Allocproof_aux]
+Done_notmp1src_invpp [lemma, in backend.Allocproof_aux]
+Done_notmp1src_res [lemma, in backend.Allocproof_aux]
+Done_notmp1_inv [lemma, in backend.Allocproof_aux]
+Done_notmp1_invf [lemma, in backend.Allocproof_aux]
+Done_notmp1_invpp [lemma, in backend.Allocproof_aux]
+Done_notmp1_res [lemma, in backend.Allocproof_aux]
+Done_notmp3_inv [lemma, in backend.Allocproof_aux]
+Done_notmp3_invf [lemma, in backend.Allocproof_aux]
+Done_notmp3_invpp [lemma, in backend.Allocproof_aux]
+Done_notmp3_res [lemma, in backend.Allocproof_aux]
+Done_well_formed [definition, in backend.Allocproof_aux]
+drop1 [definition, in backend.Conventions]
+drop2 [definition, in backend.Conventions]
+DS [module, in backend.Kildall]
+DS [module, in backend.Constprop]
+DS [module, in backend.Linearize]
+DS [module, in backend.Allocation]
+dstep [inductive, in backend.Parallelmove]
+dstepp [inductive, in backend.Parallelmove]
+dstepp_refl [constructor, in backend.Parallelmove]
+dstepp_sameExec [lemma, in backend.Parallelmove]
+dstepp_stepp [lemma, in backend.Parallelmove]
+dstepp_trans [constructor, in backend.Parallelmove]
+dstep_inv [lemma, in backend.Parallelmove]
+dstep_inv_getdst [lemma, in backend.Parallelmove]
+dstep_nop [constructor, in backend.Parallelmove]
+dstep_pop [constructor, in backend.Parallelmove]
+dstep_pop_loop [constructor, in backend.Parallelmove]
+dstep_push [constructor, in backend.Parallelmove]
+dstep_start [constructor, in backend.Parallelmove]
+dstep_step [lemma, in backend.Parallelmove]
+dst_tmp2_res [lemma, in backend.Allocproof_aux]
+dst_tmp2_step [lemma, in backend.Allocproof_aux]
+dst_tmp2_stepf [lemma, in backend.Allocproof_aux]
+dst_tmp2_stepp [lemma, in backend.Allocproof_aux]
+

E

+Eaddrof [constructor, in backend.Csharpminor]
+Eassign [constructor, in backend.Cminor]
+Eassign [constructor, in backend.Csharpminor]
+Ecall [constructor, in backend.Csharpminor]
+Ecall [constructor, in backend.Cminor]
+Econdition [constructor, in backend.Csharpminor]
+Econdition [constructor, in backend.Cminor]
+Econs [constructor, in backend.Cminor]
+Econs [constructor, in backend.Csharpminor]
+ELEMENT [module, in lib.union_find]
+elements [definition, in lib.Sets]
+elements [definition, in lib.Maps]
+elements_complete [lemma, in lib.Maps]
+elements_complete [lemma, in lib.Sets]
+elements_correct [lemma, in lib.Maps]
+elements_correct [lemma, in lib.Sets]
+elements_keys_norepet [lemma, in lib.Maps]
+Elet [constructor, in backend.Csharpminor]
+Elet [constructor, in backend.Cminor]
+Eletvar [constructor, in backend.Cminor]
+Eletvar [constructor, in backend.Csharpminor]
+Eload [constructor, in backend.Cminor]
+Eload [constructor, in backend.Csharpminor]
+elt [definition, in lib.Maps]
+elt [definition, in backend.RTLtyping]
+elt [definition, in lib.Sets]
+elt [definition, in lib.union_find]
+elt [definition, in lib.union_find]
+elt [definition, in lib.union_find]
+elt [definition, in lib.Maps]
+elt [definition, in lib.Maps]
+elt [definition, in lib.Maps]
+elt_eq [definition, in lib.Maps]
+elt_eq [definition, in lib.Maps]
+elt_eq [definition, in lib.Maps]
+elt_eq [definition, in lib.Maps]
+EMap [module, in lib.Maps]
+empty [definition, in lib.Sets]
+empty [definition, in lib.Maps]
+empty [definition, in lib.union_find]
+empty [definition, in backend.RTLtyping]
+empty [definition, in backend.Globalenvs]
+empty [definition, in backend.Mem]
+empty_block [definition, in backend.Mem]
+empty_env [definition, in backend.Csharpminor]
+empty_frame [definition, in backend.Machabstr]
+empty_graph [definition, in backend.InterfGraph]
+empty_numbering [definition, in backend.CSE]
+empty_numbering_satisfiable [lemma, in backend.CSE]
+encode [definition, in backend.RTLtyping]
+encode_decode [lemma, in backend.RTLtyping]
+encode_injective [lemma, in backend.RTLtyping]
+Enil [constructor, in backend.Csharpminor]
+Enil [constructor, in backend.Cminor]
+entrypoint_function_translated [lemma, in backend.Allocproof]
+enumerate [definition, in backend.Linearize]
+enumerate_complete [lemma, in backend.Linearizeproof]
+enumerate_head [lemma, in backend.Linearizeproof]
+enumerate_norepet [lemma, in backend.Linearizeproof]
+env [definition, in backend.Csharpminor]
+Env [definition, in backend.Parallelmove]
+env [definition, in backend.Cminor]
+Eop [constructor, in backend.Csharpminor]
+Eop [constructor, in backend.Cminor]
+eq [lemma, in backend.Constprop]
+eq [definition, in backend.Mach]
+eq [definition, in lib.Ordered]
+eq [definition, in backend.RTLtyping]
+eq [lemma, in lib.Lattice]
+eq [lemma, in lib.Sets]
+eq [definition, in backend.CSEproof]
+eq [lemma, in lib.Lattice]
+eq [lemma, in lib.Lattice]
+eq [lemma, in backend.Locations]
+eq [definition, in lib.Maps]
+eq [lemma, in lib.Maps]
+eq [definition, in backend.Locations]
+eq [definition, in lib.Ordered]
+eq [definition, in backend.Registers]
+eq [lemma, in lib.Maps]
+eq [definition, in lib.Ordered]
+eq [definition, in backend.PPC]
+eq [definition, in lib.Integers]
+eqm [definition, in lib.Integers]
+eqmod [definition, in lib.Integers]
+eqmod_add [lemma, in lib.Integers]
+eqmod_mod [lemma, in lib.Integers]
+eqmod_mod_eq [lemma, in lib.Integers]
+eqmod_mult [lemma, in lib.Integers]
+eqmod_neg [lemma, in lib.Integers]
+eqmod_refl [lemma, in lib.Integers]
+eqmod_refl2 [lemma, in lib.Integers]
+eqmod_small_eq [lemma, in lib.Integers]
+eqmod_sub [lemma, in lib.Integers]
+eqmod_sym [lemma, in lib.Integers]
+eqmod_trans [lemma, in lib.Integers]
+eqmod_256_unsigned_repr [lemma, in lib.Integers]
+eqmod_65536_unsigned_repr [lemma, in lib.Integers]
+eqm_add [lemma, in lib.Integers]
+eqm_mult [lemma, in lib.Integers]
+eqm_neg [lemma, in lib.Integers]
+eqm_refl [lemma, in lib.Integers]
+eqm_refl2 [lemma, in lib.Integers]
+eqm_samerepr [lemma, in lib.Integers]
+eqm_signed_unsigned [lemma, in lib.Integers]
+eqm_small_eq [lemma, in lib.Integers]
+eqm_sub [lemma, in lib.Integers]
+eqm_sym [lemma, in lib.Integers]
+eqm_trans [lemma, in lib.Integers]
+eqm_unsigned_repr [lemma, in lib.Integers]
+eqm_unsigned_repr_l [lemma, in lib.Integers]
+eqm_unsigned_repr_r [lemma, in lib.Integers]
+EQUALITY_TYPE [module, in lib.Maps]
+equal_eq [lemma, in backend.RTLtyping]
+equal_on_range [lemma, in lib.Integers]
+equation_evals_to_holds_1 [lemma, in backend.CSEproof]
+equation_evals_to_holds_2 [lemma, in backend.CSEproof]
+equation_holds [definition, in backend.CSE]
+eq_block [definition, in backend.Values]
+eq_dec [lemma, in lib.Integers]
+eq_dec [axiom, in lib.Floats]
+eq_false [lemma, in lib.Integers]
+eq_list_valnum [definition, in backend.CSE]
+eq_refl [lemma, in lib.Ordered]
+eq_refl [lemma, in lib.Ordered]
+eq_refl [lemma, in lib.Ordered]
+eq_rhs [definition, in backend.CSE]
+eq_spec [lemma, in lib.Integers]
+eq_sym [lemma, in lib.Ordered]
+eq_sym [lemma, in lib.Ordered]
+eq_sym [lemma, in lib.Integers]
+eq_sym [lemma, in lib.Ordered]
+eq_trans [lemma, in lib.Ordered]
+eq_trans [lemma, in lib.Ordered]
+eq_trans [lemma, in lib.Ordered]
+eq_true [lemma, in lib.Integers]
+eq_valnum [definition, in backend.CSE]
+eq_zero_false [axiom, in lib.Floats]
+eq_zero_true [axiom, in lib.Floats]
+Error [constructor, in backend.RTLgen]
+error [definition, in backend.RTLtyping]
+error [definition, in backend.RTLgen]
+Error [constructor, in backend.PPC]
+error_inconsistent [lemma, in backend.RTLtyping]
+Estore [constructor, in backend.Cminor]
+Estore [constructor, in backend.Csharpminor]
+eval_absfloat [lemma, in backend.Cmconstrproof]
+eval_add [lemma, in backend.Cmconstrproof]
+eval_addf [lemma, in backend.Cmconstrproof]
+eval_addimm [lemma, in backend.Cmconstrproof]
+eval_addimm_ptr [lemma, in backend.Cmconstrproof]
+eval_addressing [lemma, in backend.Cmconstrproof]
+eval_addressing [definition, in backend.Op]
+eval_addressing_preserved [lemma, in backend.Op]
+eval_addressing_total [definition, in backend.Op]
+eval_addressing_weaken [lemma, in backend.Op]
+eval_add_ptr [lemma, in backend.Cmconstrproof]
+eval_add_ptr_2 [lemma, in backend.Cmconstrproof]
+eval_and [lemma, in backend.Cmconstrproof]
+eval_andimm [lemma, in backend.Cmconstrproof]
+eval_base_condition_of_expr [lemma, in backend.Cmconstrproof]
+eval_cast16signed [lemma, in backend.Cmconstrproof]
+eval_cast16unsigned [lemma, in backend.Cmconstrproof]
+eval_cast8signed [lemma, in backend.Cmconstrproof]
+eval_cast8unsigned [lemma, in backend.Cmconstrproof]
+eval_cmp [lemma, in backend.Cmconstrproof]
+eval_cmpf [lemma, in backend.Cmconstrproof]
+eval_cmpu [lemma, in backend.Cmconstrproof]
+eval_cmp_null_l [lemma, in backend.Cmconstrproof]
+eval_cmp_null_r [lemma, in backend.Cmconstrproof]
+eval_cmp_ptr [lemma, in backend.Cmconstrproof]
+eval_compare_null [definition, in backend.Op]
+eval_compare_null [definition, in backend.Csharpminor]
+eval_compare_null_weaken [lemma, in backend.Op]
+eval_condition [definition, in backend.Op]
+eval_conditionalexpr_false [lemma, in backend.Cmconstrproof]
+eval_conditionalexpr_true [lemma, in backend.Cmconstrproof]
+eval_condition_of_expr [lemma, in backend.Cmconstrproof]
+eval_condition_total [definition, in backend.Op]
+eval_condition_total_is_bool [lemma, in backend.Op]
+eval_condition_weaken [lemma, in backend.Op]
+eval_divf [lemma, in backend.Cmconstrproof]
+eval_divs [lemma, in backend.Cmconstrproof]
+eval_divu [lemma, in backend.Cmconstrproof]
+eval_divu_base [lemma, in backend.Cmconstrproof]
+eval_Evar [constructor, in backend.Csharpminor]
+eval_Evar [constructor, in backend.Cminor]
+eval_expr [inductive, in backend.Csharpminor]
+eval_expr [inductive, in backend.Cminor]
+eval_exprlist_prop [definition, in backend.Cminorgenproof]
+eval_expr_prop [definition, in backend.Cminorgenproof]
+eval_floatofint [lemma, in backend.Cmconstrproof]
+eval_floatofintu [lemma, in backend.Cmconstrproof]
+eval_funcall_prop [definition, in backend.Cminorgenproof]
+eval_intoffloat [lemma, in backend.Cmconstrproof]
+eval_lift [lemma, in backend.Cmconstrproof]
+eval_lift_expr [lemma, in backend.Cmconstrproof]
+eval_load [lemma, in backend.Cmconstrproof]
+eval_mods [lemma, in backend.Cmconstrproof]
+eval_modu [lemma, in backend.Cmconstrproof]
+eval_mod_aux [lemma, in backend.Cmconstrproof]
+eval_mul [lemma, in backend.Cmconstrproof]
+eval_mulf [lemma, in backend.Cmconstrproof]
+eval_mulimm [lemma, in backend.Cmconstrproof]
+eval_mulimm_base [lemma, in backend.Cmconstrproof]
+eval_negate_condition [lemma, in backend.Op]
+eval_negfloat [lemma, in backend.Cmconstrproof]
+eval_negint [lemma, in backend.Cmconstrproof]
+eval_notbool [lemma, in backend.Cmconstrproof]
+eval_notbool_base [lemma, in backend.Cmconstrproof]
+eval_notint [lemma, in backend.Cmconstrproof]
+eval_operation [definition, in backend.Op]
+eval_operation [definition, in backend.Csharpminor]
+eval_operation_preserved [lemma, in backend.Op]
+eval_operation_total [definition, in backend.Op]
+eval_operation_weaken [lemma, in backend.Op]
+eval_or [lemma, in backend.Cmconstrproof]
+eval_rolm [lemma, in backend.Cmconstrproof]
+eval_shl [lemma, in backend.Cmconstrproof]
+eval_shlimm [lemma, in backend.Cmconstrproof]
+eval_shr [lemma, in backend.Cmconstrproof]
+eval_shru [lemma, in backend.Cmconstrproof]
+eval_shruimm [lemma, in backend.Cmconstrproof]
+eval_singleoffloat [lemma, in backend.Cmconstrproof]
+eval_static_condition [definition, in backend.Constprop]
+eval_static_condition_cases [inductive, in backend.Constprop]
+eval_static_condition_case1 [constructor, in backend.Constprop]
+eval_static_condition_case2 [constructor, in backend.Constprop]
+eval_static_condition_case3 [constructor, in backend.Constprop]
+eval_static_condition_case4 [constructor, in backend.Constprop]
+eval_static_condition_case5 [constructor, in backend.Constprop]
+eval_static_condition_case6 [constructor, in backend.Constprop]
+eval_static_condition_case7 [constructor, in backend.Constprop]
+eval_static_condition_case8 [constructor, in backend.Constprop]
+eval_static_condition_correct [lemma, in backend.Constpropproof]
+eval_static_condition_default [constructor, in backend.Constprop]
+eval_static_condition_match [definition, in backend.Constprop]
+eval_static_operation [definition, in backend.Constprop]
+eval_static_operation_cases [inductive, in backend.Constprop]
+eval_static_operation_case1 [constructor, in backend.Constprop]
+eval_static_operation_case11 [constructor, in backend.Constprop]
+eval_static_operation_case12 [constructor, in backend.Constprop]
+eval_static_operation_case13 [constructor, in backend.Constprop]
+eval_static_operation_case14 [constructor, in backend.Constprop]
+eval_static_operation_case15 [constructor, in backend.Constprop]
+eval_static_operation_case16 [constructor, in backend.Constprop]
+eval_static_operation_case17 [constructor, in backend.Constprop]
+eval_static_operation_case18 [constructor, in backend.Constprop]
+eval_static_operation_case19 [constructor, in backend.Constprop]
+eval_static_operation_case2 [constructor, in backend.Constprop]
+eval_static_operation_case20 [constructor, in backend.Constprop]
+eval_static_operation_case21 [constructor, in backend.Constprop]
+eval_static_operation_case22 [constructor, in backend.Constprop]
+eval_static_operation_case23 [constructor, in backend.Constprop]
+eval_static_operation_case24 [constructor, in backend.Constprop]
+eval_static_operation_case25 [constructor, in backend.Constprop]
+eval_static_operation_case26 [constructor, in backend.Constprop]
+eval_static_operation_case27 [constructor, in backend.Constprop]
+eval_static_operation_case28 [constructor, in backend.Constprop]
+eval_static_operation_case29 [constructor, in backend.Constprop]
+eval_static_operation_case3 [constructor, in backend.Constprop]
+eval_static_operation_case30 [constructor, in backend.Constprop]
+eval_static_operation_case31 [constructor, in backend.Constprop]
+eval_static_operation_case32 [constructor, in backend.Constprop]
+eval_static_operation_case33 [constructor, in backend.Constprop]
+eval_static_operation_case34 [constructor, in backend.Constprop]
+eval_static_operation_case35 [constructor, in backend.Constprop]
+eval_static_operation_case36 [constructor, in backend.Constprop]
+eval_static_operation_case37 [constructor, in backend.Constprop]
+eval_static_operation_case38 [constructor, in backend.Constprop]
+eval_static_operation_case39 [constructor, in backend.Constprop]
+eval_static_operation_case4 [constructor, in backend.Constprop]
+eval_static_operation_case40 [constructor, in backend.Constprop]
+eval_static_operation_case41 [constructor, in backend.Constprop]
+eval_static_operation_case42 [constructor, in backend.Constprop]
+eval_static_operation_case43 [constructor, in backend.Constprop]
+eval_static_operation_case44 [constructor, in backend.Constprop]
+eval_static_operation_case45 [constructor, in backend.Constprop]
+eval_static_operation_case46 [constructor, in backend.Constprop]
+eval_static_operation_case47 [constructor, in backend.Constprop]
+eval_static_operation_case6 [constructor, in backend.Constprop]
+eval_static_operation_case7 [constructor, in backend.Constprop]
+eval_static_operation_case8 [constructor, in backend.Constprop]
+eval_static_operation_case9 [constructor, in backend.Constprop]
+eval_static_operation_correct [lemma, in backend.Constpropproof]
+eval_static_operation_default [constructor, in backend.Constprop]
+eval_static_operation_match [definition, in backend.Constprop]
+eval_store [lemma, in backend.Cmconstrproof]
+eval_sub [lemma, in backend.Cmconstrproof]
+eval_subf [lemma, in backend.Cmconstrproof]
+eval_sub_ptr_int [lemma, in backend.Cmconstrproof]
+eval_sub_ptr_ptr [lemma, in backend.Cmconstrproof]
+eval_xor [lemma, in backend.Cmconstrproof]
+Evar [constructor, in backend.Cminor]
+Evar [constructor, in backend.Csharpminor]
+exec [definition, in backend.Parallelmove]
+exec_Bgetstack [constructor, in backend.LTL]
+exec_blocks_Bgoto_inv [lemma, in backend.Tunnelingproof]
+exec_blocks_extends [lemma, in backend.LTL]
+exec_blocks_prop [definition, in backend.Linearizeproof]
+exec_blocks_prop [definition, in backend.Tunnelingproof]
+exec_blocks_valid_outcome [lemma, in backend.Linearizeproof]
+exec_block_Bgoto_inv [lemma, in backend.Tunnelingproof]
+exec_block_prop [definition, in backend.Linearizeproof]
+exec_block_prop [definition, in backend.Tunnelingproof]
+exec_function_body_prop [definition, in backend.Machabstr2mach]
+exec_function_body_prop [definition, in backend.PPCgenproof]
+exec_function_body_prop [definition, in backend.Machtyping]
+exec_function_body_prop_ [lemma, in backend.PPCgenproof]
+exec_function_equiv [lemma, in backend.Machabstr2mach]
+exec_function_prop [definition, in backend.Stackingproof]
+exec_function_prop [definition, in backend.Machtyping]
+exec_function_prop [definition, in backend.PPCgenproof]
+exec_function_prop [definition, in backend.Constpropproof]
+exec_function_prop [definition, in backend.Linearizeproof]
+exec_function_prop [definition, in backend.Machabstr2mach]
+exec_function_prop [definition, in backend.CSEproof]
+exec_function_prop [definition, in backend.Tunnelingproof]
+exec_function_prop [definition, in backend.Allocproof]
+exec_function_prop_ [lemma, in backend.PPCgenproof]
+exec_function_subject_reduction [definition, in backend.RTLtyping]
+exec_ifthenelse_false [lemma, in backend.Cmconstrproof]
+exec_ifthenelse_true [lemma, in backend.Cmconstrproof]
+exec_Iload [constructor, in backend.RTL]
+exec_Iload' [lemma, in backend.RTL]
+exec_Inop [constructor, in backend.RTL]
+exec_instr [inductive, in backend.Machabstr]
+exec_instr [inductive, in backend.RTL]
+exec_instr [inductive, in backend.LTL]
+exec_instr [inductive, in backend.Linear]
+exec_instr [inductive, in backend.Mach]
+exec_instr [definition, in backend.PPC]
+exec_instrs_Bgoto_inv [lemma, in backend.Tunnelingproof]
+exec_instrs_extends [lemma, in backend.RTLgenproof1]
+exec_instrs_extends_rec [lemma, in backend.RTLgenproof1]
+exec_instrs_incl [lemma, in backend.Stackingproof]
+exec_instrs_incl [lemma, in backend.PPCgenproof]
+exec_instrs_incr [lemma, in backend.RTLgenproof1]
+exec_instrs_link_invariant [lemma, in backend.Machtyping]
+exec_instrs_pmov [lemma, in backend.Allocproof_aux]
+exec_instrs_present [lemma, in backend.RTL]
+exec_instrs_prop [definition, in backend.Allocproof]
+exec_instrs_prop [definition, in backend.Tunnelingproof]
+exec_instrs_prop [definition, in backend.Machabstr2mach]
+exec_instrs_prop [definition, in backend.CSEproof]
+exec_instrs_prop [definition, in backend.Constpropproof]
+exec_instrs_prop [definition, in backend.Linearizeproof]
+exec_instr_extends [lemma, in backend.RTLgenproof1]
+exec_instr_extends_rec [lemma, in backend.RTLgenproof1]
+exec_instr_incl [lemma, in backend.PPCgenproof]
+exec_instr_incl [lemma, in backend.Stackingproof]
+exec_instr_incr [lemma, in backend.RTLgenproof1]
+exec_instr_in_s2 [lemma, in backend.RTLgenproof1]
+exec_instr_link_invariant [lemma, in backend.Machtyping]
+exec_instr_not_halt [lemma, in backend.RTLgenproof1]
+exec_instr_present [lemma, in backend.RTL]
+exec_instr_prop [definition, in backend.Allocproof]
+exec_instr_prop [definition, in backend.Machabstr2mach]
+exec_instr_prop [definition, in backend.Machtyping]
+exec_instr_prop [definition, in backend.Constpropproof]
+exec_instr_prop [definition, in backend.CSEproof]
+exec_instr_prop [definition, in backend.Tunnelingproof]
+exec_instr_prop [definition, in backend.Stackingproof]
+exec_instr_prop [definition, in backend.Linearizeproof]
+exec_instr_prop [definition, in backend.PPCgenproof]
+exec_instr_subject_reduction [definition, in backend.RTLtyping]
+exec_instr_update [lemma, in backend.Allocproof_aux]
+exec_Iop [constructor, in backend.RTL]
+exec_Iop' [lemma, in backend.RTL]
+exec_Lgetstack [constructor, in backend.Linear]
+exec_Mcall_prop [lemma, in backend.PPCgenproof]
+exec_Mcond_false_prop [lemma, in backend.PPCgenproof]
+exec_Mcond_true_prop [lemma, in backend.PPCgenproof]
+exec_Mgetparam [constructor, in backend.Mach]
+exec_Mgetparam_prop [lemma, in backend.PPCgenproof]
+exec_Mgetstack [constructor, in backend.Mach]
+exec_Mgetstack [constructor, in backend.Machabstr]
+exec_Mgetstack' [lemma, in backend.Stackingproof]
+exec_Mgetstack_prop [lemma, in backend.PPCgenproof]
+exec_Mgoto_prop [lemma, in backend.PPCgenproof]
+exec_Mlabel [constructor, in backend.Mach]
+exec_Mlabel [constructor, in backend.Machabstr]
+exec_Mlabel_prop [lemma, in backend.PPCgenproof]
+exec_Mload_prop [lemma, in backend.PPCgenproof]
+exec_Mop_prop [lemma, in backend.PPCgenproof]
+exec_Msetstack [constructor, in backend.Mach]
+exec_Msetstack' [lemma, in backend.Stackingproof]
+exec_Msetstack_prop [lemma, in backend.PPCgenproof]
+exec_Mstore_prop [lemma, in backend.PPCgenproof]
+exec_mutual_induction [lemma, in backend.Machabstr]
+exec_one [constructor, in backend.PPC]
+exec_one_prop [lemma, in backend.PPCgenproof]
+exec_program [definition, in backend.Csharpminor]
+exec_program [definition, in backend.LTL]
+exec_program [definition, in backend.Cminor]
+exec_program [definition, in backend.RTL]
+exec_program [definition, in backend.Mach]
+exec_program [definition, in backend.Machabstr]
+exec_program [definition, in backend.Linear]
+exec_program [definition, in backend.PPC]
+exec_program_equiv [lemma, in backend.Machabstr2mach]
+exec_refl [constructor, in backend.PPC]
+exec_refl_prop [lemma, in backend.PPCgenproof]
+exec_step [lemma, in backend.RTL]
+exec_step [inductive, in backend.PPC]
+exec_steps [inductive, in backend.PPC]
+exec_step_intro [constructor, in backend.PPC]
+exec_stmtlist_prop [definition, in backend.Cminorgenproof]
+exec_stmt_prop [definition, in backend.Cminorgenproof]
+exec_straight [inductive, in backend.PPCgenproof1]
+exec_straight_exec_prop [lemma, in backend.PPCgenproof]
+exec_straight_one [lemma, in backend.PPCgenproof1]
+exec_straight_refl [constructor, in backend.PPCgenproof1]
+exec_straight_step [constructor, in backend.PPCgenproof1]
+exec_straight_steps [lemma, in backend.PPCgenproof]
+exec_straight_steps_1 [lemma, in backend.PPCgenproof]
+exec_straight_steps_2 [lemma, in backend.PPCgenproof]
+exec_straight_three [lemma, in backend.PPCgenproof1]
+exec_straight_trans [lemma, in backend.PPCgenproof1]
+exec_straight_two [lemma, in backend.PPCgenproof1]
+exec_trans [constructor, in backend.PPC]
+exec_trans_prop [lemma, in backend.PPCgenproof]
+expr [inductive, in backend.Csharpminor]
+expr [inductive, in backend.Cminor]
+exprlist [inductive, in backend.Csharpminor]
+exprlist [inductive, in backend.Cminor]
+expr_condexpr_exprlist_ind [lemma, in backend.RTLgenproof1]
+exten [lemma, in lib.Maps]
+extends [definition, in backend.Mem]
+extends_refl [lemma, in backend.Mem]
+extend_inject [definition, in backend.Mem]
+extend_inject_incr [lemma, in backend.Mem]
+extensionality [axiom, in lib.Coqlib]
+

F

+find_funct [definition, in backend.Globalenvs]
+find_function [definition, in backend.LTL]
+find_function [definition, in backend.Mach]
+find_function [definition, in backend.RTL]
+find_function [definition, in backend.Linear]
+find_function2 [definition, in backend.Allocproof]
+find_funct_find_funct_ptr [lemma, in backend.Globalenvs]
+find_funct_inv [lemma, in backend.Globalenvs]
+find_funct_prop [lemma, in backend.Globalenvs]
+find_funct_ptr [definition, in backend.Globalenvs]
+find_funct_ptr_inv [lemma, in backend.Globalenvs]
+find_funct_ptr_prop [lemma, in backend.Globalenvs]
+find_funct_ptr_transf [lemma, in backend.Globalenvs]
+find_funct_ptr_transf_partial [lemma, in backend.Globalenvs]
+find_funct_transf [lemma, in backend.Globalenvs]
+find_funct_transf_partial [lemma, in backend.Globalenvs]
+find_instr [definition, in backend.PPC]
+find_instr_in [lemma, in backend.PPCgenproof]
+find_instr_tail [lemma, in backend.PPCgenproof]
+find_label [definition, in backend.Mach]
+find_label [definition, in backend.PPCgenproof]
+find_label [definition, in backend.Linear]
+find_label_cleanup_code [lemma, in backend.Linearizeproof]
+find_label_goto_label [lemma, in backend.PPCgenproof]
+find_label_incl [lemma, in backend.Stackingproof]
+find_label_lin [lemma, in backend.Linearizeproof]
+find_label_lin_block [lemma, in backend.Linearizeproof]
+find_label_lin_rec [lemma, in backend.Linearizeproof]
+find_label_transl_code [lemma, in backend.Stackingproof]
+find_label_unique [lemma, in backend.Linearizeproof]
+find_letvar [definition, in backend.RTLgen]
+find_letvar_incr [lemma, in backend.RTLgenproof1]
+find_letvar_in_map [lemma, in backend.RTLgenproof1]
+find_letvar_not_mutated [lemma, in backend.RTLgenproof1]
+find_letvar_valid [lemma, in backend.RTLgenproof1]
+find_load [definition, in backend.CSE]
+find_load_correct [lemma, in backend.CSEproof]
+find_op [definition, in backend.CSE]
+find_op_correct [lemma, in backend.CSEproof]
+find_rhs [definition, in backend.CSE]
+find_rhs_correct [lemma, in backend.CSEproof]
+find_symbol [definition, in backend.Globalenvs]
+find_symbol_inv [lemma, in backend.Globalenvs]
+find_symbol_offset [definition, in backend.Op]
+find_symbol_transf [lemma, in backend.Globalenvs]
+find_symbol_transf_partial [lemma, in backend.Globalenvs]
+find_valnum_rhs [definition, in backend.CSE]
+find_valnum_rhs_correct [lemma, in backend.CSEproof]
+find_var [definition, in backend.RTLgen]
+find_var_incr [lemma, in backend.RTLgenproof1]
+find_var_in_map [lemma, in backend.RTLgenproof1]
+find_var_not_mutated [lemma, in backend.RTLgenproof1]
+find_var_valid [lemma, in backend.RTLgenproof1]
+fixpoint [definition, in backend.Kildall]
+fixpoint [definition, in backend.Kildall]
+fixpoint [definition, in backend.Kildall]
+fixpoint_entry [lemma, in backend.Kildall]
+fixpoint_entry [lemma, in backend.Kildall]
+fixpoint_entry [lemma, in backend.Kildall]
+fixpoint_incr [lemma, in backend.Kildall]
+fixpoint_invariant [lemma, in backend.Kildall]
+fixpoint_solution [lemma, in backend.Kildall]
+fixpoint_solution [lemma, in backend.Kildall]
+fixpoint_solution [lemma, in backend.Kildall]
+FI_arg [constructor, in backend.Stacking]
+FI_local [constructor, in backend.Stacking]
+FI_saved_float [constructor, in backend.Stacking]
+FI_saved_int [constructor, in backend.Stacking]
+flatten [definition, in lib.Inclusion]
+flatten_aux [definition, in lib.Inclusion]
+flatten_aux_valid_A [lemma, in lib.Inclusion]
+flatten_valid_A [lemma, in lib.Inclusion]
+float [axiom, in lib.Floats]
+Float [module, in lib.Floats]
+floatcomp [definition, in backend.PPCgen]
+floatcomp_correct [lemma, in backend.PPCgenproof1]
+floatofint [definition, in backend.Values]
+floatofint [axiom, in lib.Floats]
+floatofint [definition, in backend.Cmconstr]
+floatofintu [definition, in backend.Cmconstr]
+floatofintu [definition, in backend.Values]
+floatofintu [axiom, in lib.Floats]
+Floats [library]
+float_callee_save [definition, in backend.Lineartyping]
+float_callee_save_bound [lemma, in backend.Linearizetyping]
+float_callee_save_norepet [lemma, in backend.Conventions]
+float_callee_save_not_destroyed [lemma, in backend.Conventions]
+float_callee_save_regs [definition, in backend.Conventions]
+float_callee_save_type [lemma, in backend.Conventions]
+float_local [definition, in backend.Lineartyping]
+float_local_slot_bound [lemma, in backend.Linearizetyping]
+float_param_regs [definition, in backend.Conventions]
+fn_params_names [definition, in backend.Csharpminor]
+fn_variables [definition, in backend.Csharpminor]
+fn_vars_names [definition, in backend.Csharpminor]
+fold [definition, in lib.Sets]
+fold [definition, in lib.Maps]
+fold2 [definition, in backend.RTLtyping]
+fold_spec [lemma, in lib.Maps]
+fold_spec [lemma, in lib.Sets]
+for_all [definition, in lib.Sets]
+for_all_spec [lemma, in lib.Sets]
+Fpmov_correct [lemma, in backend.Parallelmove]
+Fpmov_correctMoves [lemma, in backend.Parallelmove]
+Fpmov_correct1 [lemma, in backend.Parallelmove]
+Fpmov_correct2 [lemma, in backend.Parallelmove]
+Fpmov_correct_ext [lemma, in backend.Parallelmove]
+Fpmov_correct_IT3 [lemma, in backend.Parallelmove]
+Fpmov_correct_map [lemma, in backend.Parallelmove]
+FPR0 [constructor, in backend.PPC]
+FPR1 [constructor, in backend.PPC]
+FPR10 [constructor, in backend.PPC]
+FPR11 [constructor, in backend.PPC]
+FPR12 [constructor, in backend.PPC]
+FPR13 [constructor, in backend.PPC]
+FPR14 [constructor, in backend.PPC]
+FPR15 [constructor, in backend.PPC]
+FPR16 [constructor, in backend.PPC]
+FPR17 [constructor, in backend.PPC]
+FPR18 [constructor, in backend.PPC]
+FPR19 [constructor, in backend.PPC]
+FPR2 [constructor, in backend.PPC]
+FPR20 [constructor, in backend.PPC]
+FPR21 [constructor, in backend.PPC]
+FPR22 [constructor, in backend.PPC]
+FPR23 [constructor, in backend.PPC]
+FPR24 [constructor, in backend.PPC]
+FPR25 [constructor, in backend.PPC]
+FPR26 [constructor, in backend.PPC]
+FPR27 [constructor, in backend.PPC]
+FPR28 [constructor, in backend.PPC]
+FPR29 [constructor, in backend.PPC]
+FPR3 [constructor, in backend.PPC]
+FPR30 [constructor, in backend.PPC]
+FPR31 [constructor, in backend.PPC]
+FPR4 [constructor, in backend.PPC]
+FPR5 [constructor, in backend.PPC]
+FPR6 [constructor, in backend.PPC]
+FPR7 [constructor, in backend.PPC]
+FPR8 [constructor, in backend.PPC]
+FPR9 [constructor, in backend.PPC]
+FR [constructor, in backend.PPC]
+frame [inductive, in backend.Cminorgenproof]
+frame [definition, in backend.Machabstr]
+frame_env [inductive, in backend.Stacking]
+frame_index [inductive, in backend.Stacking]
+frame_match [inductive, in backend.Machabstr2mach]
+frame_match_alloc [lemma, in backend.Machabstr2mach]
+frame_match_exten [lemma, in backend.Machabstr2mach]
+frame_match_free [lemma, in backend.Machabstr2mach]
+frame_match_get_slot [lemma, in backend.Machabstr2mach]
+frame_match_intro [constructor, in backend.Machabstr2mach]
+frame_match_load [lemma, in backend.Machabstr2mach]
+frame_match_new [lemma, in backend.Machabstr2mach]
+frame_match_set_slot [lemma, in backend.Machabstr2mach]
+frame_match_store [lemma, in backend.Machabstr2mach]
+frame_match_store_ok [lemma, in backend.Machabstr2mach]
+frame_match_store_stack_other [lemma, in backend.Machabstr2mach]
+free [definition, in backend.Mem]
+free_empty_bounds [lemma, in backend.Mem]
+free_extends [lemma, in backend.Mem]
+free_first_inject [lemma, in backend.Mem]
+free_first_list_inject [lemma, in backend.Mem]
+free_inject [lemma, in backend.Mem]
+free_list [definition, in backend.Mem]
+free_snd_inject [lemma, in backend.Mem]
+freg [inductive, in backend.PPC]
+freg_eq [lemma, in backend.PPC]
+freg_of [definition, in backend.PPCgen]
+freg_of_is_data_reg [lemma, in backend.PPCgenproof1]
+freg_of_not_FPR13 [lemma, in backend.PPCgenproof1]
+freg_val [lemma, in backend.PPCgenproof1]
+fresh_block_alloc [lemma, in backend.Mem]
+FT1 [constructor, in backend.Locations]
+FT2 [constructor, in backend.Locations]
+FT3 [constructor, in backend.Locations]
+function [inductive, in backend.Mach]
+function [inductive, in backend.Csharpminor]
+function [inductive, in backend.RTL]
+function [inductive, in backend.LTL]
+function [inductive, in backend.Cminor]
+function [inductive, in backend.Linear]
+functions_globalenv [lemma, in backend.Globalenvs]
+functions_translated [lemma, in backend.Constpropproof]
+functions_translated [lemma, in backend.Tunnelingproof]
+functions_translated [lemma, in backend.PPCgenproof]
+functions_translated [lemma, in backend.Allocproof]
+functions_translated [lemma, in backend.Linearizeproof]
+functions_translated [lemma, in backend.Stackingproof]
+functions_translated [lemma, in backend.CSEproof]
+functions_translated [lemma, in backend.Cminorgenproof]
+functions_translated [lemma, in backend.RTLgenproof]
+functions_translated_no_overflow [lemma, in backend.PPCgenproof]
+functions_translated_2 [lemma, in backend.PPCgenproof]
+function_bounds [definition, in backend.Lineartyping]
+function_entry_ok [lemma, in backend.Cminorgenproof]
+function_ptr_translated [lemma, in backend.Linearizeproof]
+function_ptr_translated [lemma, in backend.Allocproof]
+function_ptr_translated [lemma, in backend.Stackingproof]
+function_ptr_translated [lemma, in backend.Cminorgenproof]
+function_ptr_translated [lemma, in backend.RTLgenproof]
+function_ptr_translated [lemma, in backend.Constpropproof]
+function_ptr_translated [lemma, in backend.Tunnelingproof]
+funct_ptr_translated [lemma, in backend.CSEproof]
+F1 [constructor, in backend.Locations]
+F10 [constructor, in backend.Locations]
+F14 [constructor, in backend.Locations]
+F15 [constructor, in backend.Locations]
+F16 [constructor, in backend.Locations]
+F17 [constructor, in backend.Locations]
+F18 [constructor, in backend.Locations]
+F19 [constructor, in backend.Locations]
+F2 [constructor, in backend.Locations]
+f2ind [lemma, in backend.Parallelmove]
+f2ind' [lemma, in backend.Parallelmove]
+F20 [constructor, in backend.Locations]
+F21 [constructor, in backend.Locations]
+F22 [constructor, in backend.Locations]
+F23 [constructor, in backend.Locations]
+F24 [constructor, in backend.Locations]
+F25 [constructor, in backend.Locations]
+F26 [constructor, in backend.Locations]
+F27 [constructor, in backend.Locations]
+F28 [constructor, in backend.Locations]
+F29 [constructor, in backend.Locations]
+F3 [constructor, in backend.Locations]
+F30 [constructor, in backend.Locations]
+F31 [constructor, in backend.Locations]
+F4 [constructor, in backend.Locations]
+F5 [constructor, in backend.Locations]
+F6 [constructor, in backend.Locations]
+F7 [constructor, in backend.Locations]
+F8 [constructor, in backend.Locations]
+F9 [constructor, in backend.Locations]
+

G

+gcombine [lemma, in lib.Maps]
+ge [definition, in lib.Lattice]
+ge [definition, in backend.CSE]
+ge [definition, in lib.Lattice]
+ge [definition, in backend.Constprop]
+ge [definition, in lib.Lattice]
+ge [definition, in lib.Sets]
+gempty [lemma, in lib.Maps]
+genv [definition, in backend.Cminor]
+genv [definition, in backend.LTL]
+Genv [module, in backend.Globalenvs]
+genv [definition, in backend.PPC]
+GENV [module, in backend.Globalenvs]
+genv [definition, in backend.Csharpminor]
+genv [inductive, in backend.Globalenvs]
+genv [definition, in backend.RTL]
+genv [definition, in backend.Mach]
+genv [definition, in backend.Linear]
+get [definition, in lib.Maps]
+get [definition, in lib.Maps]
+get [definition, in lib.Maps]
+Get [definition, in backend.Parallelmove]
+get [definition, in backend.Locations]
+get [definition, in lib.Lattice]
+get [definition, in lib.Maps]
+get [definition, in backend.Parallelmove]
+get [definition, in backend.RTLtyping]
+getdst [definition, in backend.Parallelmove]
+getdst_add [lemma, in backend.Parallelmove]
+getdst_app [lemma, in backend.Parallelmove]
+getdst_f [lemma, in backend.Alloctyping_aux]
+getdst_lists2moves [lemma, in backend.Allocproof_aux]
+getdst_map [lemma, in backend.Parallelmove]
+getN [definition, in backend.Mem]
+getN_agree [lemma, in backend.Mem]
+getN_init [lemma, in backend.Mem]
+getN_inject [lemma, in backend.Mem]
+getN_setN_mismatch [lemma, in backend.Mem]
+getN_setN_other [lemma, in backend.Mem]
+getN_setN_overlap [lemma, in backend.Mem]
+getN_setN_same [lemma, in backend.Mem]
+getsrc [definition, in backend.Parallelmove]
+getsrcdst_app [lemma, in backend.Allocproof_aux]
+getsrc_add [lemma, in backend.Parallelmove]
+getsrc_add1 [lemma, in backend.Parallelmove]
+getsrc_app [lemma, in backend.Parallelmove]
+getsrc_f [lemma, in backend.Alloctyping_aux]
+getsrc_map [lemma, in backend.Parallelmove]
+get_add_1 [lemma, in backend.RTLtyping]
+get_add_2 [lemma, in backend.RTLtyping]
+get_bot [lemma, in lib.Lattice]
+get_empty [lemma, in backend.RTLtyping]
+get_noWrite [lemma, in backend.Parallelmove]
+get_pexec_id_noWrite [lemma, in backend.Parallelmove]
+get_slot [inductive, in backend.Machabstr]
+get_slot_index [lemma, in backend.Stackingproof]
+get_slot_intro [constructor, in backend.Machabstr]
+get_slot_ok [lemma, in backend.Stackingproof]
+get_top [lemma, in lib.Lattice]
+get_update [lemma, in backend.Parallelmove]
+get_update_diff [lemma, in backend.Parallelmove]
+get_update_id [lemma, in backend.Parallelmove]
+get_update_ndiff [lemma, in backend.Parallelmove]
+get_xget_h [lemma, in lib.Maps]
+ge_bot [lemma, in lib.Lattice]
+ge_bot [lemma, in lib.Lattice]
+ge_bot [lemma, in lib.Sets]
+ge_bot [lemma, in lib.Lattice]
+ge_bot [lemma, in backend.Constprop]
+ge_lub_left [lemma, in lib.Lattice]
+ge_lub_left [lemma, in lib.Sets]
+ge_lub_left [lemma, in backend.Constprop]
+ge_lub_left [lemma, in lib.Lattice]
+ge_lub_left [lemma, in lib.Lattice]
+ge_lub_right [lemma, in lib.Sets]
+ge_refl [lemma, in lib.Lattice]
+ge_refl [lemma, in lib.Sets]
+ge_refl [lemma, in lib.Lattice]
+ge_refl [lemma, in lib.Lattice]
+ge_refl [lemma, in backend.Constprop]
+ge_top [lemma, in lib.Lattice]
+ge_top [lemma, in backend.Constprop]
+ge_top [lemma, in lib.Lattice]
+ge_top [lemma, in lib.Lattice]
+ge_trans [lemma, in lib.Lattice]
+ge_trans [lemma, in backend.Constprop]
+ge_trans [lemma, in lib.Sets]
+ge_trans [lemma, in lib.Lattice]
+ge_trans [lemma, in lib.Lattice]
+gi [lemma, in lib.Maps]
+gi [lemma, in lib.Maps]
+gi [lemma, in lib.Maps]
+gleaf [lemma, in lib.Maps]
+globalenv [definition, in backend.Globalenvs]
+Globalenvs [library]
+globalenv_initmem [definition, in backend.Globalenvs]
+gmap [lemma, in lib.Maps]
+gmap [lemma, in lib.Maps]
+gmap [lemma, in lib.Maps]
+gmap [lemma, in lib.Maps]
+good_state [definition, in backend.Kildall]
+goto_label [definition, in backend.PPC]
+GPR0 [constructor, in backend.PPC]
+GPR1 [constructor, in backend.PPC]
+GPR10 [constructor, in backend.PPC]
+GPR11 [constructor, in backend.PPC]
+GPR12 [constructor, in backend.PPC]
+GPR13 [constructor, in backend.PPC]
+GPR14 [constructor, in backend.PPC]
+GPR15 [constructor, in backend.PPC]
+GPR16 [constructor, in backend.PPC]
+GPR17 [constructor, in backend.PPC]
+GPR18 [constructor, in backend.PPC]
+GPR19 [constructor, in backend.PPC]
+GPR2 [constructor, in backend.PPC]
+GPR20 [constructor, in backend.PPC]
+GPR21 [constructor, in backend.PPC]
+GPR22 [constructor, in backend.PPC]
+GPR23 [constructor, in backend.PPC]
+GPR24 [constructor, in backend.PPC]
+GPR25 [constructor, in backend.PPC]
+GPR26 [constructor, in backend.PPC]
+GPR27 [constructor, in backend.PPC]
+GPR28 [constructor, in backend.PPC]
+GPR29 [constructor, in backend.PPC]
+GPR3 [constructor, in backend.PPC]
+GPR30 [constructor, in backend.PPC]
+GPR31 [constructor, in backend.PPC]
+GPR4 [constructor, in backend.PPC]
+GPR5 [constructor, in backend.PPC]
+GPR6 [constructor, in backend.PPC]
+GPR7 [constructor, in backend.PPC]
+GPR8 [constructor, in backend.PPC]
+GPR9 [constructor, in backend.PPC]
+gpr_or_zero [definition, in backend.PPC]
+gpr_or_zero_not_zero [lemma, in backend.PPCgenproof1]
+gpr_or_zero_zero [lemma, in backend.PPCgenproof1]
+graph [inductive, in backend.InterfGraph]
+graph_coloring [axiom, in backend.Coloring]
+graph_incl [definition, in backend.InterfGraph]
+graph_incl_refl [lemma, in backend.Coloringproof]
+graph_incl_trans [lemma, in backend.InterfGraph]
+gro [lemma, in lib.Maps]
+grs [lemma, in lib.Maps]
+gsident [lemma, in lib.Maps]
+gsident [lemma, in lib.Maps]
+gsident [lemma, in lib.Maps]
+gso [lemma, in lib.Maps]
+gso [lemma, in backend.Locations]
+gso [lemma, in lib.Maps]
+gso [lemma, in lib.Maps]
+gso [lemma, in lib.Lattice]
+gso [lemma, in lib.Maps]
+gss [lemma, in lib.Maps]
+gss [lemma, in lib.Maps]
+gss [lemma, in backend.Locations]
+gss [lemma, in lib.Maps]
+gss [lemma, in lib.Lattice]
+gss [lemma, in lib.Maps]
+gsspec [lemma, in lib.Maps]
+gsspec [lemma, in lib.Maps]
+gsspec [lemma, in lib.Maps]
+gsspec [lemma, in lib.Maps]
+

H

+half_modulus [definition, in lib.Integers]
+has_type [definition, in backend.Values]
+has_type_list [definition, in backend.Values]
+head_but_last [definition, in backend.Parallelmove]
+high_bound [definition, in backend.Mem]
+high_bound_alloc [lemma, in backend.Mem]
+high_bound_free [lemma, in backend.Mem]
+high_bound_store [lemma, in backend.Mem]
+high_half_signed [axiom, in backend.PPC]
+high_half_signed_type [axiom, in backend.PPC]
+high_half_signed_zero [lemma, in backend.PPCgenproof1]
+high_half_unsigned [axiom, in backend.PPC]
+high_half_unsigned_type [axiom, in backend.PPC]
+high_half_unsigned_zero [lemma, in backend.PPCgenproof1]
+high_s [definition, in backend.PPCgen]
+high_u [definition, in backend.PPCgen]
+

I

+ident [definition, in backend.AST]
+identify [definition, in lib.union_find]
+identify_aux_decomp [lemma, in lib.union_find]
+identify_base [definition, in lib.union_find]
+identify_base_a_maps_to_b [lemma, in lib.union_find]
+identify_base_b_canon [lemma, in lib.union_find]
+identify_base_order_wf [lemma, in lib.union_find]
+identify_base_repr [lemma, in lib.union_find]
+identify_base_repr_order [lemma, in lib.union_find]
+identify_base_sameclass_1 [lemma, in lib.union_find]
+identify_base_sameclass_2 [lemma, in lib.union_find]
+Identset [module, in backend.Cminorgen]
+ident_eq [definition, in backend.AST]
+ifthenelse [definition, in backend.Cmconstr]
+IMap [module, in lib.Maps]
+immediate [inductive, in backend.PPC]
+immediate [inductive, in backend.PPC]
+immediate [inductive, in backend.PPC]
+immediate [inductive, in backend.PPC]
+immediate [inductive, in backend.PPC]
+immediate [inductive, in backend.PPC]
+included [definition, in backend.RTLtyping]
+included_consistent [lemma, in backend.RTLtyping]
+included_identify [lemma, in backend.RTLtyping]
+included_mapped [lemma, in backend.RTLtyping]
+included_mapped_forall [lemma, in backend.RTLtyping]
+included_refl [lemma, in backend.RTLtyping]
+included_trans [lemma, in backend.RTLtyping]
+Inclusion [library]
+inclusion_theorem [lemma, in lib.Inclusion]
+incl_app_inv_l [lemma, in lib.Coqlib]
+incl_app_inv_r [lemma, in lib.Coqlib]
+incl_cons_inv [lemma, in lib.Coqlib]
+incl_dst [lemma, in backend.Alloctyping_aux]
+incl_find_label [lemma, in backend.Machtyping]
+incl_nil [lemma, in backend.Alloctyping_aux]
+incl_same_head [lemma, in lib.Coqlib]
+incl_src [lemma, in backend.Alloctyping_aux]
+Incoming [constructor, in backend.Locations]
+Incoming [inductive, in backend.LTLtyping]
+Incoming [inductive, in backend.Lineartyping]
+index [definition, in backend.Locations]
+index [definition, in lib.Maps]
+index [definition, in lib.Maps]
+IndexedMreg [module, in backend.Locations]
+INDEXED_TYPE [module, in lib.Maps]
+index_arg_valid [lemma, in backend.Stackingproof]
+index_diff [definition, in backend.Stackingproof]
+index_float_callee_save [definition, in backend.Conventions]
+index_float_callee_save_inj [lemma, in backend.Conventions]
+index_float_callee_save_pos [lemma, in backend.Conventions]
+index_float_callee_save_pos2 [lemma, in backend.Conventions]
+index_inj [lemma, in lib.Maps]
+index_inj [lemma, in backend.Locations]
+index_inj [lemma, in lib.Maps]
+index_int_callee_save [definition, in backend.Conventions]
+index_int_callee_save_inj [lemma, in backend.Conventions]
+index_int_callee_save_pos [lemma, in backend.Conventions]
+index_int_callee_save_pos2 [lemma, in backend.Conventions]
+index_local_valid [lemma, in backend.Stackingproof]
+index_saved_float_valid [lemma, in backend.Stackingproof]
+index_saved_int_valid [lemma, in backend.Stackingproof]
+index_val [definition, in backend.Stackingproof]
+index_valid [definition, in backend.Stackingproof]
+index_val_init_frame [lemma, in backend.Stackingproof]
+Indst_noOverlap_aux [lemma, in backend.Parallelmove]
+Ingetsrc_swap [lemma, in backend.Parallelmove]
+Ingetsrc_swap2 [lemma, in backend.Parallelmove]
+init [definition, in lib.Maps]
+init [definition, in backend.Locations]
+init [definition, in lib.Maps]
+init [definition, in lib.Maps]
+initial_state_invariant [lemma, in backend.Kildall]
+initmem_nullptr [lemma, in backend.Globalenvs]
+initmem_undef [lemma, in backend.Globalenvs]
+init_frame [definition, in backend.Machabstr]
+init_mapping [definition, in backend.RTLgen]
+init_mapping_wf [lemma, in backend.RTLgenproof1]
+init_mem [definition, in backend.Globalenvs]
+init_mem_transf [lemma, in backend.Globalenvs]
+init_mem_transf_partial [lemma, in backend.Globalenvs]
+init_regs [definition, in backend.RTL]
+init_state [definition, in backend.RTLgen]
+init_state_wf [lemma, in backend.RTLgen]
+Inj [constructor, in lib.Lattice]
+inject_incr [definition, in backend.Mem]
+inject_incr_refl [lemma, in backend.Mem]
+inject_incr_trans [lemma, in backend.Mem]
+Inop [constructor, in backend.RTL]
+insert_bin [definition, in lib.Inclusion]
+insert_bin_included [lemma, in lib.Inclusion]
+insert_lenv [inductive, in backend.Cmconstrproof]
+insert_lenv_lookup1 [lemma, in backend.Cmconstrproof]
+insert_lenv_lookup2 [lemma, in backend.Cmconstrproof]
+insert_lenv_S [constructor, in backend.Cmconstrproof]
+insert_lenv_0 [constructor, in backend.Cmconstrproof]
+instruction [inductive, in backend.Linear]
+instruction [inductive, in backend.PPC]
+instruction [inductive, in backend.RTL]
+instruction [inductive, in backend.Mach]
+instr_at_incr [lemma, in backend.RTLgenproof1]
+int [inductive, in lib.Integers]
+Int [module, in lib.Integers]
+Integers [library]
+interfere [definition, in backend.InterfGraph]
+interfere_incl [lemma, in backend.Coloringproof]
+interfere_mreg [definition, in backend.InterfGraph]
+interfere_mreg_incl [lemma, in backend.Coloringproof]
+interfere_sym [lemma, in backend.InterfGraph]
+InterfGraph [library]
+interf_graph [definition, in backend.Coloring]
+interf_graph_correct_1 [lemma, in backend.Coloringproof]
+interf_graph_correct_2 [lemma, in backend.Coloringproof]
+interf_graph_correct_3 [lemma, in backend.Coloringproof]
+intoffloat [definition, in backend.Cmconstr]
+intoffloat [axiom, in lib.Floats]
+intoffloat [definition, in backend.Values]
+intval [definition, in backend.Constprop]
+intval_correct [lemma, in backend.Constpropproof]
+int_add_no_overflow [lemma, in backend.Machabstr2mach]
+int_callee_save [definition, in backend.Lineartyping]
+int_callee_save_bound [lemma, in backend.Linearizetyping]
+int_callee_save_norepet [lemma, in backend.Conventions]
+int_callee_save_not_destroyed [lemma, in backend.Conventions]
+int_callee_save_regs [definition, in backend.Conventions]
+int_callee_save_type [lemma, in backend.Conventions]
+int_float_callee_save_disjoint [lemma, in backend.Conventions]
+int_local [definition, in backend.Lineartyping]
+int_local_slot_bound [lemma, in backend.Linearizetyping]
+int_of_one_bits [definition, in lib.Integers]
+int_param_regs [definition, in backend.Conventions]
+inv_eval_Eop_0 [lemma, in backend.Cmconstrproof]
+inv_eval_Eop_1 [lemma, in backend.Cmconstrproof]
+inv_eval_Eop_2 [lemma, in backend.Cmconstrproof]
+in_bounds [definition, in backend.Mem]
+in_bounds_exten [lemma, in backend.Mem]
+in_bounds_holds [lemma, in backend.Mem]
+in_bounds_inject [lemma, in backend.Mem]
+in_cons_noteq [lemma, in backend.Allocproof_aux]
+in_incr [definition, in backend.Kildall]
+in_incr_refl [lemma, in backend.Kildall]
+in_incr_trans [lemma, in backend.Kildall]
+In_Indst [lemma, in backend.Parallelmove]
+in_move__in_srcdst [lemma, in backend.Alloctyping_aux]
+In_norepet [lemma, in backend.Allocproof_aux]
+in_notin_diff [lemma, in backend.Locations]
+In_noTmp_notempo [lemma, in backend.Parallelmove]
+in_or_insert_bin [lemma, in lib.Inclusion]
+in_or_notin_callstack [lemma, in backend.Machabstr2mach]
+In_permute_app_head [lemma, in lib.Inclusion]
+in_range [definition, in lib.Integers]
+in_range_range [lemma, in lib.Integers]
+in_remove_head [lemma, in lib.Inclusion]
+In_SD_diff [lemma, in backend.Parallelmove]
+In_SD_diff' [lemma, in backend.Parallelmove]
+In_SD_no_o [lemma, in backend.Parallelmove]
+in_split_move [lemma, in backend.Alloctyping_aux]
+in_xelements [lemma, in lib.Maps]
+in_xkeys [lemma, in lib.Maps]
+IR [constructor, in backend.PPC]
+ireg [inductive, in backend.PPC]
+ireg_eq [lemma, in backend.PPC]
+ireg_of [definition, in backend.PPCgen]
+ireg_of_is_data_reg [lemma, in backend.PPCgenproof1]
+ireg_of_not_GPR1 [lemma, in backend.PPCgenproof1]
+ireg_of_not_GPR2 [lemma, in backend.PPCgenproof1]
+ireg_val [lemma, in backend.PPCgenproof1]
+isfalse_not_istrue [lemma, in backend.Values]
+istrue_not_isfalse [lemma, in backend.Values]
+is_basic_block_head [definition, in backend.Kildall]
+is_bool [definition, in backend.Values]
+is_data_reg [definition, in backend.PPCgenproof1]
+is_false [definition, in lib.Integers]
+is_false [definition, in backend.Values]
+is_goto_block [definition, in backend.Tunneling]
+is_goto_block_correct [lemma, in backend.Tunnelingproof]
+is_label [definition, in backend.PPC]
+is_label [definition, in backend.Mach]
+is_label [definition, in backend.Linear]
+is_label_correct [lemma, in backend.PPC]
+is_label_correct [lemma, in backend.Mach]
+is_label_correct [lemma, in backend.Linear]
+is_move_operation [definition, in backend.Op]
+is_move_operation_correct [lemma, in backend.Op]
+is_power2 [definition, in lib.Integers]
+is_power2_correct [lemma, in lib.Integers]
+is_power2_range [lemma, in lib.Integers]
+is_power2_rng [lemma, in lib.Integers]
+is_rlw_mask [definition, in lib.Integers]
+is_rlw_mask_rec [definition, in lib.Integers]
+is_tail [inductive, in backend.Linearizeproof]
+is_tail_cons [constructor, in backend.Linearizeproof]
+is_tail_cons_left [lemma, in backend.Linearizeproof]
+is_tail_exec_instr [lemma, in backend.Linearizeproof]
+is_tail_exec_instrs [lemma, in backend.Linearizeproof]
+is_tail_find_label [lemma, in backend.Linearizeproof]
+is_tail_in [lemma, in backend.Linearizeproof]
+is_tail_refl [constructor, in backend.Linearizeproof]
+is_trivial_op [definition, in backend.CSE]
+is_true [definition, in lib.Integers]
+is_true [definition, in backend.Values]
+iterate [definition, in backend.Kildall]
+iterate_base [lemma, in backend.Kildall]
+iterate_incr [lemma, in backend.Kildall]
+iterate_solution [lemma, in backend.Kildall]
+iterate_step [lemma, in backend.Kildall]
+iter_step [definition, in backend.Kildall]
+IT1 [constructor, in backend.Locations]
+IT2 [constructor, in backend.Locations]
+IT3 [constructor, in backend.Locations]
+

K

+Kildall [library]
+kill_loads [definition, in backend.CSE]
+kill_load_eqs [definition, in backend.CSE]
+kill_load_eqs_incl [lemma, in backend.CSEproof]
+kill_load_eqs_ops [lemma, in backend.CSEproof]
+kill_load_satisfiable [lemma, in backend.CSEproof]
+

L

+L [module, in backend.Kildall]
+L [module, in backend.Kildall]
+L [module, in backend.Kildall]
+L [module, in backend.Kildall]
+L [module, in backend.Kildall]
+L [module, in backend.Kildall]
+L [module, in backend.Kildall]
+L [module, in backend.Kildall]
+L [module, in backend.Kildall]
+label [definition, in backend.Linear]
+label [definition, in backend.PPC]
+label [definition, in backend.Mach]
+label_in_lin_block [lemma, in backend.Linearizeproof]
+label_in_lin_rec [lemma, in backend.Linearizeproof]
+label_pos [definition, in backend.PPC]
+label_pos_code_tail [lemma, in backend.PPCgenproof]
+last [definition, in backend.Parallelmove]
+last_app [lemma, in backend.Parallelmove]
+last_cons [lemma, in backend.Parallelmove]
+last_replace [lemma, in backend.Parallelmove]
+Lattice [library]
+lbl [definition, in backend.Linearize]
+lbl [definition, in backend.Linearize]
+LBoolean [module, in lib.Lattice]
+Lcall [constructor, in backend.Linear]
+Lcond [constructor, in backend.Linear]
+Leaf [constructor, in lib.Maps]
+leaf [definition, in lib.Inclusion]
+leaf [constructor, in lib.Inclusion]
+leaf [definition, in lib.Inclusion]
+leaf [definition, in lib.Inclusion]
+length_addr_args [lemma, in backend.Allocproof]
+length_app [lemma, in backend.Parallelmove]
+length_cond_args [lemma, in backend.Allocproof]
+length_op_args [lemma, in backend.Allocproof]
+length_replace [lemma, in backend.Parallelmove]
+letenv [definition, in backend.Cminor]
+letenv [definition, in backend.Csharpminor]
+let_fold_args_res [lemma, in backend.RTLtyping]
+LFlat [module, in lib.Lattice]
+Lgetstack [constructor, in backend.Linear]
+Lgoto [constructor, in backend.Linear]
+lift [definition, in backend.Cmconstr]
+lift_condexpr [definition, in backend.Cmconstr]
+lift_expr [definition, in backend.Cmconstr]
+lift_exprlist [definition, in backend.Cmconstr]
+Linear [library]
+Linearize [library]
+Linearizeproof [library]
+Linearizetyping [library]
+linearize_block [definition, in backend.Linearize]
+linearize_block_incl [lemma, in backend.Linearizetyping]
+linearize_body [definition, in backend.Linearize]
+linearize_function [definition, in backend.Linearize]
+Lineartyping [library]
+link_invariant [definition, in backend.Machtyping]
+listsLoc2Moves [definition, in backend.Parallelmove]
+listsLoc2Moves [definition, in backend.Allocation]
+list_append_map [lemma, in lib.Coqlib]
+list_disjoint [definition, in lib.Coqlib]
+list_disjoint_cons_left [lemma, in lib.Coqlib]
+list_disjoint_cons_right [lemma, in lib.Coqlib]
+list_disjoint_notin [lemma, in lib.Coqlib]
+list_disjoint_sym [lemma, in lib.Coqlib]
+list_forall2 [inductive, in lib.Coqlib]
+list_forall2_cons [constructor, in lib.Coqlib]
+list_forall2_imply [lemma, in lib.Coqlib]
+list_forall2_nil [constructor, in lib.Coqlib]
+list_in_map_inv [lemma, in lib.Coqlib]
+list_length_map [lemma, in lib.Coqlib]
+list_map_compose [lemma, in lib.Coqlib]
+list_map_exten [lemma, in lib.Coqlib]
+list_map_norepet [lemma, in lib.Coqlib]
+list_map_nth [lemma, in lib.Coqlib]
+list_norepet [inductive, in lib.Coqlib]
+list_norepet_append [lemma, in lib.Coqlib]
+list_norepet_append_left [lemma, in lib.Coqlib]
+list_norepet_append_right [lemma, in lib.Coqlib]
+list_norepet_cons [constructor, in lib.Coqlib]
+list_norepet_dec [lemma, in lib.Coqlib]
+list_norepet_nil [constructor, in lib.Coqlib]
+live0 [definition, in backend.Allocproof]
+Llabel [constructor, in backend.Linear]
+Lload [constructor, in backend.Linear]
+load [definition, in backend.Mem]
+load [definition, in backend.Cmconstr]
+Load [constructor, in backend.CSE]
+loadimm [definition, in backend.PPCgen]
+loadimm_correct [lemma, in backend.PPCgenproof1]
+loadind [definition, in backend.PPCgen]
+loadind_aux [definition, in backend.PPCgen]
+loadind_aux_correct [lemma, in backend.PPCgenproof1]
+loadind_correct [lemma, in backend.PPCgenproof1]
+loadv [definition, in backend.Mem]
+loadv_inject [lemma, in backend.Mem]
+loadv_8_signed_unsigned [lemma, in backend.PPCgenproof]
+load1 [definition, in backend.PPC]
+load2 [definition, in backend.PPC]
+load_agree [lemma, in backend.Mem]
+load_alloc_other [lemma, in backend.Mem]
+load_alloc_same [lemma, in backend.Mem]
+load_contentmap_agree [lemma, in backend.Mem]
+load_contents [definition, in backend.Mem]
+load_contents_init [lemma, in backend.Mem]
+load_contents_inject [lemma, in backend.Mem]
+load_extends [lemma, in backend.Mem]
+load_free [lemma, in backend.Mem]
+load_freelist [lemma, in backend.Cminorgenproof]
+load_from_alloc_is_undef [lemma, in backend.Cminorgenproof]
+load_inject [lemma, in backend.Mem]
+load_inv [lemma, in backend.Mem]
+load_in_bounds [lemma, in backend.Mem]
+load_result [definition, in backend.Values]
+load_result_idem [lemma, in backend.Cminorgenproof]
+load_result_inject [lemma, in backend.Mem]
+load_result_normalized [lemma, in backend.Cminorgenproof]
+load_result_ty [lemma, in backend.Machabstr2mach]
+load_stack [definition, in backend.Mach]
+load_store_contents_mismatch [lemma, in backend.Mem]
+load_store_contents_other [lemma, in backend.Mem]
+load_store_contents_overlap [lemma, in backend.Mem]
+load_store_contents_same [lemma, in backend.Mem]
+load_store_other [lemma, in backend.Mem]
+load_store_same [lemma, in backend.Mem]
+loc [inductive, in backend.Locations]
+Loc [module, in backend.Locations]
+Local [constructor, in backend.Locations]
+local_variable [inductive, in backend.Csharpminor]
+Locations [library]
+Locmap [module, in backend.Locations]
+locset [definition, in backend.LTL]
+locset [definition, in backend.Linear]
+locs_acceptable [definition, in backend.Conventions]
+locs_acceptable_disj_temporaries [lemma, in backend.Conventions]
+locs_read_ok [definition, in backend.Alloctyping]
+locs_write_ok [definition, in backend.Alloctyping]
+loc_acceptable [definition, in backend.Conventions]
+loc_acceptable_noteq_diff [lemma, in backend.Allocproof]
+loc_acceptable_notin_notin [lemma, in backend.Allocproof]
+loc_arguments [definition, in backend.Conventions]
+loc_arguments_acceptable [lemma, in backend.Conventions]
+loc_arguments_bounded [lemma, in backend.Conventions]
+loc_arguments_length [lemma, in backend.Conventions]
+loc_arguments_norepet [lemma, in backend.Conventions]
+loc_arguments_not_temporaries [lemma, in backend.Conventions]
+loc_arguments_rec [definition, in backend.Conventions]
+loc_arguments_type [lemma, in backend.Conventions]
+loc_argument_acceptable [definition, in backend.Conventions]
+loc_is_acceptable [definition, in backend.Coloring]
+loc_is_acceptable_correct [lemma, in backend.Coloringproof]
+loc_parameters [definition, in backend.Conventions]
+loc_parameters_not_temporaries [lemma, in backend.Conventions]
+loc_parameters_type [lemma, in backend.Conventions]
+loc_read_ok [definition, in backend.Alloctyping]
+loc_result [definition, in backend.Conventions]
+loc_result_acceptable [lemma, in backend.Conventions]
+loc_result_type [lemma, in backend.Conventions]
+loc_write_ok [definition, in backend.Alloctyping]
+Lop [constructor, in backend.Linear]
+low_bound [definition, in backend.Mem]
+low_bound_alloc [lemma, in backend.Mem]
+low_bound_free [lemma, in backend.Mem]
+low_bound_store [lemma, in backend.Mem]
+low_half_signed [axiom, in backend.PPC]
+low_half_signed_type [axiom, in backend.PPC]
+low_half_unsigned [axiom, in backend.PPC]
+low_half_unsigned_type [axiom, in backend.PPC]
+low_high_half_signed [axiom, in backend.PPC]
+low_high_half_unsigned [axiom, in backend.PPC]
+low_high_s [lemma, in backend.PPCgenproof1]
+low_high_u [lemma, in backend.PPCgenproof1]
+low_high_u_xor [lemma, in backend.PPCgenproof1]
+low_s [definition, in backend.PPCgen]
+low_u [definition, in backend.PPCgen]
+LPMap [module, in lib.Lattice]
+LR [constructor, in backend.PPC]
+Lreturn [constructor, in backend.Linear]
+Lsetstack [constructor, in backend.Linear]
+Lstore [constructor, in backend.Linear]
+lt [definition, in lib.Integers]
+lt [definition, in lib.Ordered]
+lt [definition, in lib.Ordered]
+lt [definition, in lib.Ordered]
+LTL [library]
+LTLtyping [library]
+ltu [definition, in lib.Integers]
+lt_not_eq [lemma, in lib.Ordered]
+lt_not_eq [lemma, in lib.Ordered]
+lt_not_eq [lemma, in lib.Ordered]
+lt_trans [lemma, in lib.Ordered]
+lt_trans [lemma, in lib.Ordered]
+lt_trans [lemma, in lib.Ordered]
+lub [definition, in lib.Lattice]
+lub [definition, in lib.Lattice]
+lub [definition, in lib.Sets]
+lub [definition, in lib.Lattice]
+lub [definition, in backend.Constprop]
+lub_commut [lemma, in lib.Lattice]
+lub_commut [lemma, in backend.Constprop]
+lub_commut [lemma, in lib.Lattice]
+lub_commut [lemma, in lib.Sets]
+lub_commut [lemma, in lib.Lattice]
+LVarray [constructor, in backend.Csharpminor]
+LVscalar [constructor, in backend.Csharpminor]
+

M

+Mach [library]
+Machabstr [library]
+Machabstr2mach [library]
+Machtyping [library]
+Main [library]
+MakeSet [module, in lib.Sets]
+make_addimm [definition, in backend.Constprop]
+make_addimm_correct [lemma, in backend.Constpropproof]
+make_andimm [definition, in backend.Constprop]
+make_andimm_correct [lemma, in backend.Constpropproof]
+make_cast [definition, in backend.Cminorgen]
+make_cast_correct [lemma, in backend.Cminorgenproof]
+make_env [definition, in backend.Stacking]
+make_load [definition, in backend.Cminorgen]
+make_load_correct [lemma, in backend.Cminorgenproof]
+make_mulimm [definition, in backend.Constprop]
+make_mulimm_correct [lemma, in backend.Constpropproof]
+make_op [definition, in backend.Cminorgen]
+make_op_correct [lemma, in backend.Cminorgenproof]
+make_orimm [definition, in backend.Constprop]
+make_orimm_correct [lemma, in backend.Constpropproof]
+make_predecessors [definition, in backend.Kildall]
+make_predecessors_correct [lemma, in backend.Kildall]
+make_shlimm [definition, in backend.Constprop]
+make_shlimm_correct [lemma, in backend.Constpropproof]
+make_shrimm [definition, in backend.Constprop]
+make_shrimm_correct [lemma, in backend.Constpropproof]
+make_shruimm [definition, in backend.Constprop]
+make_shruimm_correct [lemma, in backend.Constpropproof]
+make_stackaddr [definition, in backend.Cminorgen]
+make_stackaddr_correct [lemma, in backend.Cminorgenproof]
+make_store [definition, in backend.Cminorgen]
+make_store_correct [lemma, in backend.Cminorgenproof]
+make_xorimm [definition, in backend.Constprop]
+make_xorimm_correct [lemma, in backend.Constpropproof]
+map [definition, in lib.Maps]
+map [definition, in lib.Maps]
+map [definition, in lib.Maps]
+map [definition, in lib.Maps]
+MAP [module, in lib.Maps]
+MAP [module, in lib.union_find]
+mapped [definition, in backend.RTLtyping]
+mapped_included_consistent [lemma, in backend.RTLtyping]
+mapped_list_included [lemma, in backend.RTLtyping]
+mapping [inductive, in backend.RTLgen]
+Maps [library]
+map_f_getsrc_getdst [lemma, in backend.Alloctyping_aux]
+map_inv [lemma, in backend.Allocproof_aux]
+map_wf [inductive, in backend.RTLgenproof1]
+map_wf_incr [lemma, in backend.RTLgenproof1]
+match_callstack [inductive, in backend.Cminorgenproof]
+match_callstack_alloc_left [lemma, in backend.Cminorgenproof]
+match_callstack_alloc_other [lemma, in backend.Cminorgenproof]
+match_callstack_alloc_right [lemma, in backend.Cminorgenproof]
+match_callstack_alloc_variables [lemma, in backend.Cminorgenproof]
+match_callstack_alloc_variables_rec [lemma, in backend.Cminorgenproof]
+match_callstack_freelist [lemma, in backend.Cminorgenproof]
+match_callstack_freelist_rec [lemma, in backend.Cminorgenproof]
+match_callstack_incr_bound [lemma, in backend.Cminorgenproof]
+match_callstack_mapped [lemma, in backend.Cminorgenproof]
+match_callstack_match_globalenvs [lemma, in backend.Cminorgenproof]
+match_callstack_store_above [lemma, in backend.Cminorgenproof]
+match_callstack_store_local [lemma, in backend.Cminorgenproof]
+match_callstack_store_local_unchanged [lemma, in backend.Cminorgenproof]
+match_env [inductive, in backend.Cminorgenproof]
+match_env [inductive, in backend.RTLgenproof1]
+match_env_alloc_other [lemma, in backend.Cminorgenproof]
+match_env_alloc_same [lemma, in backend.Cminorgenproof]
+match_env_empty [lemma, in backend.RTLgenproof1]
+match_env_exten [lemma, in backend.RTLgenproof1]
+match_env_extensional [lemma, in backend.Cminorgenproof]
+match_env_find_reg [lemma, in backend.RTLgenproof1]
+match_env_freelist [lemma, in backend.Cminorgenproof]
+match_env_invariant [lemma, in backend.RTLgenproof1]
+match_env_letvar [lemma, in backend.RTLgenproof1]
+match_env_store_above [lemma, in backend.Cminorgenproof]
+match_env_store_local [lemma, in backend.Cminorgenproof]
+match_env_store_mapped [lemma, in backend.Cminorgenproof]
+match_env_update_temp [lemma, in backend.RTLgenproof1]
+match_env_update_var [lemma, in backend.RTLgenproof1]
+match_globalenvs [inductive, in backend.Cminorgenproof]
+match_globalenvs_init [lemma, in backend.Cminorgenproof]
+match_init_env_init_reg [lemma, in backend.RTLgenproof1]
+match_return_outcome [definition, in backend.RTLgenproof]
+match_return_reg [definition, in backend.RTLgenproof]
+match_set_locals [lemma, in backend.RTLgenproof1]
+match_set_params_init_regs [lemma, in backend.RTLgenproof1]
+match_var [inductive, in backend.Cminorgenproof]
+max_over_instrs [definition, in backend.Lineartyping]
+max_over_instrs_bound [lemma, in backend.Linearizetyping]
+max_over_list [definition, in backend.Lineartyping]
+max_over_list_bound [lemma, in backend.Linearizetyping]
+max_over_list_pos [lemma, in backend.Lineartyping]
+max_over_regs_of_funct [definition, in backend.Lineartyping]
+max_over_regs_of_funct_bound [lemma, in backend.Linearizetyping]
+max_over_regs_of_funct_pos [lemma, in backend.Lineartyping]
+max_over_regs_of_instr [definition, in backend.Lineartyping]
+max_over_slots_of_funct [definition, in backend.Lineartyping]
+max_over_slots_of_funct_bound [lemma, in backend.Linearizetyping]
+max_over_slots_of_funct_pos [lemma, in backend.Lineartyping]
+max_over_slots_of_instr [definition, in backend.Lineartyping]
+max_signed [definition, in lib.Integers]
+max_unsigned [definition, in lib.Integers]
+Mcall [constructor, in backend.Mach]
+Mcond [constructor, in backend.Mach]
+mcs_cons [constructor, in backend.Cminorgenproof]
+mcs_nil [constructor, in backend.Cminorgenproof]
+mem [inductive, in backend.Mem]
+mem [definition, in lib.Sets]
+Mem [library]
+member [definition, in backend.RTLtyping]
+member_correct [lemma, in backend.RTLtyping]
+meminj [definition, in backend.Mem]
+memory_chunk [inductive, in backend.AST]
+memory_size [inductive, in backend.Mem]
+mem_add_globals_transf [lemma, in backend.Globalenvs]
+mem_add_other [lemma, in lib.Sets]
+mem_add_same [lemma, in lib.Sets]
+mem_add_tail [lemma, in backend.InterfGraph]
+mem_chunk [definition, in backend.Mem]
+mem_empty [lemma, in lib.Sets]
+mem_exten [lemma, in backend.Mem]
+mem_inject [inductive, in backend.Mem]
+mem_remove_other [lemma, in lib.Sets]
+mem_remove_same [lemma, in lib.Sets]
+mem_type [definition, in backend.Machabstr]
+mem_union [lemma, in lib.Sets]
+mesure [definition, in backend.Parallelmove]
+Mfloat32 [constructor, in backend.AST]
+Mfloat64 [constructor, in backend.AST]
+Mgetparam [constructor, in backend.Mach]
+Mgetstack [constructor, in backend.Mach]
+Mgoto [constructor, in backend.Mach]
+Mint16signed [constructor, in backend.AST]
+Mint16unsigned [constructor, in backend.AST]
+Mint32 [constructor, in backend.AST]
+Mint8signed [constructor, in backend.AST]
+Mint8unsigned [constructor, in backend.AST]
+min_signed [definition, in lib.Integers]
+mkint_eq [lemma, in lib.Integers]
+mk_env [definition, in backend.RTLtyping]
+Mlabel [constructor, in backend.Mach]
+Mload [constructor, in backend.Mach]
+mods [definition, in lib.Integers]
+mods [definition, in backend.Cmconstr]
+mods [definition, in backend.Values]
+mods_divs [lemma, in lib.Integers]
+mods_divs [lemma, in backend.Values]
+modu [definition, in lib.Integers]
+modu [definition, in backend.Values]
+modu [definition, in backend.Cmconstr]
+modulus [definition, in lib.Integers]
+modulus_pos [lemma, in lib.Integers]
+modu_and [lemma, in lib.Integers]
+modu_divu [lemma, in lib.Integers]
+modu_divu [lemma, in backend.Values]
+modu_divu_Euclid [lemma, in lib.Integers]
+modu_pow2 [lemma, in backend.Values]
+mod_aux [definition, in backend.Cmconstr]
+mod_in_range [lemma, in lib.Integers]
+mon [definition, in backend.RTLgen]
+mone [definition, in lib.Integers]
+mone_max_unsigned [lemma, in lib.Integers]
+Mop [constructor, in backend.Mach]
+more_likely [axiom, in backend.RTLgen]
+Move [definition, in backend.Parallelmove]
+Moves [definition, in backend.Parallelmove]
+move_types_res [lemma, in backend.Alloctyping_aux]
+move_types_stepf [lemma, in backend.Alloctyping_aux]
+mreg [inductive, in backend.Locations]
+mreg_bounded [definition, in backend.Lineartyping]
+mreg_eq [lemma, in backend.Locations]
+mreg_is_bounded [lemma, in backend.Linearizetyping]
+mreg_type [definition, in backend.Locations]
+Mreturn [constructor, in backend.Mach]
+Msetstack [constructor, in backend.Mach]
+Mstore [constructor, in backend.Mach]
+mul [axiom, in lib.Floats]
+mul [definition, in lib.Integers]
+mul [definition, in backend.Cmconstr]
+mul [definition, in backend.Values]
+mulf [definition, in backend.Cmconstr]
+mulf [definition, in backend.Values]
+mulimm [definition, in backend.Cmconstr]
+mulimm_base [definition, in backend.Cmconstr]
+mulimm_cases [inductive, in backend.Cmconstr]
+mulimm_case1 [constructor, in backend.Cmconstr]
+mulimm_case2 [constructor, in backend.Cmconstr]
+mulimm_default [constructor, in backend.Cmconstr]
+mulimm_match [definition, in backend.Cmconstr]
+multiple_predecessors [lemma, in backend.Kildall]
+mul_add_distr_l [lemma, in lib.Integers]
+mul_add_distr_l [lemma, in backend.Values]
+mul_add_distr_r [lemma, in lib.Integers]
+mul_add_distr_r [lemma, in backend.Values]
+mul_assoc [lemma, in lib.Integers]
+mul_assoc [lemma, in backend.Values]
+mul_cases [inductive, in backend.Cmconstr]
+mul_case1 [constructor, in backend.Cmconstr]
+mul_case2 [constructor, in backend.Cmconstr]
+mul_commut [lemma, in backend.Values]
+mul_commut [lemma, in lib.Integers]
+mul_default [constructor, in backend.Cmconstr]
+mul_match [definition, in backend.Cmconstr]
+mul_match_aux [definition, in backend.Cmconstr]
+mul_one [lemma, in lib.Integers]
+mul_pow2 [lemma, in lib.Integers]
+mul_pow2 [lemma, in backend.Values]
+mul_zero [lemma, in lib.Integers]
+mutated_condexpr [definition, in backend.RTLgen]
+mutated_expr [definition, in backend.RTLgen]
+mutated_exprlist [definition, in backend.RTLgen]
+mutated_reg [definition, in backend.RTLgenproof1]
+mutated_reg_in_map [lemma, in backend.RTLgenproof1]
+mymap [module, in backend.RTLtyping]
+myreg [module, in backend.RTLtyping]
+myT [inductive, in backend.RTLtyping]
+

N

+n [constructor, in backend.Op]
+nat_le_bool [definition, in lib.Inclusion]
+neg [definition, in backend.Values]
+neg [definition, in lib.Integers]
+neg [axiom, in lib.Floats]
+negate_cmp [lemma, in backend.Values]
+negate_cmp [lemma, in lib.Integers]
+negate_cmpf_eq [lemma, in backend.Values]
+negate_cmpu [lemma, in lib.Integers]
+negate_cmpu [lemma, in backend.Values]
+negate_cmp_mismatch [lemma, in backend.Values]
+negate_comparison [definition, in backend.AST]
+negate_condition [definition, in backend.Op]
+negf [definition, in backend.Values]
+negfloat [definition, in backend.Cmconstr]
+negint [definition, in backend.Cmconstr]
+neg_add_distr [lemma, in backend.Values]
+neg_add_distr [lemma, in lib.Integers]
+neg_mul_distr_l [axiom, in lib.Integers]
+neg_mul_distr_r [axiom, in lib.Integers]
+neg_repr [lemma, in lib.Integers]
+neg_zero [lemma, in lib.Integers]
+neg_zero [lemma, in backend.Values]
+neq_is_neq [lemma, in backend.Parallelmove]
+new_reg [definition, in backend.RTLgen]
+new_reg_fresh [lemma, in backend.RTLgenproof1]
+new_reg_incr [lemma, in backend.RTLgenproof1]
+new_reg_not_in_map [lemma, in backend.RTLgenproof1]
+new_reg_not_mutated [lemma, in backend.RTLgenproof1]
+new_reg_return_ok [lemma, in backend.RTLgenproof1]
+new_reg_valid [lemma, in backend.RTLgenproof1]
+nextinstr [definition, in backend.PPC]
+nextinstr_inv [lemma, in backend.PPCgenproof1]
+nextinstr_set_preg [lemma, in backend.PPCgenproof1]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Allocproof_aux]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+nil [definition, in backend.Parallelmove]
+NIndexed [module, in lib.Maps]
+NMap [module, in lib.Maps]
+Node [constructor, in lib.Maps]
+node [definition, in backend.RTL]
+node [definition, in backend.LTL]
+node [constructor, in lib.Inclusion]
+non_overlap_diff [lemma, in backend.Locations]
+NoOverlap [definition, in backend.Parallelmove]
+noOverlap [definition, in backend.Parallelmove]
+noOverlapaux_insert [lemma, in backend.Parallelmove]
+noOverlapaux_swap2 [lemma, in backend.Parallelmove]
+noOverlap_aux [definition, in backend.Parallelmove]
+noOverlap_auxpop [lemma, in backend.Parallelmove]
+noOverlap_auxPop [lemma, in backend.Parallelmove]
+noOverlap_aux_app [lemma, in backend.Parallelmove]
+noOverlap_Front0 [lemma, in backend.Parallelmove]
+noOverlap_head [lemma, in backend.Parallelmove]
+noOverlap_insert [lemma, in backend.Parallelmove]
+noOverlap_movBack [lemma, in backend.Parallelmove]
+noOverlap_movBack0 [lemma, in backend.Parallelmove]
+noOverlap_movFront [lemma, in backend.Parallelmove]
+noOverlap_nil [lemma, in backend.Parallelmove]
+noOverlap_Pop [lemma, in backend.Parallelmove]
+noOverlap_pop [lemma, in backend.Parallelmove]
+noOverlap_right [lemma, in backend.Parallelmove]
+noOverlap_swap [lemma, in backend.Parallelmove]
+noO_diff [lemma, in backend.Parallelmove]
+noO_list_pnilnil [lemma, in backend.Allocproof_aux]
+noRead [definition, in backend.Parallelmove]
+noRead_app [lemma, in backend.Parallelmove]
+noRead_by_path [lemma, in backend.Parallelmove]
+norepet [inductive, in backend.Locations]
+norepet_cons [constructor, in backend.Locations]
+norepet_nil [constructor, in backend.Locations]
+norepet_SD [lemma, in backend.Allocproof_aux]
+not [definition, in lib.Integers]
+notbool [definition, in backend.Values]
+notbool [definition, in backend.Cmconstr]
+notbool [definition, in lib.Integers]
+notbool_base [definition, in backend.Cmconstr]
+notbool_idem2 [lemma, in backend.Values]
+notbool_idem3 [lemma, in backend.Values]
+notbool_isfalse_istrue [lemma, in lib.Integers]
+notbool_istrue_isfalse [lemma, in lib.Integers]
+notbool_is_bool [lemma, in backend.Values]
+notbool_negb_1 [lemma, in backend.Values]
+notbool_negb_2 [lemma, in backend.Values]
+notbool_xor [lemma, in backend.Values]
+notemporary [definition, in backend.Parallelmove]
+notin [definition, in backend.Locations]
+notindst_nW [lemma, in backend.Parallelmove]
+notint [definition, in backend.Values]
+notint [definition, in backend.Cmconstr]
+notint_cases [inductive, in backend.Cmconstr]
+notint_case1 [constructor, in backend.Cmconstr]
+notint_case2 [constructor, in backend.Cmconstr]
+notint_case3 [constructor, in backend.Cmconstr]
+notint_default [constructor, in backend.Cmconstr]
+notint_match [definition, in backend.Cmconstr]
+notin_callstack [inductive, in backend.Machabstr2mach]
+notin_callstack_cons [constructor, in backend.Machabstr2mach]
+notin_callstack_nil [constructor, in backend.Machabstr2mach]
+notin_disjoint [lemma, in backend.Locations]
+notin_not_in [lemma, in backend.Locations]
+noTmp [definition, in backend.Parallelmove]
+noTmpLast [definition, in backend.Parallelmove]
+noTmpLast_lastnoTmp [lemma, in backend.Parallelmove]
+noTmpLast_Pop [lemma, in backend.Parallelmove]
+noTmpLast_pop [lemma, in backend.Parallelmove]
+noTmpLast_popBack [lemma, in backend.Parallelmove]
+noTmpLast_push [lemma, in backend.Parallelmove]
+noTmpLast_tmpLast [lemma, in backend.Parallelmove]
+noTmpL_diff [lemma, in backend.Parallelmove]
+noTmp_app [lemma, in backend.Parallelmove]
+noTmp_append [lemma, in backend.Parallelmove]
+noTmP_noOverlap_aux [lemma, in backend.Parallelmove]
+noTmp_noReadTmp [lemma, in backend.Parallelmove]
+noTmp_noTmpLast [lemma, in backend.Parallelmove]
+noTmp_pop [lemma, in backend.Parallelmove]
+Novalue [constructor, in backend.Constprop]
+noWrite [definition, in backend.Parallelmove]
+noWrite_in [lemma, in backend.Parallelmove]
+noWrite_insert [lemma, in backend.Parallelmove]
+noWrite_movFront [lemma, in backend.Parallelmove]
+noWrite_pop [lemma, in backend.Parallelmove]
+noWrite_swap [lemma, in backend.Parallelmove]
+noWrite_tmpLast [lemma, in backend.Parallelmove]
+no_overlap [definition, in backend.Parallelmove]
+no_overlap [definition, in backend.Locations]
+no_overlapD_inv [lemma, in backend.Allocproof_aux]
+no_overlapD_invf [lemma, in backend.Allocproof_aux]
+no_overlapD_invpp [lemma, in backend.Allocproof_aux]
+no_overlapD_res [lemma, in backend.Allocproof_aux]
+no_overlap_arguments [lemma, in backend.Conventions]
+no_overlap_list [definition, in backend.Parallelmove]
+no_overlap_list_pop [lemma, in backend.Allocproof_aux]
+no_overlap_noOverlap [lemma, in backend.Parallelmove]
+no_overlap_parameters [lemma, in backend.Conventions]
+no_overlap_state [definition, in backend.Parallelmove]
+no_overlap_stateD [definition, in backend.Allocproof_aux]
+no_overlap_temp [lemma, in backend.Allocproof_aux]
+no_self_loop [lemma, in backend.Kildall]
+no_tmp13_state [definition, in backend.Allocproof_aux]
+nth_error_in [lemma, in lib.Coqlib]
+nth_error_nil [lemma, in lib.Coqlib]
+nullptr [definition, in backend.Mem]
+Numbering [module, in backend.CSE]
+numbering [inductive, in backend.CSE]
+numbering_holds [definition, in backend.CSE]
+numbering_holds_exten [lemma, in backend.CSEproof]
+numbering_satisfiable [definition, in backend.CSE]
+num_iterations [definition, in backend.Kildall]
+

O

+Oabsf [constructor, in backend.Op]
+Oabsf [constructor, in backend.Csharpminor]
+Oadd [constructor, in backend.Csharpminor]
+Oadd [constructor, in backend.Op]
+Oaddf [constructor, in backend.Csharpminor]
+Oaddf [constructor, in backend.Op]
+Oaddimm [constructor, in backend.Op]
+Oaddrstack [constructor, in backend.Op]
+Oaddrsymbol [constructor, in backend.Op]
+Oand [constructor, in backend.Op]
+Oand [constructor, in backend.Csharpminor]
+Oandimm [constructor, in backend.Op]
+Ocast16signed [constructor, in backend.Csharpminor]
+Ocast16signed [constructor, in backend.Op]
+Ocast16unsigned [constructor, in backend.Csharpminor]
+Ocast8signed [constructor, in backend.Csharpminor]
+Ocast8signed [constructor, in backend.Op]
+Ocast8unsigned [constructor, in backend.Csharpminor]
+Ocmp [constructor, in backend.Op]
+Ocmp [constructor, in backend.Csharpminor]
+Ocmpf [constructor, in backend.Csharpminor]
+Ocmpu [constructor, in backend.Csharpminor]
+Odiv [constructor, in backend.Op]
+Odiv [constructor, in backend.Csharpminor]
+Odivf [constructor, in backend.Op]
+Odivf [constructor, in backend.Csharpminor]
+Odivu [constructor, in backend.Csharpminor]
+Odivu [constructor, in backend.Op]
+offset_of_index [definition, in backend.Stacking]
+offset_of_index_disj [lemma, in backend.Stackingproof]
+offset_of_index_no_overflow [lemma, in backend.Stackingproof]
+offset_of_index_valid [lemma, in backend.Stackingproof]
+offset_sp [definition, in backend.Op]
+Ofloatconst [constructor, in backend.Op]
+Ofloatconst [constructor, in backend.Csharpminor]
+Ofloatofint [constructor, in backend.Op]
+Ofloatofint [constructor, in backend.Csharpminor]
+Ofloatofintu [constructor, in backend.Csharpminor]
+Ofloatofintu [constructor, in backend.Op]
+of_bool [definition, in backend.Values]
+of_bool_is_bool [lemma, in backend.Values]
+Ointconst [constructor, in backend.Csharpminor]
+Ointconst [constructor, in backend.Op]
+Ointoffloat [constructor, in backend.Csharpminor]
+Ointoffloat [constructor, in backend.Op]
+OK [constructor, in backend.RTLgen]
+OK [constructor, in backend.PPC]
+Omod [constructor, in backend.Csharpminor]
+Omodu [constructor, in backend.Csharpminor]
+Omove [constructor, in backend.Op]
+Omul [constructor, in backend.Csharpminor]
+Omul [constructor, in backend.Op]
+Omuladdf [constructor, in backend.Op]
+Omulf [constructor, in backend.Op]
+Omulf [constructor, in backend.Csharpminor]
+Omulimm [constructor, in backend.Op]
+Omulsubf [constructor, in backend.Op]
+Onand [constructor, in backend.Op]
+one [definition, in lib.Integers]
+one [axiom, in lib.Floats]
+Onegf [constructor, in backend.Csharpminor]
+Onegf [constructor, in backend.Op]
+one_bits [definition, in lib.Integers]
+one_bits_decomp [lemma, in lib.Integers]
+one_bits_range [lemma, in lib.Integers]
+one_not_zero [lemma, in lib.Integers]
+Onor [constructor, in backend.Op]
+Onotint [constructor, in backend.Csharpminor]
+Onxor [constructor, in backend.Op]
+Oor [constructor, in backend.Op]
+Oor [constructor, in backend.Csharpminor]
+Oorimm [constructor, in backend.Op]
+Op [constructor, in backend.CSE]
+Op [library]
+operation [inductive, in backend.Csharpminor]
+operation [inductive, in backend.Op]
+option_fold2 [definition, in backend.RTLtyping]
+option_map [definition, in lib.Coqlib]
+option_sum [lemma, in lib.union_find]
+op_strength_reduction [definition, in backend.Constprop]
+op_strength_reduction_cases [inductive, in backend.Constprop]
+op_strength_reduction_case1 [constructor, in backend.Constprop]
+op_strength_reduction_case10 [constructor, in backend.Constprop]
+op_strength_reduction_case11 [constructor, in backend.Constprop]
+op_strength_reduction_case12 [constructor, in backend.Constprop]
+op_strength_reduction_case2 [constructor, in backend.Constprop]
+op_strength_reduction_case3 [constructor, in backend.Constprop]
+op_strength_reduction_case4 [constructor, in backend.Constprop]
+op_strength_reduction_case5 [constructor, in backend.Constprop]
+op_strength_reduction_case6 [constructor, in backend.Constprop]
+op_strength_reduction_case7 [constructor, in backend.Constprop]
+op_strength_reduction_case8 [constructor, in backend.Constprop]
+op_strength_reduction_case9 [constructor, in backend.Constprop]
+op_strength_reduction_correct [lemma, in backend.Constpropproof]
+op_strength_reduction_default [constructor, in backend.Constprop]
+op_strength_reduction_match [definition, in backend.Constprop]
+or [definition, in lib.Integers]
+or [definition, in backend.Values]
+or [definition, in backend.Cmconstr]
+Ordered [library]
+OrderedIndexed [module, in lib.Ordered]
+OrderedMreg [module, in backend.InterfGraph]
+OrderedPair [module, in lib.Ordered]
+OrderedPositive [module, in lib.Ordered]
+OrderedReg [module, in backend.InterfGraph]
+OrderedRegMreg [module, in backend.InterfGraph]
+OrderedRegReg [module, in backend.InterfGraph]
+ordered_pair [definition, in backend.InterfGraph]
+ordered_pair_charact [lemma, in backend.InterfGraph]
+ordered_pair_sym [lemma, in backend.InterfGraph]
+ORDERED_TYPE_WITH_TOP [module, in backend.Kildall]
+orimm [definition, in backend.PPCgen]
+orimm_correct [lemma, in backend.PPCgenproof1]
+Orolm [constructor, in backend.Op]
+or_assoc [lemma, in lib.Integers]
+or_assoc [lemma, in backend.Values]
+or_cases [inductive, in backend.Cmconstr]
+or_case1 [constructor, in backend.Cmconstr]
+or_commut [lemma, in lib.Integers]
+or_commut [lemma, in backend.Values]
+or_default [constructor, in backend.Cmconstr]
+or_idem [lemma, in lib.Integers]
+or_match [definition, in backend.Cmconstr]
+or_mone [lemma, in lib.Integers]
+or_of_bool [lemma, in backend.Values]
+or_rolm [lemma, in lib.Integers]
+or_rolm [lemma, in backend.Values]
+or_zero [lemma, in lib.Integers]
+Oshl [constructor, in backend.Csharpminor]
+Oshl [constructor, in backend.Op]
+Oshr [constructor, in backend.Op]
+Oshr [constructor, in backend.Csharpminor]
+Oshrimm [constructor, in backend.Op]
+Oshru [constructor, in backend.Op]
+Oshru [constructor, in backend.Csharpminor]
+Oshrximm [constructor, in backend.Op]
+Osingleoffloat [constructor, in backend.Op]
+Osingleoffloat [constructor, in backend.Csharpminor]
+Osub [constructor, in backend.Csharpminor]
+Osub [constructor, in backend.Op]
+Osubf [constructor, in backend.Csharpminor]
+Osubf [constructor, in backend.Op]
+Osubimm [constructor, in backend.Op]
+Oundef [constructor, in backend.Op]
+outcome [inductive, in backend.Cminor]
+outcome [inductive, in backend.LTL]
+outcome [inductive, in backend.PPC]
+outcome [inductive, in backend.Csharpminor]
+outcome_block [definition, in backend.Csharpminor]
+outcome_block [definition, in backend.Cminor]
+outcome_inject [inductive, in backend.Cminorgenproof]
+outcome_node [definition, in backend.RTLgenproof]
+outcome_result_value [definition, in backend.Cminor]
+outcome_result_value [definition, in backend.Csharpminor]
+Outgoing [constructor, in backend.Locations]
+outgoing_slot [definition, in backend.Lineartyping]
+outgoing_slot_bound [lemma, in backend.Linearizetyping]
+outgoing_space [definition, in backend.Lineartyping]
+Out_exit [constructor, in backend.Csharpminor]
+Out_exit [constructor, in backend.Cminor]
+Out_normal [constructor, in backend.Cminor]
+Out_normal [constructor, in backend.Csharpminor]
+Out_return [constructor, in backend.Cminor]
+Out_return [constructor, in backend.Csharpminor]
+overlap [definition, in backend.Locations]
+overlap_aux [definition, in backend.Locations]
+overlap_aux_false_1 [lemma, in backend.Locations]
+overlap_aux_true_1 [lemma, in backend.Locations]
+overlap_aux_true_2 [lemma, in backend.Locations]
+overlap_not_diff [lemma, in backend.Locations]
+Oxor [constructor, in backend.Op]
+Oxor [constructor, in backend.Csharpminor]
+Oxorimm [constructor, in backend.Op]
+

P

+Padd [constructor, in backend.PPC]
+Paddi [constructor, in backend.PPC]
+Paddis [constructor, in backend.PPC]
+Paddze [constructor, in backend.PPC]
+Pallocframe [constructor, in backend.PPC]
+Pandc [constructor, in backend.PPC]
+Pandis_ [constructor, in backend.PPC]
+Pandi_ [constructor, in backend.PPC]
+Pand_ [constructor, in backend.PPC]
+Parallelmove [library]
+parallel_move [definition, in backend.Allocation]
+parallel_move_correct [lemma, in backend.Allocproof]
+parallel_move_correctX [lemma, in backend.Allocproof_aux]
+parallel_move_correct' [lemma, in backend.Allocproof_aux]
+parallel_move_order [definition, in backend.Allocation]
+parameter_of_argument [definition, in backend.Conventions]
+path [definition, in backend.Parallelmove]
+path_pop [lemma, in backend.Parallelmove]
+path_tmpLast [lemma, in backend.Parallelmove]
+Pb [constructor, in backend.PPC]
+Pbctr [constructor, in backend.PPC]
+Pbctrl [constructor, in backend.PPC]
+Pbf [constructor, in backend.PPC]
+Pbl [constructor, in backend.PPC]
+Pblr [constructor, in backend.PPC]
+Pbt [constructor, in backend.PPC]
+PC [constructor, in backend.PPC]
+Pcmplw [constructor, in backend.PPC]
+Pcmplwi [constructor, in backend.PPC]
+Pcmpw [constructor, in backend.PPC]
+Pcmpwi [constructor, in backend.PPC]
+Pcror [constructor, in backend.PPC]
+Pdivw [constructor, in backend.PPC]
+Pdivwu [constructor, in backend.PPC]
+peq [definition, in lib.Coqlib]
+Peqv [constructor, in backend.PPC]
+peq_false [lemma, in lib.Coqlib]
+peq_true [lemma, in lib.Coqlib]
+pexec [definition, in backend.Parallelmove]
+pexec_add [lemma, in backend.Parallelmove]
+pexec_correct [lemma, in backend.Parallelmove]
+pexec_mov [lemma, in backend.Parallelmove]
+pexec_movBack [lemma, in backend.Parallelmove]
+pexec_movFront [lemma, in backend.Parallelmove]
+pexec_nop [lemma, in backend.Parallelmove]
+pexec_push [lemma, in backend.Parallelmove]
+pexec_swap [lemma, in backend.Parallelmove]
+pexec_update [lemma, in backend.Parallelmove]
+Pextsb [constructor, in backend.PPC]
+Pextsh [constructor, in backend.PPC]
+Pfabs [constructor, in backend.PPC]
+Pfadd [constructor, in backend.PPC]
+Pfcmpu [constructor, in backend.PPC]
+Pfcti [constructor, in backend.PPC]
+Pfdiv [constructor, in backend.PPC]
+Pfmadd [constructor, in backend.PPC]
+Pfmr [constructor, in backend.PPC]
+Pfmsub [constructor, in backend.PPC]
+Pfmul [constructor, in backend.PPC]
+Pfneg [constructor, in backend.PPC]
+Pfreeframe [constructor, in backend.PPC]
+Pfrsp [constructor, in backend.PPC]
+Pfsub [constructor, in backend.PPC]
+Pfundef [constructor, in backend.PPC]
+Pictf [constructor, in backend.PPC]
+Piuctf [constructor, in backend.PPC]
+Piundef [constructor, in backend.PPC]
+Plabel [constructor, in backend.PPC]
+Plbz [constructor, in backend.PPC]
+Plbzx [constructor, in backend.PPC]
+Ple [definition, in lib.Coqlib]
+Ple_refl [lemma, in lib.Coqlib]
+Ple_succ [lemma, in lib.Coqlib]
+Ple_trans [lemma, in lib.Coqlib]
+Plfd [constructor, in backend.PPC]
+Plfdx [constructor, in backend.PPC]
+Plfi [constructor, in backend.PPC]
+Plfs [constructor, in backend.PPC]
+Plfsx [constructor, in backend.PPC]
+Plha [constructor, in backend.PPC]
+Plhax [constructor, in backend.PPC]
+Plhz [constructor, in backend.PPC]
+Plhzx [constructor, in backend.PPC]
+Plt [definition, in lib.Coqlib]
+plt [definition, in lib.Coqlib]
+Plt_ne [lemma, in lib.Coqlib]
+Plt_Ple [lemma, in lib.Coqlib]
+Plt_Ple_trans [lemma, in lib.Coqlib]
+Plt_strict [lemma, in lib.Coqlib]
+Plt_succ [lemma, in lib.Coqlib]
+Plt_succ_inv [lemma, in lib.Coqlib]
+Plt_trans [lemma, in lib.Coqlib]
+Plt_trans_succ [lemma, in lib.Coqlib]
+Plt_wf [lemma, in lib.Coqlib]
+Plwz [constructor, in backend.PPC]
+Plwzx [constructor, in backend.PPC]
+PMap [module, in lib.Maps]
+Pmfcrbit [constructor, in backend.PPC]
+Pmflr [constructor, in backend.PPC]
+Pmov [definition, in backend.Parallelmove]
+Pmov_equation [lemma, in backend.Parallelmove]
+Pmr [constructor, in backend.PPC]
+Pmtctr [constructor, in backend.PPC]
+Pmtlr [constructor, in backend.PPC]
+Pmulli [constructor, in backend.PPC]
+Pmullw [constructor, in backend.PPC]
+Pnand [constructor, in backend.PPC]
+Pnor [constructor, in backend.PPC]
+Por [constructor, in backend.PPC]
+Porc [constructor, in backend.PPC]
+Pori [constructor, in backend.PPC]
+Poris [constructor, in backend.PPC]
+positive_Peano_ind [lemma, in lib.Coqlib]
+positive_rec [definition, in lib.Coqlib]
+positive_rec_base [lemma, in lib.Coqlib]
+positive_rec_succ [lemma, in lib.Coqlib]
+powerserie [definition, in lib.Integers]
+PPC [library]
+PPCgen [library]
+PPCgenproof [library]
+PPCgenproof1 [library]
+Ppred_Plt [lemma, in lib.Coqlib]
+predecessors [definition, in backend.Kildall]
+predecessors_correct [lemma, in backend.Kildall]
+preg [inductive, in backend.PPC]
+PregEq [module, in backend.PPC]
+Pregmap [module, in backend.PPC]
+preg_eq [lemma, in backend.PPC]
+preg_of [definition, in backend.PPCgenproof1]
+preg_of_injective [lemma, in backend.PPCgenproof1]
+preg_of_is_data_reg [lemma, in backend.PPCgenproof1]
+preg_of_not [lemma, in backend.PPCgenproof1]
+preg_of_not_GPR1 [lemma, in backend.PPCgenproof1]
+preg_val [lemma, in backend.PPCgenproof1]
+Prlwinm [constructor, in backend.PPC]
+program [definition, in backend.LTL]
+program [definition, in backend.Cminor]
+program [definition, in backend.Linear]
+program [inductive, in backend.AST]
+program [definition, in backend.RTL]
+program [definition, in backend.Csharpminor]
+program [definition, in backend.PPC]
+program [definition, in backend.Mach]
+program_typing_preserved [lemma, in backend.Tunnelingtyping]
+program_typing_preserved [lemma, in backend.Linearizetyping]
+program_typing_preserved [lemma, in backend.Alloctyping]
+program_typing_preserved [lemma, in backend.Stackingtyping]
+prog_funct_transf_OK [lemma, in backend.Globalenvs]
+proof_irrelevance [axiom, in lib.Coqlib]
+propagate_succ [definition, in backend.Kildall]
+propagate_successors [definition, in backend.Kildall]
+propagate_successors_charact1 [lemma, in backend.Kildall]
+propagate_successors_charact2 [lemma, in backend.Kildall]
+propagate_successors_invariant [lemma, in backend.Kildall]
+propagate_successors_P [lemma, in backend.Kildall]
+propagate_succ_charact [lemma, in backend.Kildall]
+propagate_succ_incr [lemma, in backend.Kildall]
+propagate_succ_incr_worklist [lemma, in backend.Kildall]
+propagate_succ_list [definition, in backend.Kildall]
+propagate_succ_list_charact [lemma, in backend.Kildall]
+propagate_succ_list_incr [lemma, in backend.Kildall]
+propagate_succ_list_incr_worklist [lemma, in backend.Kildall]
+propagate_succ_list_records_changes [lemma, in backend.Kildall]
+propagate_succ_records_changes [lemma, in backend.Kildall]
+Pslw [constructor, in backend.PPC]
+Psraw [constructor, in backend.PPC]
+Psrawi [constructor, in backend.PPC]
+Psrw [constructor, in backend.PPC]
+Pstate [definition, in backend.Kildall]
+Pstb [constructor, in backend.PPC]
+Pstbx [constructor, in backend.PPC]
+Pstfd [constructor, in backend.PPC]
+Pstfdx [constructor, in backend.PPC]
+Pstfs [constructor, in backend.PPC]
+Pstfsx [constructor, in backend.PPC]
+Psth [constructor, in backend.PPC]
+Psthx [constructor, in backend.PPC]
+Pstw [constructor, in backend.PPC]
+Pstwx [constructor, in backend.PPC]
+Psubfc [constructor, in backend.PPC]
+Psubfic [constructor, in backend.PPC]
+PTree [module, in lib.Maps]
+Pxor [constructor, in backend.PPC]
+Pxori [constructor, in backend.PPC]
+Pxoris [constructor, in backend.PPC]
+p_move [definition, in backend.Allocproof_aux]
+P_move [definition, in backend.Parallelmove]
+

R

+R [constructor, in backend.Locations]
+R [definition, in backend.Coloring]
+reachable [definition, in backend.Linearize]
+reachable_aux [definition, in backend.Linearize]
+reachable_correct_1 [lemma, in backend.Linearizeproof]
+reachable_correct_2 [lemma, in backend.Linearizeproof]
+reachable_entrypoint [lemma, in backend.Linearizeproof]
+reachable_successors [lemma, in backend.Linearizeproof]
+rebuild_l [lemma, in backend.Parallelmove]
+refl_ge [lemma, in backend.CSE]
+Reg [module, in backend.Registers]
+reg [definition, in backend.Registers]
+Reg [definition, in backend.Parallelmove]
+regalloc [definition, in backend.Coloring]
+regalloc_acceptable [lemma, in backend.Coloringproof]
+regalloc_correct_1 [lemma, in backend.Coloringproof]
+regalloc_correct_2 [lemma, in backend.Coloringproof]
+regalloc_correct_3 [lemma, in backend.Coloringproof]
+regalloc_disj_temporaries [lemma, in backend.Allocproof]
+regalloc_norepet_norepet [lemma, in backend.Allocproof]
+regalloc_noteq_diff [lemma, in backend.Allocproof]
+regalloc_notin_notin [lemma, in backend.Allocproof]
+regalloc_not_temporary [lemma, in backend.Allocproof]
+regalloc_ok [lemma, in backend.Coloringproof]
+regalloc_preserves_types [lemma, in backend.Coloringproof]
+regenv [definition, in backend.RTLtyping]
+RegEq [module, in backend.Mach]
+Registers [library]
+register_classification [lemma, in backend.Conventions]
+reglist [definition, in backend.LTL]
+Regmap [module, in backend.Mach]
+Regmap [module, in backend.Registers]
+regmap_optget [definition, in backend.Registers]
+regmap_optset [definition, in backend.Registers]
+regsalloc_acceptable [lemma, in backend.Coloringproof]
+regset [definition, in backend.Mach]
+regset [definition, in backend.RTL]
+regset [definition, in backend.PPC]
+Regset [module, in backend.Registers]
+regs_for [definition, in backend.Allocation]
+regs_for_rec [definition, in backend.Allocation]
+regs_match_approx [definition, in backend.Constpropproof]
+regs_match_approx_increasing [lemma, in backend.Constpropproof]
+regs_match_approx_update [lemma, in backend.Constpropproof]
+regs_of_instr [definition, in backend.Lineartyping]
+reg_for [definition, in backend.Allocation]
+reg_for_spec [lemma, in backend.Allocproof]
+reg_fresh [definition, in backend.RTLgenproof1]
+reg_fresh_decr [lemma, in backend.RTLgenproof1]
+reg_in_map [definition, in backend.RTLgenproof1]
+reg_in_map_valid [lemma, in backend.RTLgenproof1]
+reg_list_dead [definition, in backend.Allocation]
+reg_list_live [definition, in backend.Allocation]
+reg_of_crbit [definition, in backend.PPC]
+reg_option_live [definition, in backend.Allocation]
+reg_sum_live [definition, in backend.Allocation]
+reg_valid [definition, in backend.RTLgenproof1]
+reg_valid_incr [lemma, in backend.RTLgenproof1]
+reg_valnum [definition, in backend.CSE]
+reg_valnum_correct [lemma, in backend.CSEproof]
+remove [definition, in lib.Sets]
+remove [definition, in lib.Maps]
+remove_all_leaves [definition, in lib.Inclusion]
+remove_all_leaves_sound [lemma, in lib.Inclusion]
+repet [definition, in backend.RTLtyping]
+repet_correct [lemma, in backend.RTLtyping]
+replace_last_id [lemma, in backend.Parallelmove]
+replace_last_s [definition, in backend.Parallelmove]
+repr [definition, in lib.union_find]
+repr [definition, in lib.Integers]
+repr_aux [definition, in lib.union_find]
+repr_aux_canon [lemma, in lib.union_find]
+repr_aux_none [lemma, in lib.union_find]
+repr_aux_some [lemma, in lib.union_find]
+repr_empty [lemma, in lib.union_find]
+repr_order [definition, in lib.union_find]
+repr_rec [definition, in lib.union_find]
+repr_rec_ext [lemma, in lib.union_find]
+repr_repr [lemma, in lib.union_find]
+repr_signed [lemma, in lib.Integers]
+repr_unsigned [lemma, in lib.Integers]
+res [inductive, in backend.RTLgen]
+reserve_instr [definition, in backend.RTLgen]
+reserve_instr_incr [lemma, in backend.RTLgenproof1]
+reserve_instr_wf [lemma, in backend.RTLgen]
+restore_callee_save [definition, in backend.Stacking]
+restore_callee_save_correct [lemma, in backend.Stackingproof]
+restore_float_callee_save [definition, in backend.Stacking]
+restore_float_callee_save_correct [lemma, in backend.Stackingproof]
+restore_float_callee_save_correct_rec [lemma, in backend.Stackingproof]
+restore_int_callee_save [definition, in backend.Stacking]
+restore_int_callee_save_correct [lemma, in backend.Stackingproof]
+restore_int_callee_save_correct_rec [lemma, in backend.Stackingproof]
+result [definition, in backend.Kildall]
+reswellFormed [definition, in backend.Allocproof_aux]
+ret [definition, in backend.RTLgen]
+Return [constructor, in backend.LTL]
+return_regs [definition, in backend.LTL]
+return_regs_not_destroyed [lemma, in backend.Allocproof]
+return_regs_result [lemma, in backend.Allocproof]
+return_reg_ok [inductive, in backend.RTLgenproof1]
+return_reg_ok_incr [lemma, in backend.RTLgenproof1]
+return_reg_ok_none [constructor, in backend.RTLgenproof1]
+return_reg_ok_some [constructor, in backend.RTLgenproof1]
+ret_reg [definition, in backend.RTLgen]
+rhs [inductive, in backend.CSE]
+rhs_evals_to [definition, in backend.CSEproof]
+right [definition, in backend.Parallelmove]
+rleaf [lemma, in lib.Maps]
+rlw_accepting [definition, in lib.Integers]
+RLW_Sbad [constructor, in lib.Integers]
+rlw_state [inductive, in lib.Integers]
+RLW_S0 [constructor, in lib.Integers]
+RLW_S1 [constructor, in lib.Integers]
+RLW_S2 [constructor, in lib.Integers]
+RLW_S3 [constructor, in lib.Integers]
+RLW_S4 [constructor, in lib.Integers]
+RLW_S5 [constructor, in lib.Integers]
+RLW_S6 [constructor, in lib.Integers]
+rlw_transition [definition, in lib.Integers]
+rol [definition, in lib.Integers]
+rolm [definition, in backend.Values]
+rolm [definition, in backend.Cmconstr]
+rolm [definition, in lib.Integers]
+rolm_cases [inductive, in backend.Cmconstr]
+rolm_case1 [constructor, in backend.Cmconstr]
+rolm_case2 [constructor, in backend.Cmconstr]
+rolm_default [constructor, in backend.Cmconstr]
+rolm_match [definition, in backend.Cmconstr]
+rolm_rolm [lemma, in lib.Integers]
+rolm_rolm [lemma, in backend.Values]
+rolm_zero [lemma, in lib.Integers]
+rolm_zero [lemma, in backend.Values]
+rol_and [lemma, in lib.Integers]
+rol_or [lemma, in lib.Integers]
+rol_rol [lemma, in lib.Integers]
+rol_zero [lemma, in lib.Integers]
+RTL [library]
+RTLgen [library]
+RTLgenproof [library]
+RTLgenproof1 [library]
+RTLtyping [library]
+R10 [constructor, in backend.Locations]
+R13 [constructor, in backend.Locations]
+R14 [constructor, in backend.Locations]
+R15 [constructor, in backend.Locations]
+R16 [constructor, in backend.Locations]
+R17 [constructor, in backend.Locations]
+R18 [constructor, in backend.Locations]
+R19 [constructor, in backend.Locations]
+r2 [constructor, in backend.Op]
+r2 [constructor, in backend.Op]
+R20 [constructor, in backend.Locations]
+R21 [constructor, in backend.Locations]
+R22 [constructor, in backend.Locations]
+R23 [constructor, in backend.Locations]
+R24 [constructor, in backend.Locations]
+R25 [constructor, in backend.Locations]
+R26 [constructor, in backend.Locations]
+R27 [constructor, in backend.Locations]
+R28 [constructor, in backend.Locations]
+R29 [constructor, in backend.Locations]
+R3 [constructor, in backend.Locations]
+R30 [constructor, in backend.Locations]
+R31 [constructor, in backend.Locations]
+R4 [constructor, in backend.Locations]
+R5 [constructor, in backend.Locations]
+R6 [constructor, in backend.Locations]
+R7 [constructor, in backend.Locations]
+R8 [constructor, in backend.Locations]
+R9 [constructor, in backend.Locations]
+

S

+S [constructor, in backend.Locations]
+sameclass [definition, in lib.union_find]
+sameclass [definition, in lib.union_find]
+sameclass_empty [lemma, in lib.union_find]
+sameclass_identify_1 [lemma, in lib.union_find]
+sameclass_identify_2 [lemma, in lib.union_find]
+sameclass_refl [lemma, in lib.union_find]
+sameclass_repr [lemma, in lib.union_find]
+sameclass_sym [lemma, in lib.union_find]
+sameclass_trans [lemma, in lib.union_find]
+sameEnv [definition, in backend.Parallelmove]
+sameExec [definition, in backend.Parallelmove]
+sameExec_reflexive [lemma, in backend.Parallelmove]
+sameExec_transitive [lemma, in backend.Parallelmove]
+same_expr_pure [definition, in backend.Cmconstr]
+same_not_diff [lemma, in backend.Locations]
+same_typ [definition, in backend.Coloring]
+same_typ_correct [lemma, in backend.Coloringproof]
+save_callee_save [definition, in backend.Stacking]
+save_callee_save_correct [lemma, in backend.Stackingproof]
+save_float_callee_save [definition, in backend.Stacking]
+save_float_callee_save_correct [lemma, in backend.Stackingproof]
+save_float_callee_save_correct_rec [lemma, in backend.Stackingproof]
+save_int_callee_save [definition, in backend.Stacking]
+save_int_callee_save_correct [lemma, in backend.Stackingproof]
+save_int_callee_save_correct_rec [lemma, in backend.Stackingproof]
+Sblock [constructor, in backend.Cminor]
+Sblock [constructor, in backend.Csharpminor]
+SB_Pmov [lemma, in backend.Parallelmove]
+Scons [constructor, in backend.Cminor]
+Scons [constructor, in backend.Csharpminor]
+SDone_Pmov [lemma, in backend.Allocproof_aux]
+SDone_stepf [lemma, in backend.Allocproof_aux]
+sD_nW [lemma, in backend.Parallelmove]
+sD_pexec [lemma, in backend.Parallelmove]
+SEMILATTICE [module, in lib.Lattice]
+SEMILATTICE_WITH_TOP [module, in lib.Lattice]
+set [definition, in lib.Maps]
+set [definition, in backend.Locations]
+set [definition, in lib.Maps]
+set [definition, in lib.Maps]
+set [definition, in lib.Lattice]
+set [definition, in lib.Maps]
+SetDepRegMreg [module, in backend.InterfGraph]
+SetDepRegReg [module, in backend.InterfGraph]
+setN [definition, in backend.Mem]
+setN_agree [lemma, in backend.Mem]
+setN_inject [lemma, in backend.Mem]
+setN_outside_agree [lemma, in backend.Mem]
+setN_outside_inject [lemma, in backend.Mem]
+SetRegMreg [module, in backend.InterfGraph]
+SetRegReg [module, in backend.InterfGraph]
+Sets [library]
+set_cont [definition, in backend.Mem]
+set_cont_agree [lemma, in backend.Mem]
+set_cont_inject [lemma, in backend.Mem]
+set_cont_inside [lemma, in backend.Mem]
+set_cont_outside [lemma, in backend.Mem]
+set_cont_outside1 [lemma, in backend.Mem]
+set_cont_outside_agree [lemma, in backend.Mem]
+set_cont_outside_inject [lemma, in backend.Mem]
+set_locals [definition, in backend.Cminor]
+set_locals_defined [lemma, in backend.Cminorgenproof]
+set_locals_params_defined [lemma, in backend.Cminorgenproof]
+set_params [definition, in backend.Cminor]
+set_params_defined [lemma, in backend.Cminorgenproof]
+set_slot [inductive, in backend.Machabstr]
+set_slot_index [lemma, in backend.Stackingproof]
+set_slot_intro [constructor, in backend.Machabstr]
+set_slot_link_invariant [lemma, in backend.Machtyping]
+set_slot_ok [lemma, in backend.Stackingproof]
+Sexec [definition, in backend.Parallelmove]
+sexec [definition, in backend.Parallelmove]
+Sexit [constructor, in backend.Cminor]
+Sexit [constructor, in backend.Csharpminor]
+Sexpr [constructor, in backend.Cminor]
+Sexpr [constructor, in backend.Csharpminor]
+shift_cases [inductive, in backend.Cmconstr]
+shift_case1 [constructor, in backend.Cmconstr]
+shift_default [constructor, in backend.Cmconstr]
+shift_eval_addressing [lemma, in backend.Stackingproof]
+shift_eval_operation [lemma, in backend.Stackingproof]
+shift_match [definition, in backend.Cmconstr]
+shift_sp [definition, in backend.Stackingproof]
+shl [definition, in lib.Integers]
+shl [definition, in backend.Cmconstr]
+shl [definition, in backend.Values]
+shlimm [definition, in backend.Cmconstr]
+shl_mul [lemma, in backend.Values]
+shl_mul [lemma, in lib.Integers]
+shl_mul_two_p [lemma, in lib.Integers]
+shl_rolm [lemma, in lib.Integers]
+shl_rolm [lemma, in backend.Values]
+shl_zero [lemma, in lib.Integers]
+shr [definition, in lib.Integers]
+shr [definition, in backend.Cmconstr]
+shr [definition, in backend.Values]
+shru [definition, in backend.Cmconstr]
+shru [definition, in lib.Integers]
+shru [definition, in backend.Values]
+shruimm [definition, in backend.Cmconstr]
+shru_div_two_p [lemma, in lib.Integers]
+shru_rolm [lemma, in backend.Values]
+shru_rolm [lemma, in lib.Integers]
+shru_zero [lemma, in lib.Integers]
+shrx [definition, in lib.Integers]
+shrx [definition, in backend.Values]
+shrx_carry [lemma, in backend.Values]
+shrx_carry [lemma, in lib.Integers]
+shr_carry [definition, in backend.Values]
+shr_carry [definition, in lib.Integers]
+shr_zero [lemma, in lib.Integers]
+Sifthenelse [constructor, in backend.Csharpminor]
+Sifthenelse [constructor, in backend.Cminor]
+signature [inductive, in backend.AST]
+signed [definition, in lib.Integers]
+signed_range [lemma, in lib.Integers]
+signed_repr [lemma, in lib.Integers]
+sig_function_translated [lemma, in backend.Allocproof]
+sig_transl_function [lemma, in backend.Cminorgenproof]
+simpleDest [definition, in backend.Parallelmove]
+simpleDest_insert [lemma, in backend.Parallelmove]
+simpleDest_movBack [lemma, in backend.Parallelmove]
+simpleDest_movFront [lemma, in backend.Parallelmove]
+simpleDest_Pop [lemma, in backend.Parallelmove]
+simpleDest_pop [lemma, in backend.Parallelmove]
+simpleDest_pop2 [lemma, in backend.Parallelmove]
+simpleDest_right [lemma, in backend.Parallelmove]
+simpleDest_swap [lemma, in backend.Parallelmove]
+simpleDest_swap_app [lemma, in backend.Parallelmove]
+simpleDest_tmpLast [lemma, in backend.Parallelmove]
+singleoffloat [definition, in backend.Values]
+singleoffloat [definition, in backend.Cmconstr]
+singleoffloat [axiom, in lib.Floats]
+singleoffloat_idem [axiom, in lib.Floats]
+sizeof [definition, in backend.Csharpminor]
+Size16 [constructor, in backend.Mem]
+Size32 [constructor, in backend.Mem]
+Size64 [constructor, in backend.Mem]
+Size8 [constructor, in backend.Mem]
+size_arguments [definition, in backend.Conventions]
+size_arguments_bound [lemma, in backend.Linearizetyping]
+size_arguments_rec [definition, in backend.Conventions]
+size_chunk [definition, in backend.Mem]
+size_chunk_pos [lemma, in backend.Mem]
+size_mem [definition, in backend.Mem]
+size_mem_pos [lemma, in backend.Mem]
+size_no_overflow [lemma, in backend.Stackingproof]
+size_pos [lemma, in backend.Stackingproof]
+Sloop [constructor, in backend.Csharpminor]
+Sloop [constructor, in backend.Cminor]
+slot [inductive, in backend.Locations]
+slots_of_instr [definition, in backend.Lineartyping]
+slot_bounded [definition, in backend.Lineartyping]
+slot_bounded [definition, in backend.LTLtyping]
+slot_eq [lemma, in backend.Locations]
+slot_gi [lemma, in backend.Stackingproof]
+slot_gso [lemma, in backend.Stackingproof]
+slot_gss [lemma, in backend.Stackingproof]
+slot_iso [lemma, in backend.Stackingproof]
+slot_iss [lemma, in backend.Stackingproof]
+slot_is_bounded [lemma, in backend.Linearizetyping]
+slot_type [definition, in backend.Locations]
+Snil [constructor, in backend.Csharpminor]
+Snil [constructor, in backend.Cminor]
+Solver [module, in backend.CSE]
+Some [definition, in backend.Parallelmove]
+sort_bin [definition, in lib.Inclusion]
+sort_included [lemma, in lib.Inclusion]
+sort_included2 [lemma, in lib.Inclusion]
+splitNone [lemma, in backend.Parallelmove]
+splitSome [lemma, in backend.Parallelmove]
+split_length [lemma, in backend.Parallelmove]
+split_move [definition, in backend.Parallelmove]
+split_move' [definition, in backend.Parallelmove]
+split_move_incl [lemma, in backend.Alloctyping_aux]
+sp_val [lemma, in backend.PPCgenproof1]
+srcdst_tmp2_stepf [lemma, in backend.Alloctyping_aux]
+src_tmp2_res [lemma, in backend.Alloctyping_aux]
+Sreturn [constructor, in backend.Csharpminor]
+Sreturn [constructor, in backend.Cminor]
+Stacking [library]
+Stackingproof [library]
+Stackingtyping [library]
+starts_with [definition, in backend.Linearize]
+starts_with_correct [lemma, in backend.Linearizeproof]
+start_state [definition, in backend.Kildall]
+start_state_good [lemma, in backend.Kildall]
+start_state_in [definition, in backend.Kildall]
+start_state_in_entry [lemma, in backend.Kildall]
+start_state_wrk [definition, in backend.Kildall]
+state [inductive, in backend.Kildall]
+State [definition, in backend.Parallelmove]
+state [inductive, in backend.RTLgen]
+state [inductive, in backend.Kildall]
+StateBeing [definition, in backend.Parallelmove]
+StateDone [definition, in backend.Parallelmove]
+StateToMove [definition, in backend.Parallelmove]
+state_extends [definition, in backend.RTLgenproof1]
+state_incr [inductive, in backend.RTLgenproof1]
+state_incr_extends [lemma, in backend.RTLgenproof1]
+state_incr_intro [constructor, in backend.RTLgenproof1]
+state_incr_refl [lemma, in backend.RTLgenproof1]
+state_incr_trans [lemma, in backend.RTLgenproof1]
+state_incr_trans2 [lemma, in backend.RTLgenproof1]
+state_incr_trans3 [lemma, in backend.RTLgenproof1]
+state_incr_trans4 [lemma, in backend.RTLgenproof1]
+state_incr_trans5 [lemma, in backend.RTLgenproof1]
+state_incr_trans6 [lemma, in backend.RTLgenproof1]
+state_invariant [definition, in backend.Kildall]
+step [definition, in backend.Kildall]
+step [inductive, in backend.Parallelmove]
+step [definition, in backend.Kildall]
+stepf [definition, in backend.Parallelmove]
+stepf' [definition, in backend.Parallelmove]
+stepf1_dec [lemma, in backend.Parallelmove]
+stepf_dec [lemma, in backend.Parallelmove]
+stepf_dec0 [lemma, in backend.Parallelmove]
+stepf_dec0' [lemma, in backend.Parallelmove]
+stepf_pop [lemma, in backend.Parallelmove]
+stepf_popLoop [lemma, in backend.Parallelmove]
+stepInv [definition, in backend.Parallelmove]
+stepInv_pnilnil [lemma, in backend.Allocproof_aux]
+stepp [inductive, in backend.Parallelmove]
+stepp_inv [lemma, in backend.Parallelmove]
+stepp_refl [constructor, in backend.Parallelmove]
+stepp_sameExec [lemma, in backend.Parallelmove]
+stepp_trans [constructor, in backend.Parallelmove]
+stepp_transitive [lemma, in backend.Parallelmove]
+step1 [lemma, in backend.RTLtyping]
+step2 [lemma, in backend.RTLtyping]
+step3 [lemma, in backend.RTLtyping]
+step4 [lemma, in backend.RTLtyping]
+step_dec [lemma, in backend.Parallelmove]
+step_dec0 [lemma, in backend.Parallelmove]
+step_inv [lemma, in backend.Parallelmove]
+step_inv_getdst [lemma, in backend.Parallelmove]
+step_inv_loop [lemma, in backend.Parallelmove]
+step_inv_loop_aux [lemma, in backend.Parallelmove]
+step_inv_noOverlap [lemma, in backend.Parallelmove]
+step_inv_NoOverlap [lemma, in backend.Parallelmove]
+step_inv_noTmp [lemma, in backend.Parallelmove]
+step_inv_noTmpLast [lemma, in backend.Parallelmove]
+step_inv_path [lemma, in backend.Parallelmove]
+step_inv_simpleDest [lemma, in backend.Parallelmove]
+step_loop [constructor, in backend.Parallelmove]
+step_NF [definition, in backend.Parallelmove]
+step_nop [constructor, in backend.Parallelmove]
+step_pop [constructor, in backend.Parallelmove]
+step_push [constructor, in backend.Parallelmove]
+step_sameExec [lemma, in backend.Parallelmove]
+step_start [constructor, in backend.Parallelmove]
+step_state_good [lemma, in backend.Kildall]
+step_stepp [lemma, in backend.Parallelmove]
+stmt [inductive, in backend.Csharpminor]
+stmt [inductive, in backend.Cminor]
+stmtlist [inductive, in backend.Csharpminor]
+stmtlist [inductive, in backend.Cminor]
+stmt_stmtlist_ind [lemma, in backend.RTLgenproof1]
+STM_Pmov [lemma, in backend.Parallelmove]
+store [definition, in backend.Cmconstr]
+store [definition, in backend.Mem]
+storeind [definition, in backend.PPCgen]
+storeind_aux [definition, in backend.PPCgen]
+storeind_aux_correct [lemma, in backend.PPCgenproof1]
+storeind_correct [lemma, in backend.PPCgenproof1]
+storev [definition, in backend.Mem]
+storev_mapped_inject [lemma, in backend.Mem]
+storev_mapped_inject_1 [lemma, in backend.Mem]
+storev_16_signed_unsigned [lemma, in backend.PPCgenproof]
+storev_8_signed_unsigned [lemma, in backend.PPCgenproof]
+store1 [definition, in backend.PPC]
+store2 [definition, in backend.PPC]
+store_agree [lemma, in backend.Mem]
+store_alloc [lemma, in backend.Mem]
+store_contentmap_agree [lemma, in backend.Mem]
+store_contentmap_outside_agree [lemma, in backend.Mem]
+store_contents [definition, in backend.Mem]
+store_contents_inject [lemma, in backend.Mem]
+store_contents_outside_inject [lemma, in backend.Mem]
+store_inv [lemma, in backend.Mem]
+store_in_bounds [lemma, in backend.Mem]
+store_is_in_bounds [lemma, in backend.Mem]
+store_mapped_inject [lemma, in backend.Mem]
+store_mapped_inject_1 [lemma, in backend.Mem]
+store_outside_agree [lemma, in backend.Mem]
+store_outside_extends [lemma, in backend.Mem]
+store_parameters [definition, in backend.Cminorgen]
+store_parameters_correct [lemma, in backend.Cminorgenproof]
+store_stack [definition, in backend.Mach]
+store_unmapped_inject [lemma, in backend.Mem]
+store_within_extends [lemma, in backend.Mem]
+sub [axiom, in lib.Floats]
+sub [definition, in backend.Values]
+sub [definition, in lib.Integers]
+sub [definition, in backend.Cmconstr]
+subf [definition, in backend.Values]
+subf [definition, in backend.Cmconstr]
+subf_addf_opp [axiom, in lib.Floats]
+subf_cases [inductive, in backend.Cmconstr]
+subf_case1 [constructor, in backend.Cmconstr]
+subf_default [constructor, in backend.Cmconstr]
+subf_match [definition, in backend.Cmconstr]
+subject_reduction [lemma, in backend.Machtyping]
+subject_reduction [lemma, in backend.RTLtyping]
+subject_reduction_function [lemma, in backend.Machtyping]
+subject_reduction_instr [lemma, in backend.Machtyping]
+subject_reduction_instrs [lemma, in backend.Machtyping]
+sub_add_l [lemma, in backend.Values]
+sub_add_l [lemma, in lib.Integers]
+sub_add_opp [lemma, in lib.Integers]
+sub_add_opp [lemma, in backend.Values]
+sub_add_r [lemma, in backend.Values]
+sub_add_r [lemma, in lib.Integers]
+sub_cases [inductive, in backend.Cmconstr]
+sub_case1 [constructor, in backend.Cmconstr]
+sub_case2 [constructor, in backend.Cmconstr]
+sub_case3 [constructor, in backend.Cmconstr]
+sub_case4 [constructor, in backend.Cmconstr]
+sub_default [constructor, in backend.Cmconstr]
+sub_idem [lemma, in lib.Integers]
+sub_match [definition, in backend.Cmconstr]
+sub_match_aux [definition, in backend.Cmconstr]
+sub_shifted [lemma, in lib.Integers]
+sub_zero_l [lemma, in lib.Integers]
+sub_zero_r [lemma, in backend.Values]
+sub_zero_r [lemma, in lib.Integers]
+successors [definition, in backend.LTL]
+successors [definition, in backend.RTL]
+successors_aux [definition, in backend.LTL]
+successors_aux_invariant [lemma, in backend.LTL]
+successors_correct [lemma, in backend.LTL]
+successors_correct [lemma, in backend.RTL]
+sum_left_map [definition, in lib.Coqlib]
+swap_cmp [lemma, in lib.Integers]
+swap_cmp [lemma, in backend.Values]
+swap_cmpu [lemma, in backend.Values]
+swap_cmpu [lemma, in lib.Integers]
+swap_cmp_mismatch [lemma, in backend.Values]
+swap_comparison [definition, in backend.AST]
+symbols_add_globals_transf [lemma, in backend.Globalenvs]
+symbols_init_transf [lemma, in backend.Globalenvs]
+symbols_preserved [lemma, in backend.Tunnelingproof]
+symbols_preserved [lemma, in backend.Allocproof]
+symbols_preserved [lemma, in backend.Cminorgenproof]
+symbols_preserved [lemma, in backend.Constpropproof]
+symbols_preserved [lemma, in backend.PPCgenproof]
+symbols_preserved [lemma, in backend.RTLgenproof]
+symbols_preserved [lemma, in backend.Linearizeproof]
+symbols_preserved [lemma, in backend.CSEproof]
+symbols_preserved [lemma, in backend.Stackingproof]
+symbol_offset [definition, in backend.PPC]
+s1 [definition, in backend.Linearize]
+

T

+t [definition, in backend.PPC]
+t [definition, in lib.Ordered]
+t [definition, in lib.Maps]
+t [definition, in lib.Maps]
+t [definition, in lib.Lattice]
+t [definition, in backend.Locations]
+t [definition, in backend.Constprop]
+t [definition, in lib.Ordered]
+t [definition, in backend.Globalenvs]
+t [definition, in lib.Lattice]
+T [definition, in backend.RTLtyping]
+T [definition, in lib.union_find]
+t [definition, in backend.CSEproof]
+t [definition, in backend.Locations]
+t [definition, in lib.Maps]
+T [definition, in backend.Parallelmove]
+t [definition, in lib.Maps]
+T [definition, in backend.RTLtyping]
+t [definition, in backend.InterfGraph]
+t [definition, in lib.Maps]
+t [definition, in lib.Ordered]
+t [definition, in lib.Lattice]
+t [definition, in backend.Mach]
+t [definition, in lib.Sets]
+t [definition, in lib.Maps]
+t [definition, in backend.CSE]
+target_regs_cons [constructor, in backend.RTLgenproof1]
+target_regs_nil [constructor, in backend.RTLgenproof1]
+target_regs_not_mutated [lemma, in backend.RTLgenproof1]
+target_regs_ok [inductive, in backend.RTLgenproof1]
+target_regs_ok_incr [lemma, in backend.RTLgenproof1]
+target_regs_valid [lemma, in backend.RTLgenproof1]
+target_reg_immut_var [constructor, in backend.RTLgenproof1]
+target_reg_not_mutated [lemma, in backend.RTLgenproof1]
+target_reg_ok [inductive, in backend.RTLgenproof1]
+target_reg_ok_incr [lemma, in backend.RTLgenproof1]
+target_reg_valid [lemma, in backend.RTLgenproof1]
+temporaries [definition, in backend.Conventions]
+temporaries1 [definition, in backend.Allocproof_aux]
+temporaries1_3 [definition, in backend.Allocproof_aux]
+temporaries2 [definition, in backend.Allocproof_aux]
+temporaries_not_acceptable [lemma, in backend.Conventions]
+teq [definition, in backend.RTLtyping]
+teq_correct [lemma, in backend.RTLtyping]
+test_inclusion [definition, in lib.Inclusion]
+test_inclusion_sound [lemma, in lib.Inclusion]
+Tfloat [constructor, in backend.AST]
+Tint [definition, in backend.Allocation]
+Tint [constructor, in backend.AST]
+top [definition, in lib.Lattice]
+top [definition, in lib.Lattice]
+top [definition, in backend.CSE]
+top [definition, in backend.Constprop]
+top [definition, in lib.Lattice]
+top_ge [lemma, in backend.CSE]
+transfer [definition, in backend.Allocation]
+transfer [definition, in backend.Constprop]
+transfer [definition, in backend.CSE]
+transfer_correct [lemma, in backend.Constpropproof]
+transfer_correct [lemma, in backend.CSEproof]
+transform_partial_program [definition, in backend.AST]
+transform_partial_program_compose [lemma, in backend.Main]
+transform_partial_program_function [lemma, in backend.AST]
+transform_partial_program_main [lemma, in backend.AST]
+transform_program [definition, in backend.AST]
+transform_program_function [lemma, in backend.AST]
+transform_program_partial_total [lemma, in backend.Main]
+transform_program_transform_partial_program [lemma, in backend.Globalenvs]
+transf_cminor_function [definition, in backend.Main]
+transf_cminor_program [definition, in backend.Main]
+transf_cminor_program2 [definition, in backend.Main]
+transf_cminor_program2_correct [lemma, in backend.Main]
+transf_cminor_program_correct [lemma, in backend.Main]
+transf_cminor_program_equiv [lemma, in backend.Main]
+transf_code [definition, in backend.Constprop]
+transf_code [definition, in backend.CSE]
+transf_code_wf [lemma, in backend.CSE]
+transf_code_wf [lemma, in backend.Constprop]
+transf_code_wf [lemma, in backend.RTL]
+transf_csharpminor_function [definition, in backend.Main]
+transf_csharpminor_program [definition, in backend.Main]
+transf_csharpminor_program2 [definition, in backend.Main]
+transf_csharpminor_program2_correct [lemma, in backend.Main]
+transf_csharpminor_program_correct [lemma, in backend.Main]
+transf_csharpminor_program_equiv [lemma, in backend.Main]
+transf_entrypoint [definition, in backend.Allocation]
+transf_entrypoint_correct [lemma, in backend.Allocproof]
+transf_entrypoint_wf [lemma, in backend.Allocation]
+transf_function [definition, in backend.Linearize]
+transf_function [definition, in backend.Allocation]
+transf_function [definition, in backend.CSE]
+transf_function [definition, in backend.RTL]
+transf_function [definition, in backend.PPCgen]
+transf_function [definition, in backend.Stacking]
+transf_function [definition, in backend.Constprop]
+transf_function_correct [lemma, in backend.Linearizeproof]
+transf_function_correct [lemma, in backend.PPCgenproof]
+transf_function_correct [lemma, in backend.Stackingproof]
+transf_function_correct [lemma, in backend.CSEproof]
+transf_funct_correct [lemma, in backend.Constpropproof]
+transf_instr [definition, in backend.Allocation]
+transf_instr [definition, in backend.Constprop]
+transf_instr [definition, in backend.CSE]
+transf_partial [definition, in backend.Globalenvs]
+transf_partial_program [definition, in backend.AST]
+transf_partial_program_compose [lemma, in backend.Main]
+transf_program [definition, in backend.CSE]
+transf_program [definition, in backend.PPCgen]
+transf_program [definition, in backend.Stacking]
+transf_program [definition, in backend.Constprop]
+transf_program [definition, in backend.Allocation]
+transf_program [definition, in backend.Linearize]
+transf_program [definition, in backend.AST]
+transf_program_correct [lemma, in backend.Linearizeproof]
+transf_program_correct [lemma, in backend.Tunnelingproof]
+transf_program_correct [lemma, in backend.Constpropproof]
+transf_program_correct [lemma, in backend.PPCgenproof]
+transf_program_correct [lemma, in backend.CSEproof]
+transf_program_partial_total [lemma, in backend.Main]
+transf_program_transf_partial_program [lemma, in backend.Globalenvs]
+translate_cmp [lemma, in lib.Integers]
+translate_eq [lemma, in lib.Integers]
+translate_lt [lemma, in lib.Integers]
+transl_addr [definition, in backend.Stacking]
+transl_body [definition, in backend.Stacking]
+transl_code [definition, in backend.PPCgen]
+transl_code [definition, in backend.Stacking]
+transl_code_at_pc [inductive, in backend.PPCgenproof]
+transl_code_label [lemma, in backend.PPCgenproof]
+transl_cond [definition, in backend.PPCgen]
+transl_condition_CEcondition_correct [lemma, in backend.RTLgenproof]
+transl_condition_CEcond_correct [lemma, in backend.RTLgenproof]
+transl_condition_CEfalse_correct [lemma, in backend.RTLgenproof]
+transl_condition_CEtrue_correct [lemma, in backend.RTLgenproof]
+transl_condition_correct [definition, in backend.RTLgenproof]
+transl_condition_incr [lemma, in backend.RTLgenproof1]
+transl_condition_incr_pred [definition, in backend.RTLgenproof1]
+transl_cond_correct [lemma, in backend.PPCgenproof1]
+transl_cond_correct_aux [lemma, in backend.PPCgenproof1]
+transl_expr [definition, in backend.RTLgen]
+transl_expr [definition, in backend.Cminorgen]
+transl_exprlist_correct [definition, in backend.RTLgenproof]
+transl_exprlist_Econs_correct [lemma, in backend.Cminorgenproof]
+transl_exprlist_Econs_correct [lemma, in backend.RTLgenproof]
+transl_exprlist_Enil_correct [lemma, in backend.RTLgenproof]
+transl_exprlist_Enil_correct [lemma, in backend.Cminorgenproof]
+transl_exprlist_incr [lemma, in backend.RTLgenproof1]
+transl_exprlist_incr_pred [definition, in backend.RTLgenproof1]
+transl_expr_condition_exprlist_incr [lemma, in backend.RTLgenproof1]
+transl_expr_correct [definition, in backend.RTLgenproof]
+transl_expr_Eaddrof_global_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Eaddrof_local_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Eassign_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Eassign_correct [lemma, in backend.RTLgenproof]
+transl_expr_Ecall_correct [lemma, in backend.RTLgenproof]
+transl_expr_Ecall_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Econdition_correct [lemma, in backend.RTLgenproof]
+transl_expr_Econdition_false_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Econdition_true_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Eletvar_correct [lemma, in backend.RTLgenproof]
+transl_expr_Eletvar_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Elet_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Elet_correct [lemma, in backend.RTLgenproof]
+transl_expr_Eload_correct [lemma, in backend.RTLgenproof]
+transl_expr_Eload_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Eop_correct [lemma, in backend.RTLgenproof]
+transl_expr_Eop_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Estore_correct [lemma, in backend.RTLgenproof]
+transl_expr_Estore_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Evar_correct [lemma, in backend.Cminorgenproof]
+transl_expr_Evar_correct [lemma, in backend.RTLgenproof]
+transl_expr_incr [lemma, in backend.RTLgenproof1]
+transl_expr_incr_pred [definition, in backend.RTLgenproof1]
+transl_find_label [lemma, in backend.PPCgenproof]
+transl_find_label [lemma, in backend.Stackingproof]
+transl_fun [definition, in backend.RTLgen]
+transl_funcall_correct [lemma, in backend.Cminorgenproof]
+transl_funcall_correct [lemma, in backend.RTLgenproof]
+transl_function [definition, in backend.Cminorgen]
+transl_function [definition, in backend.PPCgen]
+transl_function [definition, in backend.RTLgen]
+transl_function_correct [definition, in backend.RTLgenproof]
+transl_function_correct [lemma, in backend.Allocproof]
+transl_function_correct [lemma, in backend.Cminorgenproof]
+transl_function_correctness [lemma, in backend.Allocproof]
+transl_function_correctness [lemma, in backend.RTLgenproof]
+transl_Icall_correct [lemma, in backend.Allocproof]
+transl_Icond_false_correct [lemma, in backend.Allocproof]
+transl_Icond_true_correct [lemma, in backend.Allocproof]
+transl_Iload_correct [lemma, in backend.Allocproof]
+transl_Inop_correct [lemma, in backend.Allocproof]
+transl_instr [definition, in backend.PPCgen]
+transl_instr [definition, in backend.Stacking]
+transl_instr_label [lemma, in backend.PPCgenproof]
+transl_Iop_correct [lemma, in backend.Allocproof]
+transl_Istore_correct [lemma, in backend.Allocproof]
+transl_load_correct [lemma, in backend.PPCgenproof1]
+transl_load_store [definition, in backend.PPCgen]
+transl_load_store_correct [lemma, in backend.PPCgenproof1]
+transl_one_correct [lemma, in backend.Allocproof]
+transl_op [definition, in backend.Stacking]
+transl_op [definition, in backend.PPCgen]
+transl_op_correct [lemma, in backend.PPCgenproof1]
+transl_program [definition, in backend.RTLgen]
+transl_program [definition, in backend.Cminorgen]
+transl_program_correct [lemma, in backend.RTLgenproof]
+transl_program_correct [lemma, in backend.Stackingproof]
+transl_program_correct [lemma, in backend.Allocproof]
+transl_program_correct [lemma, in backend.Cminorgenproof]
+transl_refl_correct [lemma, in backend.Allocproof]
+transl_stmt [definition, in backend.Cminorgen]
+transl_stmt [definition, in backend.RTLgen]
+transl_stmtlist_correct [definition, in backend.RTLgenproof]
+transl_stmtlist_incr [lemma, in backend.RTLgenproof1]
+transl_stmtlist_incr_pred [definition, in backend.RTLgenproof1]
+transl_stmtlist_Scons_continue_correct [lemma, in backend.RTLgenproof]
+transl_stmtlist_Scons_stop_correct [lemma, in backend.RTLgenproof]
+transl_stmtlist_Scons_1_correct [lemma, in backend.Cminorgenproof]
+transl_stmtlist_Scons_2_correct [lemma, in backend.Cminorgenproof]
+transl_stmtlist_Snil_correct [lemma, in backend.RTLgenproof]
+transl_stmtlist_Snil_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_correct [definition, in backend.RTLgenproof]
+transl_stmt_incr [lemma, in backend.RTLgenproof1]
+transl_stmt_incr_pred [definition, in backend.RTLgenproof1]
+transl_stmt_Sblock_correct [lemma, in backend.RTLgenproof]
+transl_stmt_Sblock_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_Sexit_correct [lemma, in backend.RTLgenproof]
+transl_stmt_Sexit_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_Sexpr_correct [lemma, in backend.RTLgenproof]
+transl_stmt_Sexpr_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_Sifthenelse_correct [lemma, in backend.RTLgenproof]
+transl_stmt_Sifthenelse_false_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_Sifthenelse_true_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_Sloop_exit_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_Sloop_loop_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_Sloop_loop_correct [lemma, in backend.RTLgenproof]
+transl_stmt_Sloop_stop_correct [lemma, in backend.RTLgenproof]
+transl_stmt_Sreturn_none_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_Sreturn_none_correct [lemma, in backend.RTLgenproof]
+transl_stmt_Sreturn_some_correct [lemma, in backend.RTLgenproof]
+transl_stmt_Sreturn_some_correct [lemma, in backend.Cminorgenproof]
+transl_stmt_stmtlist_incr [lemma, in backend.RTLgenproof1]
+transl_store_correct [lemma, in backend.PPCgenproof1]
+transl_trans_correct [lemma, in backend.Allocproof]
+tree [inductive, in lib.Maps]
+TREE [module, in lib.Maps]
+tReg [constructor, in backend.RTLtyping]
+tTy [constructor, in backend.RTLtyping]
+tunneled_code [definition, in backend.Tunnelingproof]
+Tunneling [library]
+Tunnelingproof [library]
+Tunnelingtyping [library]
+tunnel_block [definition, in backend.Tunneling]
+tunnel_function [definition, in backend.Tunneling]
+tunnel_function_correct [lemma, in backend.Tunnelingproof]
+tunnel_outcome [definition, in backend.Tunnelingproof]
+tunnel_program [definition, in backend.Tunneling]
+two_power_nat_O [lemma, in lib.Coqlib]
+two_power_nat_pos [lemma, in lib.Coqlib]
+typ [inductive, in backend.AST]
+type [definition, in backend.Locations]
+typenv [definition, in backend.Registers]
+typesize [definition, in backend.AST]
+typesize [definition, in backend.Locations]
+typesize_pos [lemma, in backend.Locations]
+type_args_complete [lemma, in backend.RTLtyping]
+type_args_correct [lemma, in backend.RTLtyping]
+type_args_extends [lemma, in backend.RTLtyping]
+type_args_included [lemma, in backend.RTLtyping]
+type_args_mapped [lemma, in backend.RTLtyping]
+type_args_res_complete [lemma, in backend.RTLtyping]
+type_args_res_included [lemma, in backend.RTLtyping]
+type_args_res_ros_included [lemma, in backend.RTLtyping]
+type_arg_complete [lemma, in backend.RTLtyping]
+type_arg_correct [lemma, in backend.RTLtyping]
+type_arg_correct_1 [lemma, in backend.RTLtyping]
+type_arg_extends [lemma, in backend.RTLtyping]
+type_arg_included [lemma, in backend.RTLtyping]
+type_arg_mapped [lemma, in backend.RTLtyping]
+type_instrs_extends [lemma, in backend.RTLtyping]
+type_instrs_included [lemma, in backend.RTLtyping]
+type_instr_included [lemma, in backend.RTLtyping]
+type_of_addressing [definition, in backend.Op]
+type_of_chunk [definition, in backend.Op]
+type_of_chunk_correct [lemma, in backend.Op]
+type_of_condition [definition, in backend.Op]
+type_of_index [definition, in backend.Stackingproof]
+type_of_operation [definition, in backend.Op]
+type_of_operation_sound [lemma, in backend.Op]
+type_of_sig_res [definition, in backend.RTLtyping]
+type_res_complete [lemma, in backend.RTLtyping]
+type_res_correct [lemma, in backend.RTLtyping]
+type_ros_complete [lemma, in backend.RTLtyping]
+type_ros_correct [lemma, in backend.RTLtyping]
+type_rtl_arg [definition, in backend.RTLtyping]
+type_rtl_function [definition, in backend.RTLtyping]
+type_rtl_function_correct [lemma, in backend.RTLtyping]
+type_rtl_function_instrs [lemma, in backend.RTLtyping]
+type_rtl_function_norepet [lemma, in backend.RTLtyping]
+type_rtl_function_params [lemma, in backend.RTLtyping]
+type_rtl_instr [definition, in backend.RTLtyping]
+type_rtl_ros [definition, in backend.RTLtyping]
+t_ [inductive, in lib.Lattice]
+t_ [inductive, in lib.Lattice]
+T_type [lemma, in backend.Alloctyping_aux]
+

U

+Uf [module, in backend.RTLtyping]
+unchecked_store [definition, in backend.Mem]
+Undef [constructor, in backend.Mem]
+undef_is_bool [lemma, in backend.Values]
+unfold_transf_function [lemma, in backend.Stackingproof]
+union [definition, in lib.Sets]
+UNIONFIND [module, in lib.union_find]
+unionfind [inductive, in lib.union_find]
+Unionfind [module, in lib.union_find]
+union_find [library]
+unique_labels [definition, in backend.Linearizeproof]
+unique_labels_lin_block [lemma, in backend.Linearizeproof]
+unique_labels_lin_function [lemma, in backend.Linearizeproof]
+unique_labels_lin_rec [lemma, in backend.Linearizeproof]
+unroll_positive_rec [lemma, in lib.Coqlib]
+unsigned [definition, in lib.Integers]
+unsigned_range [lemma, in lib.Integers]
+unsigned_range_2 [lemma, in lib.Integers]
+unsigned_repr [lemma, in lib.Integers]
+unsplit_move [lemma, in backend.Parallelmove]
+update [definition, in backend.Mem]
+update [definition, in backend.Parallelmove]
+update_instr [definition, in backend.RTLgen]
+update_instr_extends [lemma, in backend.RTLgenproof1]
+update_instr_incr [lemma, in backend.RTLgenproof1]
+update_instr_wf [lemma, in backend.RTLgen]
+update_o [lemma, in backend.Mem]
+update_s [lemma, in backend.Mem]
+

V

+Val [module, in backend.Values]
+val [inductive, in backend.Values]
+valid_block [definition, in backend.Mem]
+valid_block_alloc [lemma, in backend.Mem]
+valid_block_free [lemma, in backend.Mem]
+valid_block_store [lemma, in backend.Mem]
+valid_fresh_absurd [lemma, in backend.RTLgenproof1]
+valid_fresh_different [lemma, in backend.RTLgenproof1]
+valid_new_block [lemma, in backend.Mem]
+valid_not_valid_diff [lemma, in backend.Mem]
+valid_outcome [definition, in backend.Linearizeproof]
+valid_pointer [definition, in backend.Mem]
+valid_pointer_inject_no_overflow [lemma, in backend.Mem]
+valnum [definition, in backend.CSE]
+ValnumEq [module, in backend.CSEproof]
+valnum_reg [definition, in backend.CSE]
+valnum_regs [definition, in backend.CSE]
+valnum_regs_holds [lemma, in backend.CSEproof]
+valnum_reg_holds [lemma, in backend.CSEproof]
+Value [definition, in backend.Parallelmove]
+Values [library]
+valu_agree [definition, in backend.CSEproof]
+valu_agree_list [lemma, in backend.CSEproof]
+valu_agree_refl [lemma, in backend.CSEproof]
+valu_agree_trans [lemma, in backend.CSEproof]
+val_cond_reg [definition, in backend.PPC]
+val_cons_inject [constructor, in backend.Mem]
+val_content_inject [inductive, in backend.Mem]
+val_content_inject_base [constructor, in backend.Mem]
+val_content_inject_cast [lemma, in backend.Cminorgenproof]
+val_content_inject_incr [lemma, in backend.Mem]
+val_content_inject_8 [constructor, in backend.Mem]
+val_inject [inductive, in backend.Mem]
+val_inject_float [constructor, in backend.Mem]
+val_inject_incr [lemma, in backend.Mem]
+val_inject_int [constructor, in backend.Mem]
+val_inject_ptr [constructor, in backend.Mem]
+val_list_inject [inductive, in backend.Mem]
+val_list_inject_incr [lemma, in backend.Mem]
+val_list_match_approx [inductive, in backend.Constpropproof]
+val_match_approx [definition, in backend.Constpropproof]
+val_match_approx_increasing [lemma, in backend.Constpropproof]
+val_nil_inject [constructor, in backend.Mem]
+val_normalized [definition, in backend.Cminorgenproof]
+vars_vals_cons [constructor, in backend.Cminorgenproof]
+vars_vals_match [inductive, in backend.Cminorgenproof]
+vars_vals_match_extensional [lemma, in backend.Cminorgenproof]
+vars_vals_match_holds [lemma, in backend.Cminorgenproof]
+vars_vals_match_holds_1 [lemma, in backend.Cminorgenproof]
+vars_vals_nil [constructor, in backend.Cminorgenproof]
+var_addr [definition, in backend.Cminorgen]
+var_addr_global_correct [lemma, in backend.Cminorgenproof]
+var_addr_local_correct [lemma, in backend.Cminorgenproof]
+var_get [definition, in backend.Cminorgen]
+var_get_correct [lemma, in backend.Cminorgenproof]
+Var_global [constructor, in backend.Cminorgen]
+var_info [inductive, in backend.Cminorgen]
+Var_local [constructor, in backend.Cminorgen]
+var_set [definition, in backend.Cminorgen]
+var_set_correct [lemma, in backend.Cminorgenproof]
+Var_stack_array [constructor, in backend.Cminorgen]
+Var_stack_scalar [constructor, in backend.Cminorgen]
+Vfalse [definition, in backend.Values]
+Vfloat [constructor, in backend.Values]
+Vint [constructor, in backend.Values]
+vlma_cons [constructor, in backend.Constpropproof]
+vlma_nil [constructor, in backend.Constpropproof]
+VMap [module, in backend.CSEproof]
+Vmone [definition, in backend.Values]
+Vone [definition, in backend.Values]
+Vptr [constructor, in backend.Values]
+Vtrue [definition, in backend.Values]
+Vundef [constructor, in backend.Values]
+Vzero [definition, in backend.Values]
+

W

+wf_add_load [lemma, in backend.CSEproof]
+wf_add_op [lemma, in backend.CSEproof]
+wf_add_rhs [lemma, in backend.CSEproof]
+wf_analyze [lemma, in backend.CSEproof]
+wf_empty [lemma, in lib.union_find]
+wf_empty_numbering [lemma, in backend.CSEproof]
+wf_equation [definition, in backend.CSEproof]
+wf_equation_increasing [lemma, in backend.CSEproof]
+wf_kill_loads [lemma, in backend.CSEproof]
+wf_numbering [definition, in backend.CSEproof]
+wf_rhs [definition, in backend.CSEproof]
+wf_rhs_increasing [lemma, in backend.CSEproof]
+wf_transfer [lemma, in backend.CSEproof]
+wf_tunneled_code [lemma, in backend.Tunneling]
+wf_valnum_reg [lemma, in backend.CSEproof]
+wf_valnum_regs [lemma, in backend.CSEproof]
+wordsize [definition, in lib.Integers]
+wt_add_call [lemma, in backend.Alloctyping]
+wt_add_cond [lemma, in backend.Alloctyping]
+wt_add_entry [lemma, in backend.Alloctyping]
+wt_add_load [lemma, in backend.Alloctyping]
+wt_add_move [lemma, in backend.Alloctyping]
+wt_add_moves [lemma, in backend.Alloctyping_aux]
+wt_add_op_move [lemma, in backend.Alloctyping]
+wt_add_op_others [lemma, in backend.Alloctyping]
+wt_add_op_undef [lemma, in backend.Alloctyping]
+wt_add_reload [lemma, in backend.Alloctyping]
+wt_add_reloads [lemma, in backend.Alloctyping]
+wt_add_return [lemma, in backend.Alloctyping]
+wt_add_spill [lemma, in backend.Alloctyping]
+wt_add_store [lemma, in backend.Alloctyping]
+wt_add_undefs [lemma, in backend.Alloctyping]
+wt_Bgetstack [constructor, in backend.LTLtyping]
+wt_block [inductive, in backend.LTLtyping]
+wt_Bop [constructor, in backend.LTLtyping]
+wt_Bopmove [constructor, in backend.LTLtyping]
+wt_Bopundef [constructor, in backend.LTLtyping]
+wt_Bsetstack [constructor, in backend.LTLtyping]
+wt_content [definition, in backend.Machtyping]
+wt_fold_right [lemma, in backend.Stackingtyping]
+wt_frame [definition, in backend.Machtyping]
+wt_function [inductive, in backend.RTLtyping]
+wt_function [inductive, in backend.Machtyping]
+wt_function [definition, in backend.LTLtyping]
+wt_function [definition, in backend.Lineartyping]
+wt_get_slot [lemma, in backend.Machtyping]
+wt_init_frame [lemma, in backend.Machtyping]
+wt_init_regs [lemma, in backend.RTLtyping]
+wt_Inop [constructor, in backend.RTLtyping]
+wt_instr [inductive, in backend.Lineartyping]
+wt_instr [inductive, in backend.Machtyping]
+wt_instr [inductive, in backend.RTLtyping]
+wt_instrs [definition, in backend.Stackingtyping]
+wt_instrs_cons [lemma, in backend.Stackingtyping]
+wt_Iop [constructor, in backend.RTLtyping]
+wt_Iopmove [constructor, in backend.RTLtyping]
+wt_Iopundef [constructor, in backend.RTLtyping]
+wt_Lgetstack [constructor, in backend.Lineartyping]
+wt_linearize_block [lemma, in backend.Linearizetyping]
+wt_linearize_body [lemma, in backend.Linearizetyping]
+wt_Lop [constructor, in backend.Lineartyping]
+wt_Lopmove [constructor, in backend.Lineartyping]
+wt_Lopundef [constructor, in backend.Lineartyping]
+wt_Lsetstack [constructor, in backend.Lineartyping]
+wt_Mgetstack [constructor, in backend.Machtyping]
+wt_Mlabel [constructor, in backend.Machtyping]
+wt_Msetstack [constructor, in backend.Machtyping]
+wt_Msetstack' [lemma, in backend.Stackingtyping]
+wt_parallel_move [lemma, in backend.Alloctyping]
+wt_parallel_moveX [lemma, in backend.Alloctyping_aux]
+wt_parallel_move' [lemma, in backend.Alloctyping_aux]
+wt_program [definition, in backend.Lineartyping]
+wt_program [definition, in backend.RTLtyping]
+wt_program [definition, in backend.LTLtyping]
+wt_program [definition, in backend.Machtyping]
+wt_regset [definition, in backend.RTLtyping]
+wt_regset [definition, in backend.Machtyping]
+wt_regset_assign [lemma, in backend.RTLtyping]
+wt_regset_list [lemma, in backend.RTLtyping]
+wt_regs_for [lemma, in backend.Alloctyping]
+wt_regs_for_rec [lemma, in backend.Alloctyping]
+wt_reg_for [lemma, in backend.Alloctyping]
+wt_restore_callee_save [lemma, in backend.Stackingtyping]
+wt_restore_float_callee_save [lemma, in backend.Stackingtyping]
+wt_restore_int_callee_save [lemma, in backend.Stackingtyping]
+wt_rtl_function [lemma, in backend.Alloctyping]
+wt_save_callee_save [lemma, in backend.Stackingtyping]
+wt_save_float_callee_save [lemma, in backend.Stackingtyping]
+wt_save_int_callee_save [lemma, in backend.Stackingtyping]
+wt_setreg [lemma, in backend.Machtyping]
+wt_set_slot [lemma, in backend.Machtyping]
+wt_transf_entrypoint [lemma, in backend.Alloctyping]
+wt_transf_function [lemma, in backend.Stackingtyping]
+wt_transf_function [lemma, in backend.Alloctyping]
+wt_transf_function [lemma, in backend.Linearizetyping]
+wt_transf_instr [lemma, in backend.Alloctyping]
+wt_transf_instrs [lemma, in backend.Alloctyping]
+wt_transl_instr [lemma, in backend.Stackingtyping]
+wt_tunnel_block [lemma, in backend.Tunnelingtyping]
+wt_tunnel_function [lemma, in backend.Tunnelingtyping]
+

X

+xcombine_l [definition, in lib.Maps]
+xcombine_lr [lemma, in lib.Maps]
+xcombine_r [definition, in lib.Maps]
+xelements [definition, in lib.Maps]
+xelements_complete [lemma, in lib.Maps]
+xelements_correct [lemma, in lib.Maps]
+xelements_hi [lemma, in lib.Maps]
+xelements_ho [lemma, in lib.Maps]
+xelements_ih [lemma, in lib.Maps]
+xelements_ii [lemma, in lib.Maps]
+xelements_io [lemma, in lib.Maps]
+xelements_keys_norepet [lemma, in lib.Maps]
+xelements_oh [lemma, in lib.Maps]
+xelements_oi [lemma, in lib.Maps]
+xelements_oo [lemma, in lib.Maps]
+xgcombine [lemma, in lib.Maps]
+xgcombine_l [lemma, in lib.Maps]
+xgcombine_r [lemma, in lib.Maps]
+xget [definition, in lib.Maps]
+xget_left [lemma, in lib.Maps]
+xgmap [lemma, in lib.Maps]
+xkeys [definition, in lib.Maps]
+xmap [definition, in lib.Maps]
+xor [definition, in backend.Cmconstr]
+xor [definition, in backend.Values]
+xor [definition, in lib.Integers]
+xorimm [definition, in backend.PPCgen]
+xorimm_correct [lemma, in backend.PPCgenproof1]
+xor_assoc [lemma, in lib.Integers]
+xor_assoc [lemma, in backend.Values]
+xor_commut [lemma, in backend.Values]
+xor_commut [lemma, in lib.Integers]
+xor_one_one [lemma, in lib.Integers]
+xor_zero [lemma, in lib.Integers]
+xor_zero_one [lemma, in lib.Integers]
+

Z

+Zdiv_round [definition, in lib.Integers]
+Zdiv_small [lemma, in lib.Coqlib]
+Zdiv_unique [lemma, in lib.Coqlib]
+zeq [definition, in lib.Coqlib]
+zeq_false [lemma, in lib.Coqlib]
+zeq_true [lemma, in lib.Coqlib]
+zero [definition, in lib.Integers]
+zero [axiom, in lib.Floats]
+ZIndexed [module, in lib.Maps]
+zle [definition, in lib.Coqlib]
+zle_false [lemma, in lib.Coqlib]
+zle_true [lemma, in lib.Coqlib]
+zlt [definition, in lib.Coqlib]
+zlt_false [lemma, in lib.Coqlib]
+zlt_true [lemma, in lib.Coqlib]
+ZMap [module, in lib.Maps]
+Zmax_bound_l [lemma, in lib.Coqlib]
+Zmax_bound_r [lemma, in lib.Coqlib]
+Zmax_spec [lemma, in lib.Coqlib]
+Zmin_spec [lemma, in lib.Coqlib]
+Zmod_round [definition, in lib.Integers]
+Zmod_small [lemma, in lib.Coqlib]
+Zmod_unique [lemma, in lib.Coqlib]
+ztonat [definition, in backend.Mem]
+Z_bin_decomp [definition, in lib.Integers]
+Z_bin_decomp_range [lemma, in lib.Integers]
+Z_bin_decomp_shift_add [lemma, in lib.Integers]
+Z_of_bits [definition, in lib.Integers]
+Z_of_bits_excl [lemma, in lib.Integers]
+Z_of_bits_exten [lemma, in lib.Integers]
+Z_of_bits_of_Z [lemma, in lib.Integers]
+Z_of_bits_range [lemma, in lib.Integers]
+Z_of_bits_range_2 [lemma, in lib.Integers]
+Z_of_bits_shift [lemma, in lib.Integers]
+Z_of_bits_shifts [lemma, in lib.Integers]
+Z_of_bits_shifts_rev [lemma, in lib.Integers]
+Z_of_bits_shift_rev [lemma, in lib.Integers]
+Z_one_bits [definition, in lib.Integers]
+Z_one_bits_powerserie [lemma, in lib.Integers]
+Z_one_bits_range [lemma, in lib.Integers]
+Z_shift_add [definition, in lib.Integers]
+Z_shift_add_bin_decomp [lemma, in lib.Integers]
+Z_shift_add_inj [lemma, in lib.Integers]
+

_

+_ [constructor, in backend.Lineartyping]
+_ [constructor, in backend.LTLtyping]
+

+

Axiom Index

+

A

+abs [in lib.Floats]
+add [in lib.Floats]
+addf_commut [in lib.Floats]
+

C

+cmp [in lib.Floats]
+cmp_ge_gt_eq [in lib.Floats]
+cmp_le_lt_eq [in lib.Floats]
+cmp_ne_eq [in lib.Floats]
+

D

+div [in lib.Floats]
+

E

+eq_dec [in lib.Floats]
+eq_zero_false [in lib.Floats]
+eq_zero_true [in lib.Floats]
+extensionality [in lib.Coqlib]
+

F

+float [in lib.Floats]
+floatofint [in lib.Floats]
+floatofintu [in lib.Floats]
+

G

+graph_coloring [in backend.Coloring]
+

H

+high_half_signed [in backend.PPC]
+high_half_signed_type [in backend.PPC]
+high_half_unsigned [in backend.PPC]
+high_half_unsigned_type [in backend.PPC]
+

I

+intoffloat [in lib.Floats]
+

L

+low_half_signed [in backend.PPC]
+low_half_signed_type [in backend.PPC]
+low_half_unsigned [in backend.PPC]
+low_half_unsigned_type [in backend.PPC]
+low_high_half_signed [in backend.PPC]
+low_high_half_unsigned [in backend.PPC]
+

M

+more_likely [in backend.RTLgen]
+mul [in lib.Floats]
+

N

+neg [in lib.Floats]
+neg_mul_distr_l [in lib.Integers]
+neg_mul_distr_r [in lib.Integers]
+

O

+one [in lib.Floats]
+

P

+proof_irrelevance [in lib.Coqlib]
+

S

+singleoffloat [in lib.Floats]
+singleoffloat_idem [in lib.Floats]
+sub [in lib.Floats]
+subf_addf_opp [in lib.Floats]
+

Z

+zero [in lib.Floats]
+

+

Lemma Index

+

A

+addf_commut [in backend.Values]
+addimm_correct [in backend.PPCgenproof1]
+addimm_1_correct [in backend.PPCgenproof1]
+addimm_2_correct [in backend.PPCgenproof1]
+address_inject [in backend.Mem]
+addr_strength_reduction_correct [in backend.Constpropproof]
+add_and [in lib.Integers]
+add_assoc [in lib.Integers]
+add_assoc [in backend.Values]
+add_call_correct [in backend.Allocproof]
+add_commut [in lib.Integers]
+add_commut [in backend.Values]
+add_cond_correct [in backend.Allocproof]
+add_edges_instrs_correct [in backend.Coloringproof]
+add_edges_instrs_correct_aux [in backend.Coloringproof]
+add_edges_instrs_incl_aux [in backend.Coloringproof]
+add_edges_instr_correct [in backend.Coloringproof]
+add_edges_instr_incl [in backend.Coloringproof]
+add_entry_correct [in backend.Allocproof]
+add_functs_transf [in backend.Globalenvs]
+add_instr_at [in backend.RTLgenproof1]
+add_instr_incr [in backend.RTLgenproof1]
+add_instr_wf [in backend.RTLgen]
+add_interf_call_correct [in backend.Coloringproof]
+add_interf_call_correct_aux_1 [in backend.Coloringproof]
+add_interf_call_correct_aux_2 [in backend.Coloringproof]
+add_interf_call_incl [in backend.Coloringproof]
+add_interf_call_incl_aux_1 [in backend.Coloringproof]
+add_interf_call_incl_aux_2 [in backend.Coloringproof]
+add_interf_correct [in backend.InterfGraph]
+add_interf_entry_correct [in backend.Coloringproof]
+add_interf_entry_incl [in backend.Coloringproof]
+add_interf_incl [in backend.InterfGraph]
+add_interf_live_correct [in backend.Coloringproof]
+add_interf_live_correct_aux [in backend.Coloringproof]
+add_interf_live_incl [in backend.Coloringproof]
+add_interf_live_incl_aux [in backend.Coloringproof]
+add_interf_move_correct [in backend.Coloringproof]
+add_interf_move_incl [in backend.Coloringproof]
+add_interf_mreg_correct [in backend.InterfGraph]
+add_interf_mreg_incl [in backend.InterfGraph]
+add_interf_op_correct [in backend.Coloringproof]
+add_interf_op_incl [in backend.Coloringproof]
+add_interf_params_correct [in backend.Coloringproof]
+add_interf_params_correct_aux [in backend.Coloringproof]
+add_interf_params_incl [in backend.Coloringproof]
+add_interf_params_incl_aux [in backend.Coloringproof]
+add_letvar_wf [in backend.RTLgenproof1]
+add_load_correct [in backend.Allocproof]
+add_load_satisfiable [in backend.CSEproof]
+add_move_correct [in backend.RTLgenproof]
+add_move_correct [in backend.Allocproof]
+add_move_incr [in backend.RTLgenproof1]
+add_neg_zero [in lib.Integers]
+add_op_correct [in backend.Allocproof]
+add_op_satisfiable [in backend.CSEproof]
+add_permut [in backend.Values]
+add_permut [in lib.Integers]
+add_permut_4 [in backend.Values]
+add_prefs_call_incl [in backend.Coloringproof]
+add_pref_incl [in backend.InterfGraph]
+add_pref_mreg_incl [in backend.InterfGraph]
+add_reloads_correct [in backend.Allocproof]
+add_reloads_correct_rec [in backend.Allocproof]
+add_reload_correct [in backend.Allocproof]
+add_return_correct [in backend.Allocproof]
+add_rhs_satisfiable [in backend.CSEproof]
+add_signed [in lib.Integers]
+add_spill_correct [in backend.Allocproof]
+add_store_correct [in backend.Allocproof]
+add_successors_correct [in backend.Kildall]
+add_to_worklist_1 [in backend.Kildall]
+add_to_worklist_2 [in backend.Kildall]
+add_undefs_correct [in backend.Allocproof]
+add_unsigned [in lib.Integers]
+add_vars_incr [in backend.RTLgenproof1]
+add_vars_letenv [in backend.RTLgenproof1]
+add_vars_valid [in backend.RTLgenproof1]
+add_vars_wf [in backend.RTLgenproof1]
+add_var_find [in backend.RTLgenproof1]
+add_var_incr [in backend.RTLgenproof1]
+add_var_letenv [in backend.RTLgenproof1]
+add_var_valid [in backend.RTLgenproof1]
+add_var_wf [in backend.RTLgenproof1]
+add_zero [in lib.Integers]
+agree_assign_dead [in backend.Allocproof]
+agree_assign_live [in backend.Allocproof]
+agree_call [in backend.Allocproof]
+agree_eval_reg [in backend.Stackingproof]
+agree_eval_reg [in backend.Allocproof]
+agree_eval_regs [in backend.Stackingproof]
+agree_eval_regs [in backend.Allocproof]
+agree_exten [in backend.Allocproof]
+agree_exten_1 [in backend.PPCgenproof1]
+agree_exten_2 [in backend.PPCgenproof1]
+agree_increasing [in backend.Allocproof]
+agree_init_regs [in backend.Allocproof]
+agree_move_live [in backend.Allocproof]
+agree_nextinstr [in backend.PPCgenproof1]
+agree_nextinstr_commut [in backend.PPCgenproof1]
+agree_parameters [in backend.Allocproof]
+agree_reg_list_live [in backend.Allocproof]
+agree_reg_live [in backend.Allocproof]
+agree_reg_sum_live [in backend.Allocproof]
+agree_return_regs [in backend.Stackingproof]
+agree_set_commut [in backend.PPCgenproof1]
+agree_set_local [in backend.Stackingproof]
+agree_set_mfreg [in backend.PPCgenproof1]
+agree_set_mireg [in backend.PPCgenproof1]
+agree_set_mireg_exten [in backend.PPCgenproof1]
+agree_set_mireg_twice [in backend.PPCgenproof1]
+agree_set_mreg [in backend.PPCgenproof1]
+agree_set_other [in backend.PPCgenproof1]
+agree_set_outgoing [in backend.Stackingproof]
+agree_set_reg [in backend.Stackingproof]
+agree_set_twice_mireg [in backend.PPCgenproof1]
+align_le [in lib.Coqlib]
+allocs_write_ok [in backend.Alloctyping]
+alloc_extends [in backend.Mem]
+alloc_mapped_inject [in backend.Mem]
+alloc_of_coloring_correct_1 [in backend.Coloringproof]
+alloc_of_coloring_correct_2 [in backend.Coloringproof]
+alloc_of_coloring_correct_3 [in backend.Coloringproof]
+alloc_of_coloring_correct_4 [in backend.Coloringproof]
+alloc_regs_fresh_or_in_map [in backend.RTLgenproof1]
+alloc_regs_incr [in backend.RTLgenproof1]
+alloc_regs_target_ok [in backend.RTLgenproof1]
+alloc_regs_valid [in backend.RTLgenproof1]
+alloc_reg_fresh_or_in_map [in backend.RTLgenproof1]
+alloc_reg_incr [in backend.RTLgenproof1]
+alloc_reg_target_ok [in backend.RTLgenproof1]
+alloc_reg_valid [in backend.RTLgenproof1]
+alloc_right_inject [in backend.Mem]
+alloc_type [in backend.Alloctyping]
+alloc_types [in backend.Alloctyping]
+alloc_unmapped_inject [in backend.Mem]
+alloc_variables_list_block [in backend.Cminorgenproof]
+alloc_variables_nextblock_incr [in backend.Cminorgenproof]
+alloc_write_ok [in backend.Alloctyping]
+all_interf_regs_correct_aux_1 [in backend.InterfGraph]
+all_interf_regs_correct_aux_2 [in backend.InterfGraph]
+all_interf_regs_correct_aux_3 [in backend.InterfGraph]
+all_interf_regs_correct_1 [in backend.InterfGraph]
+all_interf_regs_correct_2 [in backend.InterfGraph]
+analysis_correct_entry [in backend.CSEproof]
+analysis_correct_N [in backend.CSEproof]
+analysis_correct_1 [in backend.CSEproof]
+analyze_correct [in backend.Allocproof]
+analyze_correct_1 [in backend.Constpropproof]
+analyze_correct_2 [in backend.Constpropproof]
+analyze_correct_3 [in backend.Constpropproof]
+analyze_invariant [in backend.Kildall]
+analyze_P [in backend.Kildall]
+andimm_correct [in backend.PPCgenproof1]
+and_assoc [in backend.Values]
+and_assoc [in lib.Integers]
+and_commut [in lib.Integers]
+and_commut [in backend.Values]
+and_idem [in lib.Integers]
+and_mone [in lib.Integers]
+and_or_distrib [in lib.Integers]
+and_shl [in lib.Integers]
+and_shru [in lib.Integers]
+and_xor_distrib [in lib.Integers]
+and_zero [in lib.Integers]
+appcons_length [in backend.Parallelmove]
+append_assoc_0 [in lib.Maps]
+append_assoc_1 [in lib.Maps]
+append_injective [in lib.Maps]
+append_neutral_l [in lib.Maps]
+append_neutral_r [in lib.Maps]
+apply_total_transf_program [in backend.Main]
+approx_regs_val_list [in backend.Constpropproof]
+app_app [in backend.Parallelmove]
+app_cons [in backend.Parallelmove]
+app_nil [in backend.Parallelmove]
+app_rewrite [in backend.Parallelmove]
+app_rewriter [in backend.Parallelmove]
+app_rewrite2 [in backend.Parallelmove]
+arguments_not_preserved [in backend.Conventions]
+

B

+bind_parameters_length [in backend.Cminorgenproof]
+bits_of_Z_above [in lib.Integers]
+bits_of_Z_below [in lib.Integers]
+bits_of_Z_mone [in lib.Integers]
+bits_of_Z_of_bits [in lib.Integers]
+bits_of_Z_zero [in lib.Integers]
+bitwise_binop_assoc [in lib.Integers]
+bitwise_binop_commut [in lib.Integers]
+bitwise_binop_idem [in lib.Integers]
+bitwise_binop_rol [in lib.Integers]
+bitwise_binop_shl [in lib.Integers]
+bitwise_binop_shru [in lib.Integers]
+block_agree_refl [in backend.Mem]
+block_agree_sym [in backend.Mem]
+block_agree_trans [in backend.Mem]
+block_contents_exten [in backend.Mem]
+block_contents_inject_incr [in backend.Mem]
+block_cont_val [in backend.Mem]
+bool_of_false_val [in backend.Values]
+bool_of_false_val2 [in backend.Values]
+bool_of_false_val_inv [in backend.Values]
+bool_of_true_val [in backend.Values]
+bool_of_true_val2 [in backend.Values]
+bool_of_true_val_inv [in backend.Values]
+bounds_free_block [in backend.Mem]
+bound_float_callee_save_pos [in backend.Lineartyping]
+bound_float_local_pos [in backend.Lineartyping]
+bound_int_callee_save_pos [in backend.Lineartyping]
+bound_int_local_pos [in backend.Lineartyping]
+bound_outgoing_pos [in backend.Lineartyping]
+branch_target_characterization [in backend.Tunnelingproof]
+branch_target_rec_1 [in backend.Tunnelingproof]
+branch_target_rec_2 [in backend.Tunnelingproof]
+

C

+callstack_dom_diff [in backend.Machabstr2mach]
+callstack_dom_incr [in backend.Machabstr2mach]
+callstack_dom_less [in backend.Machabstr2mach]
+callstack_exten [in backend.Machabstr2mach]
+callstack_function_entry [in backend.Machabstr2mach]
+callstack_function_return [in backend.Machabstr2mach]
+callstack_get_parent [in backend.Machabstr2mach]
+callstack_get_slot [in backend.Machabstr2mach]
+callstack_init [in backend.Machabstr2mach]
+callstack_load [in backend.Machabstr2mach]
+callstack_set_slot [in backend.Machabstr2mach]
+callstack_store [in backend.Machabstr2mach]
+callstack_store_aux [in backend.Machabstr2mach]
+callstack_store_ok [in backend.Machabstr2mach]
+call_regs_param_of_arg [in backend.Allocproof]
+cast16unsigned_and [in lib.Integers]
+cast16unsigned_and [in backend.Values]
+cast16_signed_equal_if_unsigned_equal [in lib.Integers]
+cast16_signed_idem [in lib.Integers]
+cast16_unsigned_idem [in lib.Integers]
+cast16_unsigned_signed [in lib.Integers]
+cast8unsigned_and [in lib.Integers]
+cast8unsigned_and [in backend.Values]
+cast8_signed_equal_if_unsigned_equal [in lib.Integers]
+cast8_signed_idem [in lib.Integers]
+cast8_signed_unsigned [in lib.Integers]
+cast8_unsigned_idem [in lib.Integers]
+cast8_unsigned_signed [in lib.Integers]
+check_all_leaves_sound [in lib.Inclusion]
+check_coloring_1_correct [in backend.Coloringproof]
+check_coloring_2_correct [in backend.Coloringproof]
+check_coloring_3_correct [in backend.Coloringproof]
+check_cont_agree [in backend.Mem]
+check_cont_false [in backend.Mem]
+check_cont_inject [in backend.Mem]
+check_cont_inv [in backend.Mem]
+check_cont_true [in backend.Mem]
+check_equal_on_range_correct [in lib.Integers]
+cleanup_code_conservation [in backend.Linearizetyping]
+cleanup_code_conservation_2 [in backend.Linearizetyping]
+cleanup_code_correct_1 [in backend.Linearizeproof]
+cleanup_code_correct_2 [in backend.Linearizeproof]
+cleanup_function_conservation [in backend.Linearizetyping]
+cleanup_function_conservation_2 [in backend.Linearizetyping]
+cleanup_function_correct [in backend.Linearizeproof]
+cmpf_ge [in backend.Values]
+cmpf_is_bool [in backend.Values]
+cmpf_le [in backend.Values]
+cmpu_is_bool [in backend.Values]
+cmp_is_bool [in backend.Values]
+cmp_mismatch_is_bool [in backend.Values]
+code_tail_next [in backend.PPCgenproof]
+code_tail_next_int [in backend.PPCgenproof]
+combine_commut [in lib.Maps]
+compare [in lib.Ordered]
+compare [in lib.Ordered]
+compare [in lib.Ordered]
+compare_float_spec [in backend.PPCgenproof1]
+compare_sint_spec [in backend.PPCgenproof1]
+compare_uint_spec [in backend.PPCgenproof1]
+cond_strength_reduction_correct [in backend.Constpropproof]
+consistent_not_eq [in backend.RTLtyping]
+cons_replace [in backend.Parallelmove]
+contentmap_inject_incr [in backend.Mem]
+content_inject_incr [in backend.Mem]
+correct_interf_alloc_instr [in backend.Coloringproof]
+correct_interf_instr_incl [in backend.Coloringproof]
+

D

+definite_included [in backend.RTLtyping]
+diff_not_eq [in backend.Locations]
+diff_sym [in backend.Locations]
+discard_top_worklist_invariant [in backend.Kildall]
+disc1 [in backend.Parallelmove]
+disc2 [in backend.Parallelmove]
+disjoint_cons_left [in backend.Locations]
+disjoint_cons_right [in backend.Locations]
+disjoint_notin [in backend.Locations]
+disjoint_sym [in backend.Locations]
+disjoint_tmp__noTmp [in backend.Parallelmove]
+dis_dsttmp1_pnilnil [in backend.Allocproof_aux]
+dis_srctmp1_pnilnil [in backend.Allocproof_aux]
+divs_pow2 [in lib.Integers]
+divs_pow2 [in backend.Values]
+divu_pow2 [in backend.Values]
+divu_pow2 [in lib.Integers]
+Done_notmp1src_inv [in backend.Allocproof_aux]
+Done_notmp1src_invf [in backend.Allocproof_aux]
+Done_notmp1src_invpp [in backend.Allocproof_aux]
+Done_notmp1src_res [in backend.Allocproof_aux]
+Done_notmp1_inv [in backend.Allocproof_aux]
+Done_notmp1_invf [in backend.Allocproof_aux]
+Done_notmp1_invpp [in backend.Allocproof_aux]
+Done_notmp1_res [in backend.Allocproof_aux]
+Done_notmp3_inv [in backend.Allocproof_aux]
+Done_notmp3_invf [in backend.Allocproof_aux]
+Done_notmp3_invpp [in backend.Allocproof_aux]
+Done_notmp3_res [in backend.Allocproof_aux]
+dstepp_sameExec [in backend.Parallelmove]
+dstepp_stepp [in backend.Parallelmove]
+dstep_inv [in backend.Parallelmove]
+dstep_inv_getdst [in backend.Parallelmove]
+dstep_step [in backend.Parallelmove]
+dst_tmp2_res [in backend.Allocproof_aux]
+dst_tmp2_step [in backend.Allocproof_aux]
+dst_tmp2_stepf [in backend.Allocproof_aux]
+dst_tmp2_stepp [in backend.Allocproof_aux]
+

E

+elements_complete [in lib.Maps]
+elements_complete [in lib.Sets]
+elements_correct [in lib.Maps]
+elements_correct [in lib.Sets]
+elements_keys_norepet [in lib.Maps]
+empty_numbering_satisfiable [in backend.CSE]
+encode_decode [in backend.RTLtyping]
+encode_injective [in backend.RTLtyping]
+entrypoint_function_translated [in backend.Allocproof]
+enumerate_complete [in backend.Linearizeproof]
+enumerate_head [in backend.Linearizeproof]
+enumerate_norepet [in backend.Linearizeproof]
+eq [in backend.Constprop]
+eq [in lib.Lattice]
+eq [in lib.Sets]
+eq [in lib.Lattice]
+eq [in lib.Lattice]
+eq [in backend.Locations]
+eq [in lib.Maps]
+eq [in lib.Maps]
+eqmod_add [in lib.Integers]
+eqmod_mod [in lib.Integers]
+eqmod_mod_eq [in lib.Integers]
+eqmod_mult [in lib.Integers]
+eqmod_neg [in lib.Integers]
+eqmod_refl [in lib.Integers]
+eqmod_refl2 [in lib.Integers]
+eqmod_small_eq [in lib.Integers]
+eqmod_sub [in lib.Integers]
+eqmod_sym [in lib.Integers]
+eqmod_trans [in lib.Integers]
+eqmod_256_unsigned_repr [in lib.Integers]
+eqmod_65536_unsigned_repr [in lib.Integers]
+eqm_add [in lib.Integers]
+eqm_mult [in lib.Integers]
+eqm_neg [in lib.Integers]
+eqm_refl [in lib.Integers]
+eqm_refl2 [in lib.Integers]
+eqm_samerepr [in lib.Integers]
+eqm_signed_unsigned [in lib.Integers]
+eqm_small_eq [in lib.Integers]
+eqm_sub [in lib.Integers]
+eqm_sym [in lib.Integers]
+eqm_trans [in lib.Integers]
+eqm_unsigned_repr [in lib.Integers]
+eqm_unsigned_repr_l [in lib.Integers]
+eqm_unsigned_repr_r [in lib.Integers]
+equal_eq [in backend.RTLtyping]
+equal_on_range [in lib.Integers]
+equation_evals_to_holds_1 [in backend.CSEproof]
+equation_evals_to_holds_2 [in backend.CSEproof]
+eq_dec [in lib.Integers]
+eq_false [in lib.Integers]
+eq_refl [in lib.Ordered]
+eq_refl [in lib.Ordered]
+eq_refl [in lib.Ordered]
+eq_spec [in lib.Integers]
+eq_sym [in lib.Ordered]
+eq_sym [in lib.Ordered]
+eq_sym [in lib.Integers]
+eq_sym [in lib.Ordered]
+eq_trans [in lib.Ordered]
+eq_trans [in lib.Ordered]
+eq_trans [in lib.Ordered]
+eq_true [in lib.Integers]
+error_inconsistent [in backend.RTLtyping]
+eval_absfloat [in backend.Cmconstrproof]
+eval_add [in backend.Cmconstrproof]
+eval_addf [in backend.Cmconstrproof]
+eval_addimm [in backend.Cmconstrproof]
+eval_addimm_ptr [in backend.Cmconstrproof]
+eval_addressing [in backend.Cmconstrproof]
+eval_addressing_preserved [in backend.Op]
+eval_addressing_weaken [in backend.Op]
+eval_add_ptr [in backend.Cmconstrproof]
+eval_add_ptr_2 [in backend.Cmconstrproof]
+eval_and [in backend.Cmconstrproof]
+eval_andimm [in backend.Cmconstrproof]
+eval_base_condition_of_expr [in backend.Cmconstrproof]
+eval_cast16signed [in backend.Cmconstrproof]
+eval_cast16unsigned [in backend.Cmconstrproof]
+eval_cast8signed [in backend.Cmconstrproof]
+eval_cast8unsigned [in backend.Cmconstrproof]
+eval_cmp [in backend.Cmconstrproof]
+eval_cmpf [in backend.Cmconstrproof]
+eval_cmpu [in backend.Cmconstrproof]
+eval_cmp_null_l [in backend.Cmconstrproof]
+eval_cmp_null_r [in backend.Cmconstrproof]
+eval_cmp_ptr [in backend.Cmconstrproof]
+eval_compare_null_weaken [in backend.Op]
+eval_conditionalexpr_false [in backend.Cmconstrproof]
+eval_conditionalexpr_true [in backend.Cmconstrproof]
+eval_condition_of_expr [in backend.Cmconstrproof]
+eval_condition_total_is_bool [in backend.Op]
+eval_condition_weaken [in backend.Op]
+eval_divf [in backend.Cmconstrproof]
+eval_divs [in backend.Cmconstrproof]
+eval_divu [in backend.Cmconstrproof]
+eval_divu_base [in backend.Cmconstrproof]
+eval_floatofint [in backend.Cmconstrproof]
+eval_floatofintu [in backend.Cmconstrproof]
+eval_intoffloat [in backend.Cmconstrproof]
+eval_lift [in backend.Cmconstrproof]
+eval_lift_expr [in backend.Cmconstrproof]
+eval_load [in backend.Cmconstrproof]
+eval_mods [in backend.Cmconstrproof]
+eval_modu [in backend.Cmconstrproof]
+eval_mod_aux [in backend.Cmconstrproof]
+eval_mul [in backend.Cmconstrproof]
+eval_mulf [in backend.Cmconstrproof]
+eval_mulimm [in backend.Cmconstrproof]
+eval_mulimm_base [in backend.Cmconstrproof]
+eval_negate_condition [in backend.Op]
+eval_negfloat [in backend.Cmconstrproof]
+eval_negint [in backend.Cmconstrproof]
+eval_notbool [in backend.Cmconstrproof]
+eval_notbool_base [in backend.Cmconstrproof]
+eval_notint [in backend.Cmconstrproof]
+eval_operation_preserved [in backend.Op]
+eval_operation_weaken [in backend.Op]
+eval_or [in backend.Cmconstrproof]
+eval_rolm [in backend.Cmconstrproof]
+eval_shl [in backend.Cmconstrproof]
+eval_shlimm [in backend.Cmconstrproof]
+eval_shr [in backend.Cmconstrproof]
+eval_shru [in backend.Cmconstrproof]
+eval_shruimm [in backend.Cmconstrproof]
+eval_singleoffloat [in backend.Cmconstrproof]
+eval_static_condition_correct [in backend.Constpropproof]
+eval_static_operation_correct [in backend.Constpropproof]
+eval_store [in backend.Cmconstrproof]
+eval_sub [in backend.Cmconstrproof]
+eval_subf [in backend.Cmconstrproof]
+eval_sub_ptr_int [in backend.Cmconstrproof]
+eval_sub_ptr_ptr [in backend.Cmconstrproof]
+eval_xor [in backend.Cmconstrproof]
+exec_blocks_Bgoto_inv [in backend.Tunnelingproof]
+exec_blocks_extends [in backend.LTL]
+exec_blocks_valid_outcome [in backend.Linearizeproof]
+exec_block_Bgoto_inv [in backend.Tunnelingproof]
+exec_function_body_prop_ [in backend.PPCgenproof]
+exec_function_equiv [in backend.Machabstr2mach]
+exec_function_prop_ [in backend.PPCgenproof]
+exec_ifthenelse_false [in backend.Cmconstrproof]
+exec_ifthenelse_true [in backend.Cmconstrproof]
+exec_Iload' [in backend.RTL]
+exec_instrs_Bgoto_inv [in backend.Tunnelingproof]
+exec_instrs_extends [in backend.RTLgenproof1]
+exec_instrs_extends_rec [in backend.RTLgenproof1]
+exec_instrs_incl [in backend.Stackingproof]
+exec_instrs_incl [in backend.PPCgenproof]
+exec_instrs_incr [in backend.RTLgenproof1]
+exec_instrs_link_invariant [in backend.Machtyping]
+exec_instrs_pmov [in backend.Allocproof_aux]
+exec_instrs_present [in backend.RTL]
+exec_instr_extends [in backend.RTLgenproof1]
+exec_instr_extends_rec [in backend.RTLgenproof1]
+exec_instr_incl [in backend.PPCgenproof]
+exec_instr_incl [in backend.Stackingproof]
+exec_instr_incr [in backend.RTLgenproof1]
+exec_instr_in_s2 [in backend.RTLgenproof1]
+exec_instr_link_invariant [in backend.Machtyping]
+exec_instr_not_halt [in backend.RTLgenproof1]
+exec_instr_present [in backend.RTL]
+exec_instr_update [in backend.Allocproof_aux]
+exec_Iop' [in backend.RTL]
+exec_Mcall_prop [in backend.PPCgenproof]
+exec_Mcond_false_prop [in backend.PPCgenproof]
+exec_Mcond_true_prop [in backend.PPCgenproof]
+exec_Mgetparam_prop [in backend.PPCgenproof]
+exec_Mgetstack' [in backend.Stackingproof]
+exec_Mgetstack_prop [in backend.PPCgenproof]
+exec_Mgoto_prop [in backend.PPCgenproof]
+exec_Mlabel_prop [in backend.PPCgenproof]
+exec_Mload_prop [in backend.PPCgenproof]
+exec_Mop_prop [in backend.PPCgenproof]
+exec_Msetstack' [in backend.Stackingproof]
+exec_Msetstack_prop [in backend.PPCgenproof]
+exec_Mstore_prop [in backend.PPCgenproof]
+exec_mutual_induction [in backend.Machabstr]
+exec_one_prop [in backend.PPCgenproof]
+exec_program_equiv [in backend.Machabstr2mach]
+exec_refl_prop [in backend.PPCgenproof]
+exec_step [in backend.RTL]
+exec_straight_exec_prop [in backend.PPCgenproof]
+exec_straight_one [in backend.PPCgenproof1]
+exec_straight_steps [in backend.PPCgenproof]
+exec_straight_steps_1 [in backend.PPCgenproof]
+exec_straight_steps_2 [in backend.PPCgenproof]
+exec_straight_three [in backend.PPCgenproof1]
+exec_straight_trans [in backend.PPCgenproof1]
+exec_straight_two [in backend.PPCgenproof1]
+exec_trans_prop [in backend.PPCgenproof]
+expr_condexpr_exprlist_ind [in backend.RTLgenproof1]
+exten [in lib.Maps]
+extends_refl [in backend.Mem]
+extend_inject_incr [in backend.Mem]
+

F

+find_funct_find_funct_ptr [in backend.Globalenvs]
+find_funct_inv [in backend.Globalenvs]
+find_funct_prop [in backend.Globalenvs]
+find_funct_ptr_inv [in backend.Globalenvs]
+find_funct_ptr_prop [in backend.Globalenvs]
+find_funct_ptr_transf [in backend.Globalenvs]
+find_funct_ptr_transf_partial [in backend.Globalenvs]
+find_funct_transf [in backend.Globalenvs]
+find_funct_transf_partial [in backend.Globalenvs]
+find_instr_in [in backend.PPCgenproof]
+find_instr_tail [in backend.PPCgenproof]
+find_label_cleanup_code [in backend.Linearizeproof]
+find_label_goto_label [in backend.PPCgenproof]
+find_label_incl [in backend.Stackingproof]
+find_label_lin [in backend.Linearizeproof]
+find_label_lin_block [in backend.Linearizeproof]
+find_label_lin_rec [in backend.Linearizeproof]
+find_label_transl_code [in backend.Stackingproof]
+find_label_unique [in backend.Linearizeproof]
+find_letvar_incr [in backend.RTLgenproof1]
+find_letvar_in_map [in backend.RTLgenproof1]
+find_letvar_not_mutated [in backend.RTLgenproof1]
+find_letvar_valid [in backend.RTLgenproof1]
+find_load_correct [in backend.CSEproof]
+find_op_correct [in backend.CSEproof]
+find_rhs_correct [in backend.CSEproof]
+find_symbol_inv [in backend.Globalenvs]
+find_symbol_transf [in backend.Globalenvs]
+find_symbol_transf_partial [in backend.Globalenvs]
+find_valnum_rhs_correct [in backend.CSEproof]
+find_var_incr [in backend.RTLgenproof1]
+find_var_in_map [in backend.RTLgenproof1]
+find_var_not_mutated [in backend.RTLgenproof1]
+find_var_valid [in backend.RTLgenproof1]
+fixpoint_entry [in backend.Kildall]
+fixpoint_entry [in backend.Kildall]
+fixpoint_entry [in backend.Kildall]
+fixpoint_incr [in backend.Kildall]
+fixpoint_invariant [in backend.Kildall]
+fixpoint_solution [in backend.Kildall]
+fixpoint_solution [in backend.Kildall]
+fixpoint_solution [in backend.Kildall]
+flatten_aux_valid_A [in lib.Inclusion]
+flatten_valid_A [in lib.Inclusion]
+floatcomp_correct [in backend.PPCgenproof1]
+float_callee_save_bound [in backend.Linearizetyping]
+float_callee_save_norepet [in backend.Conventions]
+float_callee_save_not_destroyed [in backend.Conventions]
+float_callee_save_type [in backend.Conventions]
+float_local_slot_bound [in backend.Linearizetyping]
+fold_spec [in lib.Maps]
+fold_spec [in lib.Sets]
+for_all_spec [in lib.Sets]
+Fpmov_correct [in backend.Parallelmove]
+Fpmov_correctMoves [in backend.Parallelmove]
+Fpmov_correct1 [in backend.Parallelmove]
+Fpmov_correct2 [in backend.Parallelmove]
+Fpmov_correct_ext [in backend.Parallelmove]
+Fpmov_correct_IT3 [in backend.Parallelmove]
+Fpmov_correct_map [in backend.Parallelmove]
+frame_match_alloc [in backend.Machabstr2mach]
+frame_match_exten [in backend.Machabstr2mach]
+frame_match_free [in backend.Machabstr2mach]
+frame_match_get_slot [in backend.Machabstr2mach]
+frame_match_load [in backend.Machabstr2mach]
+frame_match_new [in backend.Machabstr2mach]
+frame_match_set_slot [in backend.Machabstr2mach]
+frame_match_store [in backend.Machabstr2mach]
+frame_match_store_ok [in backend.Machabstr2mach]
+frame_match_store_stack_other [in backend.Machabstr2mach]
+free_empty_bounds [in backend.Mem]
+free_extends [in backend.Mem]
+free_first_inject [in backend.Mem]
+free_first_list_inject [in backend.Mem]
+free_inject [in backend.Mem]
+free_snd_inject [in backend.Mem]
+freg_eq [in backend.PPC]
+freg_of_is_data_reg [in backend.PPCgenproof1]
+freg_of_not_FPR13 [in backend.PPCgenproof1]
+freg_val [in backend.PPCgenproof1]
+fresh_block_alloc [in backend.Mem]
+functions_globalenv [in backend.Globalenvs]
+functions_translated [in backend.Constpropproof]
+functions_translated [in backend.Tunnelingproof]
+functions_translated [in backend.PPCgenproof]
+functions_translated [in backend.Allocproof]
+functions_translated [in backend.Linearizeproof]
+functions_translated [in backend.Stackingproof]
+functions_translated [in backend.CSEproof]
+functions_translated [in backend.Cminorgenproof]
+functions_translated [in backend.RTLgenproof]
+functions_translated_no_overflow [in backend.PPCgenproof]
+functions_translated_2 [in backend.PPCgenproof]
+function_entry_ok [in backend.Cminorgenproof]
+function_ptr_translated [in backend.Linearizeproof]
+function_ptr_translated [in backend.Allocproof]
+function_ptr_translated [in backend.Stackingproof]
+function_ptr_translated [in backend.Cminorgenproof]
+function_ptr_translated [in backend.RTLgenproof]
+function_ptr_translated [in backend.Constpropproof]
+function_ptr_translated [in backend.Tunnelingproof]
+funct_ptr_translated [in backend.CSEproof]
+f2ind [in backend.Parallelmove]
+f2ind' [in backend.Parallelmove]
+

G

+gcombine [in lib.Maps]
+gempty [in lib.Maps]
+getdst_add [in backend.Parallelmove]
+getdst_app [in backend.Parallelmove]
+getdst_f [in backend.Alloctyping_aux]
+getdst_lists2moves [in backend.Allocproof_aux]
+getdst_map [in backend.Parallelmove]
+getN_agree [in backend.Mem]
+getN_init [in backend.Mem]
+getN_inject [in backend.Mem]
+getN_setN_mismatch [in backend.Mem]
+getN_setN_other [in backend.Mem]
+getN_setN_overlap [in backend.Mem]
+getN_setN_same [in backend.Mem]
+getsrcdst_app [in backend.Allocproof_aux]
+getsrc_add [in backend.Parallelmove]
+getsrc_add1 [in backend.Parallelmove]
+getsrc_app [in backend.Parallelmove]
+getsrc_f [in backend.Alloctyping_aux]
+getsrc_map [in backend.Parallelmove]
+get_add_1 [in backend.RTLtyping]
+get_add_2 [in backend.RTLtyping]
+get_bot [in lib.Lattice]
+get_empty [in backend.RTLtyping]
+get_noWrite [in backend.Parallelmove]
+get_pexec_id_noWrite [in backend.Parallelmove]
+get_slot_index [in backend.Stackingproof]
+get_slot_ok [in backend.Stackingproof]
+get_top [in lib.Lattice]
+get_update [in backend.Parallelmove]
+get_update_diff [in backend.Parallelmove]
+get_update_id [in backend.Parallelmove]
+get_update_ndiff [in backend.Parallelmove]
+get_xget_h [in lib.Maps]
+ge_bot [in lib.Lattice]
+ge_bot [in lib.Lattice]
+ge_bot [in lib.Sets]
+ge_bot [in lib.Lattice]
+ge_bot [in backend.Constprop]
+ge_lub_left [in lib.Lattice]
+ge_lub_left [in lib.Sets]
+ge_lub_left [in backend.Constprop]
+ge_lub_left [in lib.Lattice]
+ge_lub_left [in lib.Lattice]
+ge_lub_right [in lib.Sets]
+ge_refl [in lib.Lattice]
+ge_refl [in lib.Sets]
+ge_refl [in lib.Lattice]
+ge_refl [in lib.Lattice]
+ge_refl [in backend.Constprop]
+ge_top [in lib.Lattice]
+ge_top [in backend.Constprop]
+ge_top [in lib.Lattice]
+ge_top [in lib.Lattice]
+ge_trans [in lib.Lattice]
+ge_trans [in backend.Constprop]
+ge_trans [in lib.Sets]
+ge_trans [in lib.Lattice]
+ge_trans [in lib.Lattice]
+gi [in lib.Maps]
+gi [in lib.Maps]
+gi [in lib.Maps]
+gleaf [in lib.Maps]
+gmap [in lib.Maps]
+gmap [in lib.Maps]
+gmap [in lib.Maps]
+gmap [in lib.Maps]
+gpr_or_zero_not_zero [in backend.PPCgenproof1]
+gpr_or_zero_zero [in backend.PPCgenproof1]
+graph_incl_refl [in backend.Coloringproof]
+graph_incl_trans [in backend.InterfGraph]
+gro [in lib.Maps]
+grs [in lib.Maps]
+gsident [in lib.Maps]
+gsident [in lib.Maps]
+gsident [in lib.Maps]
+gso [in lib.Maps]
+gso [in backend.Locations]
+gso [in lib.Maps]
+gso [in lib.Maps]
+gso [in lib.Lattice]
+gso [in lib.Maps]
+gss [in lib.Maps]
+gss [in lib.Maps]
+gss [in backend.Locations]
+gss [in lib.Maps]
+gss [in lib.Lattice]
+gss [in lib.Maps]
+gsspec [in lib.Maps]
+gsspec [in lib.Maps]
+gsspec [in lib.Maps]
+gsspec [in lib.Maps]
+

H

+high_bound_alloc [in backend.Mem]
+high_bound_free [in backend.Mem]
+high_bound_store [in backend.Mem]
+high_half_signed_zero [in backend.PPCgenproof1]
+high_half_unsigned_zero [in backend.PPCgenproof1]
+

I

+identify_aux_decomp [in lib.union_find]
+identify_base_a_maps_to_b [in lib.union_find]
+identify_base_b_canon [in lib.union_find]
+identify_base_order_wf [in lib.union_find]
+identify_base_repr [in lib.union_find]
+identify_base_repr_order [in lib.union_find]
+identify_base_sameclass_1 [in lib.union_find]
+identify_base_sameclass_2 [in lib.union_find]
+included_consistent [in backend.RTLtyping]
+included_identify [in backend.RTLtyping]
+included_mapped [in backend.RTLtyping]
+included_mapped_forall [in backend.RTLtyping]
+included_refl [in backend.RTLtyping]
+included_trans [in backend.RTLtyping]
+inclusion_theorem [in lib.Inclusion]
+incl_app_inv_l [in lib.Coqlib]
+incl_app_inv_r [in lib.Coqlib]
+incl_cons_inv [in lib.Coqlib]
+incl_dst [in backend.Alloctyping_aux]
+incl_find_label [in backend.Machtyping]
+incl_nil [in backend.Alloctyping_aux]
+incl_same_head [in lib.Coqlib]
+incl_src [in backend.Alloctyping_aux]
+index_arg_valid [in backend.Stackingproof]
+index_float_callee_save_inj [in backend.Conventions]
+index_float_callee_save_pos [in backend.Conventions]
+index_float_callee_save_pos2 [in backend.Conventions]
+index_inj [in lib.Maps]
+index_inj [in backend.Locations]
+index_inj [in lib.Maps]
+index_int_callee_save_inj [in backend.Conventions]
+index_int_callee_save_pos [in backend.Conventions]
+index_int_callee_save_pos2 [in backend.Conventions]
+index_local_valid [in backend.Stackingproof]
+index_saved_float_valid [in backend.Stackingproof]
+index_saved_int_valid [in backend.Stackingproof]
+index_val_init_frame [in backend.Stackingproof]
+Indst_noOverlap_aux [in backend.Parallelmove]
+Ingetsrc_swap [in backend.Parallelmove]
+Ingetsrc_swap2 [in backend.Parallelmove]
+initial_state_invariant [in backend.Kildall]
+initmem_nullptr [in backend.Globalenvs]
+initmem_undef [in backend.Globalenvs]
+init_mapping_wf [in backend.RTLgenproof1]
+init_mem_transf [in backend.Globalenvs]
+init_mem_transf_partial [in backend.Globalenvs]
+init_state_wf [in backend.RTLgen]
+inject_incr_refl [in backend.Mem]
+inject_incr_trans [in backend.Mem]
+insert_bin_included [in lib.Inclusion]
+insert_lenv_lookup1 [in backend.Cmconstrproof]
+insert_lenv_lookup2 [in backend.Cmconstrproof]
+instr_at_incr [in backend.RTLgenproof1]
+interfere_incl [in backend.Coloringproof]
+interfere_mreg_incl [in backend.Coloringproof]
+interfere_sym [in backend.InterfGraph]
+interf_graph_correct_1 [in backend.Coloringproof]
+interf_graph_correct_2 [in backend.Coloringproof]
+interf_graph_correct_3 [in backend.Coloringproof]
+intval_correct [in backend.Constpropproof]
+int_add_no_overflow [in backend.Machabstr2mach]
+int_callee_save_bound [in backend.Linearizetyping]
+int_callee_save_norepet [in backend.Conventions]
+int_callee_save_not_destroyed [in backend.Conventions]
+int_callee_save_type [in backend.Conventions]
+int_float_callee_save_disjoint [in backend.Conventions]
+int_local_slot_bound [in backend.Linearizetyping]
+inv_eval_Eop_0 [in backend.Cmconstrproof]
+inv_eval_Eop_1 [in backend.Cmconstrproof]
+inv_eval_Eop_2 [in backend.Cmconstrproof]
+in_bounds_exten [in backend.Mem]
+in_bounds_holds [in backend.Mem]
+in_bounds_inject [in backend.Mem]
+in_cons_noteq [in backend.Allocproof_aux]
+in_incr_refl [in backend.Kildall]
+in_incr_trans [in backend.Kildall]
+In_Indst [in backend.Parallelmove]
+in_move__in_srcdst [in backend.Alloctyping_aux]
+In_norepet [in backend.Allocproof_aux]
+in_notin_diff [in backend.Locations]
+In_noTmp_notempo [in backend.Parallelmove]
+in_or_insert_bin [in lib.Inclusion]
+in_or_notin_callstack [in backend.Machabstr2mach]
+In_permute_app_head [in lib.Inclusion]
+in_range_range [in lib.Integers]
+in_remove_head [in lib.Inclusion]
+In_SD_diff [in backend.Parallelmove]
+In_SD_diff' [in backend.Parallelmove]
+In_SD_no_o [in backend.Parallelmove]
+in_split_move [in backend.Alloctyping_aux]
+in_xelements [in lib.Maps]
+in_xkeys [in lib.Maps]
+ireg_eq [in backend.PPC]
+ireg_of_is_data_reg [in backend.PPCgenproof1]
+ireg_of_not_GPR1 [in backend.PPCgenproof1]
+ireg_of_not_GPR2 [in backend.PPCgenproof1]
+ireg_val [in backend.PPCgenproof1]
+isfalse_not_istrue [in backend.Values]
+istrue_not_isfalse [in backend.Values]
+is_goto_block_correct [in backend.Tunnelingproof]
+is_label_correct [in backend.PPC]
+is_label_correct [in backend.Mach]
+is_label_correct [in backend.Linear]
+is_move_operation_correct [in backend.Op]
+is_power2_correct [in lib.Integers]
+is_power2_range [in lib.Integers]
+is_power2_rng [in lib.Integers]
+is_tail_cons_left [in backend.Linearizeproof]
+is_tail_exec_instr [in backend.Linearizeproof]
+is_tail_exec_instrs [in backend.Linearizeproof]
+is_tail_find_label [in backend.Linearizeproof]
+is_tail_in [in backend.Linearizeproof]
+iterate_base [in backend.Kildall]
+iterate_incr [in backend.Kildall]
+iterate_solution [in backend.Kildall]
+iterate_step [in backend.Kildall]
+

K

+kill_load_eqs_incl [in backend.CSEproof]
+kill_load_eqs_ops [in backend.CSEproof]
+kill_load_satisfiable [in backend.CSEproof]
+

L

+label_in_lin_block [in backend.Linearizeproof]
+label_in_lin_rec [in backend.Linearizeproof]
+label_pos_code_tail [in backend.PPCgenproof]
+last_app [in backend.Parallelmove]
+last_cons [in backend.Parallelmove]
+last_replace [in backend.Parallelmove]
+length_addr_args [in backend.Allocproof]
+length_app [in backend.Parallelmove]
+length_cond_args [in backend.Allocproof]
+length_op_args [in backend.Allocproof]
+length_replace [in backend.Parallelmove]
+let_fold_args_res [in backend.RTLtyping]
+linearize_block_incl [in backend.Linearizetyping]
+list_append_map [in lib.Coqlib]
+list_disjoint_cons_left [in lib.Coqlib]
+list_disjoint_cons_right [in lib.Coqlib]
+list_disjoint_notin [in lib.Coqlib]
+list_disjoint_sym [in lib.Coqlib]
+list_forall2_imply [in lib.Coqlib]
+list_in_map_inv [in lib.Coqlib]
+list_length_map [in lib.Coqlib]
+list_map_compose [in lib.Coqlib]
+list_map_exten [in lib.Coqlib]
+list_map_norepet [in lib.Coqlib]
+list_map_nth [in lib.Coqlib]
+list_norepet_append [in lib.Coqlib]
+list_norepet_append_left [in lib.Coqlib]
+list_norepet_append_right [in lib.Coqlib]
+list_norepet_dec [in lib.Coqlib]
+loadimm_correct [in backend.PPCgenproof1]
+loadind_aux_correct [in backend.PPCgenproof1]
+loadind_correct [in backend.PPCgenproof1]
+loadv_inject [in backend.Mem]
+loadv_8_signed_unsigned [in backend.PPCgenproof]
+load_agree [in backend.Mem]
+load_alloc_other [in backend.Mem]
+load_alloc_same [in backend.Mem]
+load_contentmap_agree [in backend.Mem]
+load_contents_init [in backend.Mem]
+load_contents_inject [in backend.Mem]
+load_extends [in backend.Mem]
+load_free [in backend.Mem]
+load_freelist [in backend.Cminorgenproof]
+load_from_alloc_is_undef [in backend.Cminorgenproof]
+load_inject [in backend.Mem]
+load_inv [in backend.Mem]
+load_in_bounds [in backend.Mem]
+load_result_idem [in backend.Cminorgenproof]
+load_result_inject [in backend.Mem]
+load_result_normalized [in backend.Cminorgenproof]
+load_result_ty [in backend.Machabstr2mach]
+load_store_contents_mismatch [in backend.Mem]
+load_store_contents_other [in backend.Mem]
+load_store_contents_overlap [in backend.Mem]
+load_store_contents_same [in backend.Mem]
+load_store_other [in backend.Mem]
+load_store_same [in backend.Mem]
+locs_acceptable_disj_temporaries [in backend.Conventions]
+loc_acceptable_noteq_diff [in backend.Allocproof]
+loc_acceptable_notin_notin [in backend.Allocproof]
+loc_arguments_acceptable [in backend.Conventions]
+loc_arguments_bounded [in backend.Conventions]
+loc_arguments_length [in backend.Conventions]
+loc_arguments_norepet [in backend.Conventions]
+loc_arguments_not_temporaries [in backend.Conventions]
+loc_arguments_type [in backend.Conventions]
+loc_is_acceptable_correct [in backend.Coloringproof]
+loc_parameters_not_temporaries [in backend.Conventions]
+loc_parameters_type [in backend.Conventions]
+loc_result_acceptable [in backend.Conventions]
+loc_result_type [in backend.Conventions]
+low_bound_alloc [in backend.Mem]
+low_bound_free [in backend.Mem]
+low_bound_store [in backend.Mem]
+low_high_s [in backend.PPCgenproof1]
+low_high_u [in backend.PPCgenproof1]
+low_high_u_xor [in backend.PPCgenproof1]
+lt_not_eq [in lib.Ordered]
+lt_not_eq [in lib.Ordered]
+lt_not_eq [in lib.Ordered]
+lt_trans [in lib.Ordered]
+lt_trans [in lib.Ordered]
+lt_trans [in lib.Ordered]
+lub_commut [in lib.Lattice]
+lub_commut [in backend.Constprop]
+lub_commut [in lib.Lattice]
+lub_commut [in lib.Sets]
+lub_commut [in lib.Lattice]
+

M

+make_addimm_correct [in backend.Constpropproof]
+make_andimm_correct [in backend.Constpropproof]
+make_cast_correct [in backend.Cminorgenproof]
+make_load_correct [in backend.Cminorgenproof]
+make_mulimm_correct [in backend.Constpropproof]
+make_op_correct [in backend.Cminorgenproof]
+make_orimm_correct [in backend.Constpropproof]
+make_predecessors_correct [in backend.Kildall]
+make_shlimm_correct [in backend.Constpropproof]
+make_shrimm_correct [in backend.Constpropproof]
+make_shruimm_correct [in backend.Constpropproof]
+make_stackaddr_correct [in backend.Cminorgenproof]
+make_store_correct [in backend.Cminorgenproof]
+make_xorimm_correct [in backend.Constpropproof]
+mapped_included_consistent [in backend.RTLtyping]
+mapped_list_included [in backend.RTLtyping]
+map_f_getsrc_getdst [in backend.Alloctyping_aux]
+map_inv [in backend.Allocproof_aux]
+map_wf_incr [in backend.RTLgenproof1]
+match_callstack_alloc_left [in backend.Cminorgenproof]
+match_callstack_alloc_other [in backend.Cminorgenproof]
+match_callstack_alloc_right [in backend.Cminorgenproof]
+match_callstack_alloc_variables [in backend.Cminorgenproof]
+match_callstack_alloc_variables_rec [in backend.Cminorgenproof]
+match_callstack_freelist [in backend.Cminorgenproof]
+match_callstack_freelist_rec [in backend.Cminorgenproof]
+match_callstack_incr_bound [in backend.Cminorgenproof]
+match_callstack_mapped [in backend.Cminorgenproof]
+match_callstack_match_globalenvs [in backend.Cminorgenproof]
+match_callstack_store_above [in backend.Cminorgenproof]
+match_callstack_store_local [in backend.Cminorgenproof]
+match_callstack_store_local_unchanged [in backend.Cminorgenproof]
+match_env_alloc_other [in backend.Cminorgenproof]
+match_env_alloc_same [in backend.Cminorgenproof]
+match_env_empty [in backend.RTLgenproof1]
+match_env_exten [in backend.RTLgenproof1]
+match_env_extensional [in backend.Cminorgenproof]
+match_env_find_reg [in backend.RTLgenproof1]
+match_env_freelist [in backend.Cminorgenproof]
+match_env_invariant [in backend.RTLgenproof1]
+match_env_letvar [in backend.RTLgenproof1]
+match_env_store_above [in backend.Cminorgenproof]
+match_env_store_local [in backend.Cminorgenproof]
+match_env_store_mapped [in backend.Cminorgenproof]
+match_env_update_temp [in backend.RTLgenproof1]
+match_env_update_var [in backend.RTLgenproof1]
+match_globalenvs_init [in backend.Cminorgenproof]
+match_init_env_init_reg [in backend.RTLgenproof1]
+match_set_locals [in backend.RTLgenproof1]
+match_set_params_init_regs [in backend.RTLgenproof1]
+max_over_instrs_bound [in backend.Linearizetyping]
+max_over_list_bound [in backend.Linearizetyping]
+max_over_list_pos [in backend.Lineartyping]
+max_over_regs_of_funct_bound [in backend.Linearizetyping]
+max_over_regs_of_funct_pos [in backend.Lineartyping]
+max_over_slots_of_funct_bound [in backend.Linearizetyping]
+max_over_slots_of_funct_pos [in backend.Lineartyping]
+member_correct [in backend.RTLtyping]
+mem_add_globals_transf [in backend.Globalenvs]
+mem_add_other [in lib.Sets]
+mem_add_same [in lib.Sets]
+mem_add_tail [in backend.InterfGraph]
+mem_empty [in lib.Sets]
+mem_exten [in backend.Mem]
+mem_remove_other [in lib.Sets]
+mem_remove_same [in lib.Sets]
+mem_union [in lib.Sets]
+mkint_eq [in lib.Integers]
+mods_divs [in lib.Integers]
+mods_divs [in backend.Values]
+modulus_pos [in lib.Integers]
+modu_and [in lib.Integers]
+modu_divu [in lib.Integers]
+modu_divu [in backend.Values]
+modu_divu_Euclid [in lib.Integers]
+modu_pow2 [in backend.Values]
+mod_in_range [in lib.Integers]
+mone_max_unsigned [in lib.Integers]
+move_types_res [in backend.Alloctyping_aux]
+move_types_stepf [in backend.Alloctyping_aux]
+mreg_eq [in backend.Locations]
+mreg_is_bounded [in backend.Linearizetyping]
+multiple_predecessors [in backend.Kildall]
+mul_add_distr_l [in lib.Integers]
+mul_add_distr_l [in backend.Values]
+mul_add_distr_r [in lib.Integers]
+mul_add_distr_r [in backend.Values]
+mul_assoc [in lib.Integers]
+mul_assoc [in backend.Values]
+mul_commut [in backend.Values]
+mul_commut [in lib.Integers]
+mul_one [in lib.Integers]
+mul_pow2 [in lib.Integers]
+mul_pow2 [in backend.Values]
+mul_zero [in lib.Integers]
+mutated_reg_in_map [in backend.RTLgenproof1]
+

N

+negate_cmp [in backend.Values]
+negate_cmp [in lib.Integers]
+negate_cmpf_eq [in backend.Values]
+negate_cmpu [in lib.Integers]
+negate_cmpu [in backend.Values]
+negate_cmp_mismatch [in backend.Values]
+neg_add_distr [in backend.Values]
+neg_add_distr [in lib.Integers]
+neg_repr [in lib.Integers]
+neg_zero [in lib.Integers]
+neg_zero [in backend.Values]
+neq_is_neq [in backend.Parallelmove]
+new_reg_fresh [in backend.RTLgenproof1]
+new_reg_incr [in backend.RTLgenproof1]
+new_reg_not_in_map [in backend.RTLgenproof1]
+new_reg_not_mutated [in backend.RTLgenproof1]
+new_reg_return_ok [in backend.RTLgenproof1]
+new_reg_valid [in backend.RTLgenproof1]
+nextinstr_inv [in backend.PPCgenproof1]
+nextinstr_set_preg [in backend.PPCgenproof1]
+non_overlap_diff [in backend.Locations]
+noOverlapaux_insert [in backend.Parallelmove]
+noOverlapaux_swap2 [in backend.Parallelmove]
+noOverlap_auxpop [in backend.Parallelmove]
+noOverlap_auxPop [in backend.Parallelmove]
+noOverlap_aux_app [in backend.Parallelmove]
+noOverlap_Front0 [in backend.Parallelmove]
+noOverlap_head [in backend.Parallelmove]
+noOverlap_insert [in backend.Parallelmove]
+noOverlap_movBack [in backend.Parallelmove]
+noOverlap_movBack0 [in backend.Parallelmove]
+noOverlap_movFront [in backend.Parallelmove]
+noOverlap_nil [in backend.Parallelmove]
+noOverlap_Pop [in backend.Parallelmove]
+noOverlap_pop [in backend.Parallelmove]
+noOverlap_right [in backend.Parallelmove]
+noOverlap_swap [in backend.Parallelmove]
+noO_diff [in backend.Parallelmove]
+noO_list_pnilnil [in backend.Allocproof_aux]
+noRead_app [in backend.Parallelmove]
+noRead_by_path [in backend.Parallelmove]
+norepet_SD [in backend.Allocproof_aux]
+notbool_idem2 [in backend.Values]
+notbool_idem3 [in backend.Values]
+notbool_isfalse_istrue [in lib.Integers]
+notbool_istrue_isfalse [in lib.Integers]
+notbool_is_bool [in backend.Values]
+notbool_negb_1 [in backend.Values]
+notbool_negb_2 [in backend.Values]
+notbool_xor [in backend.Values]
+notindst_nW [in backend.Parallelmove]
+notin_disjoint [in backend.Locations]
+notin_not_in [in backend.Locations]
+noTmpLast_lastnoTmp [in backend.Parallelmove]
+noTmpLast_Pop [in backend.Parallelmove]
+noTmpLast_pop [in backend.Parallelmove]
+noTmpLast_popBack [in backend.Parallelmove]
+noTmpLast_push [in backend.Parallelmove]
+noTmpLast_tmpLast [in backend.Parallelmove]
+noTmpL_diff [in backend.Parallelmove]
+noTmp_app [in backend.Parallelmove]
+noTmp_append [in backend.Parallelmove]
+noTmP_noOverlap_aux [in backend.Parallelmove]
+noTmp_noReadTmp [in backend.Parallelmove]
+noTmp_noTmpLast [in backend.Parallelmove]
+noTmp_pop [in backend.Parallelmove]
+noWrite_in [in backend.Parallelmove]
+noWrite_insert [in backend.Parallelmove]
+noWrite_movFront [in backend.Parallelmove]
+noWrite_pop [in backend.Parallelmove]
+noWrite_swap [in backend.Parallelmove]
+noWrite_tmpLast [in backend.Parallelmove]
+no_overlapD_inv [in backend.Allocproof_aux]
+no_overlapD_invf [in backend.Allocproof_aux]
+no_overlapD_invpp [in backend.Allocproof_aux]
+no_overlapD_res [in backend.Allocproof_aux]
+no_overlap_arguments [in backend.Conventions]
+no_overlap_list_pop [in backend.Allocproof_aux]
+no_overlap_noOverlap [in backend.Parallelmove]
+no_overlap_parameters [in backend.Conventions]
+no_overlap_temp [in backend.Allocproof_aux]
+no_self_loop [in backend.Kildall]
+nth_error_in [in lib.Coqlib]
+nth_error_nil [in lib.Coqlib]
+numbering_holds_exten [in backend.CSEproof]
+

O

+offset_of_index_disj [in backend.Stackingproof]
+offset_of_index_no_overflow [in backend.Stackingproof]
+offset_of_index_valid [in backend.Stackingproof]
+of_bool_is_bool [in backend.Values]
+one_bits_decomp [in lib.Integers]
+one_bits_range [in lib.Integers]
+one_not_zero [in lib.Integers]
+option_sum [in lib.union_find]
+op_strength_reduction_correct [in backend.Constpropproof]
+ordered_pair_charact [in backend.InterfGraph]
+ordered_pair_sym [in backend.InterfGraph]
+orimm_correct [in backend.PPCgenproof1]
+or_assoc [in lib.Integers]
+or_assoc [in backend.Values]
+or_commut [in lib.Integers]
+or_commut [in backend.Values]
+or_idem [in lib.Integers]
+or_mone [in lib.Integers]
+or_of_bool [in backend.Values]
+or_rolm [in lib.Integers]
+or_rolm [in backend.Values]
+or_zero [in lib.Integers]
+outgoing_slot_bound [in backend.Linearizetyping]
+overlap_aux_false_1 [in backend.Locations]
+overlap_aux_true_1 [in backend.Locations]
+overlap_aux_true_2 [in backend.Locations]
+overlap_not_diff [in backend.Locations]
+

P

+parallel_move_correct [in backend.Allocproof]
+parallel_move_correctX [in backend.Allocproof_aux]
+parallel_move_correct' [in backend.Allocproof_aux]
+path_pop [in backend.Parallelmove]
+path_tmpLast [in backend.Parallelmove]
+peq_false [in lib.Coqlib]
+peq_true [in lib.Coqlib]
+pexec_add [in backend.Parallelmove]
+pexec_correct [in backend.Parallelmove]
+pexec_mov [in backend.Parallelmove]
+pexec_movBack [in backend.Parallelmove]
+pexec_movFront [in backend.Parallelmove]
+pexec_nop [in backend.Parallelmove]
+pexec_push [in backend.Parallelmove]
+pexec_swap [in backend.Parallelmove]
+pexec_update [in backend.Parallelmove]
+Ple_refl [in lib.Coqlib]
+Ple_succ [in lib.Coqlib]
+Ple_trans [in lib.Coqlib]
+Plt_ne [in lib.Coqlib]
+Plt_Ple [in lib.Coqlib]
+Plt_Ple_trans [in lib.Coqlib]
+Plt_strict [in lib.Coqlib]
+Plt_succ [in lib.Coqlib]
+Plt_succ_inv [in lib.Coqlib]
+Plt_trans [in lib.Coqlib]
+Plt_trans_succ [in lib.Coqlib]
+Plt_wf [in lib.Coqlib]
+Pmov_equation [in backend.Parallelmove]
+positive_Peano_ind [in lib.Coqlib]
+positive_rec_base [in lib.Coqlib]
+positive_rec_succ [in lib.Coqlib]
+Ppred_Plt [in lib.Coqlib]
+predecessors_correct [in backend.Kildall]
+preg_eq [in backend.PPC]
+preg_of_injective [in backend.PPCgenproof1]
+preg_of_is_data_reg [in backend.PPCgenproof1]
+preg_of_not [in backend.PPCgenproof1]
+preg_of_not_GPR1 [in backend.PPCgenproof1]
+preg_val [in backend.PPCgenproof1]
+program_typing_preserved [in backend.Tunnelingtyping]
+program_typing_preserved [in backend.Linearizetyping]
+program_typing_preserved [in backend.Alloctyping]
+program_typing_preserved [in backend.Stackingtyping]
+prog_funct_transf_OK [in backend.Globalenvs]
+propagate_successors_charact1 [in backend.Kildall]
+propagate_successors_charact2 [in backend.Kildall]
+propagate_successors_invariant [in backend.Kildall]
+propagate_successors_P [in backend.Kildall]
+propagate_succ_charact [in backend.Kildall]
+propagate_succ_incr [in backend.Kildall]
+propagate_succ_incr_worklist [in backend.Kildall]
+propagate_succ_list_charact [in backend.Kildall]
+propagate_succ_list_incr [in backend.Kildall]
+propagate_succ_list_incr_worklist [in backend.Kildall]
+propagate_succ_list_records_changes [in backend.Kildall]
+propagate_succ_records_changes [in backend.Kildall]
+

R

+reachable_correct_1 [in backend.Linearizeproof]
+reachable_correct_2 [in backend.Linearizeproof]
+reachable_entrypoint [in backend.Linearizeproof]
+reachable_successors [in backend.Linearizeproof]
+rebuild_l [in backend.Parallelmove]
+refl_ge [in backend.CSE]
+regalloc_acceptable [in backend.Coloringproof]
+regalloc_correct_1 [in backend.Coloringproof]
+regalloc_correct_2 [in backend.Coloringproof]
+regalloc_correct_3 [in backend.Coloringproof]
+regalloc_disj_temporaries [in backend.Allocproof]
+regalloc_norepet_norepet [in backend.Allocproof]
+regalloc_noteq_diff [in backend.Allocproof]
+regalloc_notin_notin [in backend.Allocproof]
+regalloc_not_temporary [in backend.Allocproof]
+regalloc_ok [in backend.Coloringproof]
+regalloc_preserves_types [in backend.Coloringproof]
+register_classification [in backend.Conventions]
+regsalloc_acceptable [in backend.Coloringproof]
+regs_match_approx_increasing [in backend.Constpropproof]
+regs_match_approx_update [in backend.Constpropproof]
+reg_for_spec [in backend.Allocproof]
+reg_fresh_decr [in backend.RTLgenproof1]
+reg_in_map_valid [in backend.RTLgenproof1]
+reg_valid_incr [in backend.RTLgenproof1]
+reg_valnum_correct [in backend.CSEproof]
+remove_all_leaves_sound [in lib.Inclusion]
+repet_correct [in backend.RTLtyping]
+replace_last_id [in backend.Parallelmove]
+repr_aux_canon [in lib.union_find]
+repr_aux_none [in lib.union_find]
+repr_aux_some [in lib.union_find]
+repr_empty [in lib.union_find]
+repr_rec_ext [in lib.union_find]
+repr_repr [in lib.union_find]
+repr_signed [in lib.Integers]
+repr_unsigned [in lib.Integers]
+reserve_instr_incr [in backend.RTLgenproof1]
+reserve_instr_wf [in backend.RTLgen]
+restore_callee_save_correct [in backend.Stackingproof]
+restore_float_callee_save_correct [in backend.Stackingproof]
+restore_float_callee_save_correct_rec [in backend.Stackingproof]
+restore_int_callee_save_correct [in backend.Stackingproof]
+restore_int_callee_save_correct_rec [in backend.Stackingproof]
+return_regs_not_destroyed [in backend.Allocproof]
+return_regs_result [in backend.Allocproof]
+return_reg_ok_incr [in backend.RTLgenproof1]
+rleaf [in lib.Maps]
+rolm_rolm [in lib.Integers]
+rolm_rolm [in backend.Values]
+rolm_zero [in lib.Integers]
+rolm_zero [in backend.Values]
+rol_and [in lib.Integers]
+rol_or [in lib.Integers]
+rol_rol [in lib.Integers]
+rol_zero [in lib.Integers]
+

S

+sameclass_empty [in lib.union_find]
+sameclass_identify_1 [in lib.union_find]
+sameclass_identify_2 [in lib.union_find]
+sameclass_refl [in lib.union_find]
+sameclass_repr [in lib.union_find]
+sameclass_sym [in lib.union_find]
+sameclass_trans [in lib.union_find]
+sameExec_reflexive [in backend.Parallelmove]
+sameExec_transitive [in backend.Parallelmove]
+same_not_diff [in backend.Locations]
+same_typ_correct [in backend.Coloringproof]
+save_callee_save_correct [in backend.Stackingproof]
+save_float_callee_save_correct [in backend.Stackingproof]
+save_float_callee_save_correct_rec [in backend.Stackingproof]
+save_int_callee_save_correct [in backend.Stackingproof]
+save_int_callee_save_correct_rec [in backend.Stackingproof]
+SB_Pmov [in backend.Parallelmove]
+SDone_Pmov [in backend.Allocproof_aux]
+SDone_stepf [in backend.Allocproof_aux]
+sD_nW [in backend.Parallelmove]
+sD_pexec [in backend.Parallelmove]
+setN_agree [in backend.Mem]
+setN_inject [in backend.Mem]
+setN_outside_agree [in backend.Mem]
+setN_outside_inject [in backend.Mem]
+set_cont_agree [in backend.Mem]
+set_cont_inject [in backend.Mem]
+set_cont_inside [in backend.Mem]
+set_cont_outside [in backend.Mem]
+set_cont_outside1 [in backend.Mem]
+set_cont_outside_agree [in backend.Mem]
+set_cont_outside_inject [in backend.Mem]
+set_locals_defined [in backend.Cminorgenproof]
+set_locals_params_defined [in backend.Cminorgenproof]
+set_params_defined [in backend.Cminorgenproof]
+set_slot_index [in backend.Stackingproof]
+set_slot_link_invariant [in backend.Machtyping]
+set_slot_ok [in backend.Stackingproof]
+shift_eval_addressing [in backend.Stackingproof]
+shift_eval_operation [in backend.Stackingproof]
+shl_mul [in backend.Values]
+shl_mul [in lib.Integers]
+shl_mul_two_p [in lib.Integers]
+shl_rolm [in lib.Integers]
+shl_rolm [in backend.Values]
+shl_zero [in lib.Integers]
+shru_div_two_p [in lib.Integers]
+shru_rolm [in backend.Values]
+shru_rolm [in lib.Integers]
+shru_zero [in lib.Integers]
+shrx_carry [in backend.Values]
+shrx_carry [in lib.Integers]
+shr_zero [in lib.Integers]
+signed_range [in lib.Integers]
+signed_repr [in lib.Integers]
+sig_function_translated [in backend.Allocproof]
+sig_transl_function [in backend.Cminorgenproof]
+simpleDest_insert [in backend.Parallelmove]
+simpleDest_movBack [in backend.Parallelmove]
+simpleDest_movFront [in backend.Parallelmove]
+simpleDest_Pop [in backend.Parallelmove]
+simpleDest_pop [in backend.Parallelmove]
+simpleDest_pop2 [in backend.Parallelmove]
+simpleDest_right [in backend.Parallelmove]
+simpleDest_swap [in backend.Parallelmove]
+simpleDest_swap_app [in backend.Parallelmove]
+simpleDest_tmpLast [in backend.Parallelmove]
+size_arguments_bound [in backend.Linearizetyping]
+size_chunk_pos [in backend.Mem]
+size_mem_pos [in backend.Mem]
+size_no_overflow [in backend.Stackingproof]
+size_pos [in backend.Stackingproof]
+slot_eq [in backend.Locations]
+slot_gi [in backend.Stackingproof]
+slot_gso [in backend.Stackingproof]
+slot_gss [in backend.Stackingproof]
+slot_iso [in backend.Stackingproof]
+slot_iss [in backend.Stackingproof]
+slot_is_bounded [in backend.Linearizetyping]
+sort_included [in lib.Inclusion]
+sort_included2 [in lib.Inclusion]
+splitNone [in backend.Parallelmove]
+splitSome [in backend.Parallelmove]
+split_length [in backend.Parallelmove]
+split_move_incl [in backend.Alloctyping_aux]
+sp_val [in backend.PPCgenproof1]
+srcdst_tmp2_stepf [in backend.Alloctyping_aux]
+src_tmp2_res [in backend.Alloctyping_aux]
+starts_with_correct [in backend.Linearizeproof]
+start_state_good [in backend.Kildall]
+start_state_in_entry [in backend.Kildall]
+state_incr_extends [in backend.RTLgenproof1]
+state_incr_refl [in backend.RTLgenproof1]
+state_incr_trans [in backend.RTLgenproof1]
+state_incr_trans2 [in backend.RTLgenproof1]
+state_incr_trans3 [in backend.RTLgenproof1]
+state_incr_trans4 [in backend.RTLgenproof1]
+state_incr_trans5 [in backend.RTLgenproof1]
+state_incr_trans6 [in backend.RTLgenproof1]
+stepf1_dec [in backend.Parallelmove]
+stepf_dec [in backend.Parallelmove]
+stepf_dec0 [in backend.Parallelmove]
+stepf_dec0' [in backend.Parallelmove]
+stepf_pop [in backend.Parallelmove]
+stepf_popLoop [in backend.Parallelmove]
+stepInv_pnilnil [in backend.Allocproof_aux]
+stepp_inv [in backend.Parallelmove]
+stepp_sameExec [in backend.Parallelmove]
+stepp_transitive [in backend.Parallelmove]
+step1 [in backend.RTLtyping]
+step2 [in backend.RTLtyping]
+step3 [in backend.RTLtyping]
+step4 [in backend.RTLtyping]
+step_dec [in backend.Parallelmove]
+step_dec0 [in backend.Parallelmove]
+step_inv [in backend.Parallelmove]
+step_inv_getdst [in backend.Parallelmove]
+step_inv_loop [in backend.Parallelmove]
+step_inv_loop_aux [in backend.Parallelmove]
+step_inv_noOverlap [in backend.Parallelmove]
+step_inv_NoOverlap [in backend.Parallelmove]
+step_inv_noTmp [in backend.Parallelmove]
+step_inv_noTmpLast [in backend.Parallelmove]
+step_inv_path [in backend.Parallelmove]
+step_inv_simpleDest [in backend.Parallelmove]
+step_sameExec [in backend.Parallelmove]
+step_state_good [in backend.Kildall]
+step_stepp [in backend.Parallelmove]
+stmt_stmtlist_ind [in backend.RTLgenproof1]
+STM_Pmov [in backend.Parallelmove]
+storeind_aux_correct [in backend.PPCgenproof1]
+storeind_correct [in backend.PPCgenproof1]
+storev_mapped_inject [in backend.Mem]
+storev_mapped_inject_1 [in backend.Mem]
+storev_16_signed_unsigned [in backend.PPCgenproof]
+storev_8_signed_unsigned [in backend.PPCgenproof]
+store_agree [in backend.Mem]
+store_alloc [in backend.Mem]
+store_contentmap_agree [in backend.Mem]
+store_contentmap_outside_agree [in backend.Mem]
+store_contents_inject [in backend.Mem]
+store_contents_outside_inject [in backend.Mem]
+store_inv [in backend.Mem]
+store_in_bounds [in backend.Mem]
+store_is_in_bounds [in backend.Mem]
+store_mapped_inject [in backend.Mem]
+store_mapped_inject_1 [in backend.Mem]
+store_outside_agree [in backend.Mem]
+store_outside_extends [in backend.Mem]
+store_parameters_correct [in backend.Cminorgenproof]
+store_unmapped_inject [in backend.Mem]
+store_within_extends [in backend.Mem]
+subject_reduction [in backend.Machtyping]
+subject_reduction [in backend.RTLtyping]
+subject_reduction_function [in backend.Machtyping]
+subject_reduction_instr [in backend.Machtyping]
+subject_reduction_instrs [in backend.Machtyping]
+sub_add_l [in backend.Values]
+sub_add_l [in lib.Integers]
+sub_add_opp [in lib.Integers]
+sub_add_opp [in backend.Values]
+sub_add_r [in backend.Values]
+sub_add_r [in lib.Integers]
+sub_idem [in lib.Integers]
+sub_shifted [in lib.Integers]
+sub_zero_l [in lib.Integers]
+sub_zero_r [in backend.Values]
+sub_zero_r [in lib.Integers]
+successors_aux_invariant [in backend.LTL]
+successors_correct [in backend.LTL]
+successors_correct [in backend.RTL]
+swap_cmp [in lib.Integers]
+swap_cmp [in backend.Values]
+swap_cmpu [in backend.Values]
+swap_cmpu [in lib.Integers]
+swap_cmp_mismatch [in backend.Values]
+symbols_add_globals_transf [in backend.Globalenvs]
+symbols_init_transf [in backend.Globalenvs]
+symbols_preserved [in backend.Tunnelingproof]
+symbols_preserved [in backend.Allocproof]
+symbols_preserved [in backend.Cminorgenproof]
+symbols_preserved [in backend.Constpropproof]
+symbols_preserved [in backend.PPCgenproof]
+symbols_preserved [in backend.RTLgenproof]
+symbols_preserved [in backend.Linearizeproof]
+symbols_preserved [in backend.CSEproof]
+symbols_preserved [in backend.Stackingproof]
+

T

+target_regs_not_mutated [in backend.RTLgenproof1]
+target_regs_ok_incr [in backend.RTLgenproof1]
+target_regs_valid [in backend.RTLgenproof1]
+target_reg_not_mutated [in backend.RTLgenproof1]
+target_reg_ok_incr [in backend.RTLgenproof1]
+target_reg_valid [in backend.RTLgenproof1]
+temporaries_not_acceptable [in backend.Conventions]
+teq_correct [in backend.RTLtyping]
+test_inclusion_sound [in lib.Inclusion]
+top_ge [in backend.CSE]
+transfer_correct [in backend.Constpropproof]
+transfer_correct [in backend.CSEproof]
+transform_partial_program_compose [in backend.Main]
+transform_partial_program_function [in backend.AST]
+transform_partial_program_main [in backend.AST]
+transform_program_function [in backend.AST]
+transform_program_partial_total [in backend.Main]
+transform_program_transform_partial_program [in backend.Globalenvs]
+transf_cminor_program2_correct [in backend.Main]
+transf_cminor_program_correct [in backend.Main]
+transf_cminor_program_equiv [in backend.Main]
+transf_code_wf [in backend.CSE]
+transf_code_wf [in backend.Constprop]
+transf_code_wf [in backend.RTL]
+transf_csharpminor_program2_correct [in backend.Main]
+transf_csharpminor_program_correct [in backend.Main]
+transf_csharpminor_program_equiv [in backend.Main]
+transf_entrypoint_correct [in backend.Allocproof]
+transf_entrypoint_wf [in backend.Allocation]
+transf_function_correct [in backend.Linearizeproof]
+transf_function_correct [in backend.PPCgenproof]
+transf_function_correct [in backend.Stackingproof]
+transf_function_correct [in backend.CSEproof]
+transf_funct_correct [in backend.Constpropproof]
+transf_partial_program_compose [in backend.Main]
+transf_program_correct [in backend.Linearizeproof]
+transf_program_correct [in backend.Tunnelingproof]
+transf_program_correct [in backend.Constpropproof]
+transf_program_correct [in backend.PPCgenproof]
+transf_program_correct [in backend.CSEproof]
+transf_program_partial_total [in backend.Main]
+transf_program_transf_partial_program [in backend.Globalenvs]
+translate_cmp [in lib.Integers]
+translate_eq [in lib.Integers]
+translate_lt [in lib.Integers]
+transl_code_label [in backend.PPCgenproof]
+transl_condition_CEcondition_correct [in backend.RTLgenproof]
+transl_condition_CEcond_correct [in backend.RTLgenproof]
+transl_condition_CEfalse_correct [in backend.RTLgenproof]
+transl_condition_CEtrue_correct [in backend.RTLgenproof]
+transl_condition_incr [in backend.RTLgenproof1]
+transl_cond_correct [in backend.PPCgenproof1]
+transl_cond_correct_aux [in backend.PPCgenproof1]
+transl_exprlist_Econs_correct [in backend.Cminorgenproof]
+transl_exprlist_Econs_correct [in backend.RTLgenproof]
+transl_exprlist_Enil_correct [in backend.RTLgenproof]
+transl_exprlist_Enil_correct [in backend.Cminorgenproof]
+transl_exprlist_incr [in backend.RTLgenproof1]
+transl_expr_condition_exprlist_incr [in backend.RTLgenproof1]
+transl_expr_Eaddrof_global_correct [in backend.Cminorgenproof]
+transl_expr_Eaddrof_local_correct [in backend.Cminorgenproof]
+transl_expr_Eassign_correct [in backend.Cminorgenproof]
+transl_expr_Eassign_correct [in backend.RTLgenproof]
+transl_expr_Ecall_correct [in backend.RTLgenproof]
+transl_expr_Ecall_correct [in backend.Cminorgenproof]
+transl_expr_Econdition_correct [in backend.RTLgenproof]
+transl_expr_Econdition_false_correct [in backend.Cminorgenproof]
+transl_expr_Econdition_true_correct [in backend.Cminorgenproof]
+transl_expr_Eletvar_correct [in backend.RTLgenproof]
+transl_expr_Eletvar_correct [in backend.Cminorgenproof]
+transl_expr_Elet_correct [in backend.Cminorgenproof]
+transl_expr_Elet_correct [in backend.RTLgenproof]
+transl_expr_Eload_correct [in backend.RTLgenproof]
+transl_expr_Eload_correct [in backend.Cminorgenproof]
+transl_expr_Eop_correct [in backend.RTLgenproof]
+transl_expr_Eop_correct [in backend.Cminorgenproof]
+transl_expr_Estore_correct [in backend.RTLgenproof]
+transl_expr_Estore_correct [in backend.Cminorgenproof]
+transl_expr_Evar_correct [in backend.Cminorgenproof]
+transl_expr_Evar_correct [in backend.RTLgenproof]
+transl_expr_incr [in backend.RTLgenproof1]
+transl_find_label [in backend.PPCgenproof]
+transl_find_label [in backend.Stackingproof]
+transl_funcall_correct [in backend.Cminorgenproof]
+transl_funcall_correct [in backend.RTLgenproof]
+transl_function_correct [in backend.Allocproof]
+transl_function_correct [in backend.Cminorgenproof]
+transl_function_correctness [in backend.Allocproof]
+transl_function_correctness [in backend.RTLgenproof]
+transl_Icall_correct [in backend.Allocproof]
+transl_Icond_false_correct [in backend.Allocproof]
+transl_Icond_true_correct [in backend.Allocproof]
+transl_Iload_correct [in backend.Allocproof]
+transl_Inop_correct [in backend.Allocproof]
+transl_instr_label [in backend.PPCgenproof]
+transl_Iop_correct [in backend.Allocproof]
+transl_Istore_correct [in backend.Allocproof]
+transl_load_correct [in backend.PPCgenproof1]
+transl_load_store_correct [in backend.PPCgenproof1]
+transl_one_correct [in backend.Allocproof]
+transl_op_correct [in backend.PPCgenproof1]
+transl_program_correct [in backend.RTLgenproof]
+transl_program_correct [in backend.Stackingproof]
+transl_program_correct [in backend.Allocproof]
+transl_program_correct [in backend.Cminorgenproof]
+transl_refl_correct [in backend.Allocproof]
+transl_stmtlist_incr [in backend.RTLgenproof1]
+transl_stmtlist_Scons_continue_correct [in backend.RTLgenproof]
+transl_stmtlist_Scons_stop_correct [in backend.RTLgenproof]
+transl_stmtlist_Scons_1_correct [in backend.Cminorgenproof]
+transl_stmtlist_Scons_2_correct [in backend.Cminorgenproof]
+transl_stmtlist_Snil_correct [in backend.RTLgenproof]
+transl_stmtlist_Snil_correct [in backend.Cminorgenproof]
+transl_stmt_incr [in backend.RTLgenproof1]
+transl_stmt_Sblock_correct [in backend.RTLgenproof]
+transl_stmt_Sblock_correct [in backend.Cminorgenproof]
+transl_stmt_Sexit_correct [in backend.RTLgenproof]
+transl_stmt_Sexit_correct [in backend.Cminorgenproof]
+transl_stmt_Sexpr_correct [in backend.RTLgenproof]
+transl_stmt_Sexpr_correct [in backend.Cminorgenproof]
+transl_stmt_Sifthenelse_correct [in backend.RTLgenproof]
+transl_stmt_Sifthenelse_false_correct [in backend.Cminorgenproof]
+transl_stmt_Sifthenelse_true_correct [in backend.Cminorgenproof]
+transl_stmt_Sloop_exit_correct [in backend.Cminorgenproof]
+transl_stmt_Sloop_loop_correct [in backend.Cminorgenproof]
+transl_stmt_Sloop_loop_correct [in backend.RTLgenproof]
+transl_stmt_Sloop_stop_correct [in backend.RTLgenproof]
+transl_stmt_Sreturn_none_correct [in backend.Cminorgenproof]
+transl_stmt_Sreturn_none_correct [in backend.RTLgenproof]
+transl_stmt_Sreturn_some_correct [in backend.RTLgenproof]
+transl_stmt_Sreturn_some_correct [in backend.Cminorgenproof]
+transl_stmt_stmtlist_incr [in backend.RTLgenproof1]
+transl_store_correct [in backend.PPCgenproof1]
+transl_trans_correct [in backend.Allocproof]
+tunnel_function_correct [in backend.Tunnelingproof]
+two_power_nat_O [in lib.Coqlib]
+two_power_nat_pos [in lib.Coqlib]
+typesize_pos [in backend.Locations]
+type_args_complete [in backend.RTLtyping]
+type_args_correct [in backend.RTLtyping]
+type_args_extends [in backend.RTLtyping]
+type_args_included [in backend.RTLtyping]
+type_args_mapped [in backend.RTLtyping]
+type_args_res_complete [in backend.RTLtyping]
+type_args_res_included [in backend.RTLtyping]
+type_args_res_ros_included [in backend.RTLtyping]
+type_arg_complete [in backend.RTLtyping]
+type_arg_correct [in backend.RTLtyping]
+type_arg_correct_1 [in backend.RTLtyping]
+type_arg_extends [in backend.RTLtyping]
+type_arg_included [in backend.RTLtyping]
+type_arg_mapped [in backend.RTLtyping]
+type_instrs_extends [in backend.RTLtyping]
+type_instrs_included [in backend.RTLtyping]
+type_instr_included [in backend.RTLtyping]
+type_of_chunk_correct [in backend.Op]
+type_of_operation_sound [in backend.Op]
+type_res_complete [in backend.RTLtyping]
+type_res_correct [in backend.RTLtyping]
+type_ros_complete [in backend.RTLtyping]
+type_ros_correct [in backend.RTLtyping]
+type_rtl_function_correct [in backend.RTLtyping]
+type_rtl_function_instrs [in backend.RTLtyping]
+type_rtl_function_norepet [in backend.RTLtyping]
+type_rtl_function_params [in backend.RTLtyping]
+T_type [in backend.Alloctyping_aux]
+

U

+undef_is_bool [in backend.Values]
+unfold_transf_function [in backend.Stackingproof]
+unique_labels_lin_block [in backend.Linearizeproof]
+unique_labels_lin_function [in backend.Linearizeproof]
+unique_labels_lin_rec [in backend.Linearizeproof]
+unroll_positive_rec [in lib.Coqlib]
+unsigned_range [in lib.Integers]
+unsigned_range_2 [in lib.Integers]
+unsigned_repr [in lib.Integers]
+unsplit_move [in backend.Parallelmove]
+update_instr_extends [in backend.RTLgenproof1]
+update_instr_incr [in backend.RTLgenproof1]
+update_instr_wf [in backend.RTLgen]
+update_o [in backend.Mem]
+update_s [in backend.Mem]
+

V

+valid_block_alloc [in backend.Mem]
+valid_block_free [in backend.Mem]
+valid_block_store [in backend.Mem]
+valid_fresh_absurd [in backend.RTLgenproof1]
+valid_fresh_different [in backend.RTLgenproof1]
+valid_new_block [in backend.Mem]
+valid_not_valid_diff [in backend.Mem]
+valid_pointer_inject_no_overflow [in backend.Mem]
+valnum_regs_holds [in backend.CSEproof]
+valnum_reg_holds [in backend.CSEproof]
+valu_agree_list [in backend.CSEproof]
+valu_agree_refl [in backend.CSEproof]
+valu_agree_trans [in backend.CSEproof]
+val_content_inject_cast [in backend.Cminorgenproof]
+val_content_inject_incr [in backend.Mem]
+val_inject_incr [in backend.Mem]
+val_list_inject_incr [in backend.Mem]
+val_match_approx_increasing [in backend.Constpropproof]
+vars_vals_match_extensional [in backend.Cminorgenproof]
+vars_vals_match_holds [in backend.Cminorgenproof]
+vars_vals_match_holds_1 [in backend.Cminorgenproof]
+var_addr_global_correct [in backend.Cminorgenproof]
+var_addr_local_correct [in backend.Cminorgenproof]
+var_get_correct [in backend.Cminorgenproof]
+var_set_correct [in backend.Cminorgenproof]
+

W

+wf_add_load [in backend.CSEproof]
+wf_add_op [in backend.CSEproof]
+wf_add_rhs [in backend.CSEproof]
+wf_analyze [in backend.CSEproof]
+wf_empty [in lib.union_find]
+wf_empty_numbering [in backend.CSEproof]
+wf_equation_increasing [in backend.CSEproof]
+wf_kill_loads [in backend.CSEproof]
+wf_rhs_increasing [in backend.CSEproof]
+wf_transfer [in backend.CSEproof]
+wf_tunneled_code [in backend.Tunneling]
+wf_valnum_reg [in backend.CSEproof]
+wf_valnum_regs [in backend.CSEproof]
+wt_add_call [in backend.Alloctyping]
+wt_add_cond [in backend.Alloctyping]
+wt_add_entry [in backend.Alloctyping]
+wt_add_load [in backend.Alloctyping]
+wt_add_move [in backend.Alloctyping]
+wt_add_moves [in backend.Alloctyping_aux]
+wt_add_op_move [in backend.Alloctyping]
+wt_add_op_others [in backend.Alloctyping]
+wt_add_op_undef [in backend.Alloctyping]
+wt_add_reload [in backend.Alloctyping]
+wt_add_reloads [in backend.Alloctyping]
+wt_add_return [in backend.Alloctyping]
+wt_add_spill [in backend.Alloctyping]
+wt_add_store [in backend.Alloctyping]
+wt_add_undefs [in backend.Alloctyping]
+wt_fold_right [in backend.Stackingtyping]
+wt_get_slot [in backend.Machtyping]
+wt_init_frame [in backend.Machtyping]
+wt_init_regs [in backend.RTLtyping]
+wt_instrs_cons [in backend.Stackingtyping]
+wt_linearize_block [in backend.Linearizetyping]
+wt_linearize_body [in backend.Linearizetyping]
+wt_Msetstack' [in backend.Stackingtyping]
+wt_parallel_move [in backend.Alloctyping]
+wt_parallel_moveX [in backend.Alloctyping_aux]
+wt_parallel_move' [in backend.Alloctyping_aux]
+wt_regset_assign [in backend.RTLtyping]
+wt_regset_list [in backend.RTLtyping]
+wt_regs_for [in backend.Alloctyping]
+wt_regs_for_rec [in backend.Alloctyping]
+wt_reg_for [in backend.Alloctyping]
+wt_restore_callee_save [in backend.Stackingtyping]
+wt_restore_float_callee_save [in backend.Stackingtyping]
+wt_restore_int_callee_save [in backend.Stackingtyping]
+wt_rtl_function [in backend.Alloctyping]
+wt_save_callee_save [in backend.Stackingtyping]
+wt_save_float_callee_save [in backend.Stackingtyping]
+wt_save_int_callee_save [in backend.Stackingtyping]
+wt_setreg [in backend.Machtyping]
+wt_set_slot [in backend.Machtyping]
+wt_transf_entrypoint [in backend.Alloctyping]
+wt_transf_function [in backend.Stackingtyping]
+wt_transf_function [in backend.Alloctyping]
+wt_transf_function [in backend.Linearizetyping]
+wt_transf_instr [in backend.Alloctyping]
+wt_transf_instrs [in backend.Alloctyping]
+wt_transl_instr [in backend.Stackingtyping]
+wt_tunnel_block [in backend.Tunnelingtyping]
+wt_tunnel_function [in backend.Tunnelingtyping]
+

X

+xcombine_lr [in lib.Maps]
+xelements_complete [in lib.Maps]
+xelements_correct [in lib.Maps]
+xelements_hi [in lib.Maps]
+xelements_ho [in lib.Maps]
+xelements_ih [in lib.Maps]
+xelements_ii [in lib.Maps]
+xelements_io [in lib.Maps]
+xelements_keys_norepet [in lib.Maps]
+xelements_oh [in lib.Maps]
+xelements_oi [in lib.Maps]
+xelements_oo [in lib.Maps]
+xgcombine [in lib.Maps]
+xgcombine_l [in lib.Maps]
+xgcombine_r [in lib.Maps]
+xget_left [in lib.Maps]
+xgmap [in lib.Maps]
+xorimm_correct [in backend.PPCgenproof1]
+xor_assoc [in lib.Integers]
+xor_assoc [in backend.Values]
+xor_commut [in backend.Values]
+xor_commut [in lib.Integers]
+xor_one_one [in lib.Integers]
+xor_zero [in lib.Integers]
+xor_zero_one [in lib.Integers]
+

Z

+Zdiv_small [in lib.Coqlib]
+Zdiv_unique [in lib.Coqlib]
+zeq_false [in lib.Coqlib]
+zeq_true [in lib.Coqlib]
+zle_false [in lib.Coqlib]
+zle_true [in lib.Coqlib]
+zlt_false [in lib.Coqlib]
+zlt_true [in lib.Coqlib]
+Zmax_bound_l [in lib.Coqlib]
+Zmax_bound_r [in lib.Coqlib]
+Zmax_spec [in lib.Coqlib]
+Zmin_spec [in lib.Coqlib]
+Zmod_small [in lib.Coqlib]
+Zmod_unique [in lib.Coqlib]
+Z_bin_decomp_range [in lib.Integers]
+Z_bin_decomp_shift_add [in lib.Integers]
+Z_of_bits_excl [in lib.Integers]
+Z_of_bits_exten [in lib.Integers]
+Z_of_bits_of_Z [in lib.Integers]
+Z_of_bits_range [in lib.Integers]
+Z_of_bits_range_2 [in lib.Integers]
+Z_of_bits_shift [in lib.Integers]
+Z_of_bits_shifts [in lib.Integers]
+Z_of_bits_shifts_rev [in lib.Integers]
+Z_of_bits_shift_rev [in lib.Integers]
+Z_one_bits_powerserie [in lib.Integers]
+Z_one_bits_range [in lib.Integers]
+Z_shift_add_bin_decomp [in lib.Integers]
+Z_shift_add_inj [in lib.Integers]
+

+

Constructor Index

+

A

+Abased [in backend.Op]
+addf_case1 [in backend.Cmconstr]
+addf_case2 [in backend.Cmconstr]
+addf_default [in backend.Cmconstr]
+addimm_case1 [in backend.Cmconstr]
+addimm_case2 [in backend.Cmconstr]
+addimm_case3 [in backend.Cmconstr]
+addimm_case4 [in backend.Cmconstr]
+addimm_default [in backend.Cmconstr]
+addressing_case1 [in backend.Cmconstr]
+addressing_case2 [in backend.Cmconstr]
+addressing_case3 [in backend.Cmconstr]
+addressing_case4 [in backend.Cmconstr]
+addressing_case5 [in backend.Cmconstr]
+addressing_default [in backend.Cmconstr]
+addr_strength_reduction_case1 [in backend.Constprop]
+addr_strength_reduction_case2 [in backend.Constprop]
+addr_strength_reduction_case3 [in backend.Constprop]
+addr_strength_reduction_default [in backend.Constprop]
+add_case1 [in backend.Cmconstr]
+add_case2 [in backend.Cmconstr]
+add_case3 [in backend.Cmconstr]
+add_case4 [in backend.Cmconstr]
+add_case5 [in backend.Cmconstr]
+add_default [in backend.Cmconstr]
+Aglobal [in backend.Op]
+Aindexed [in backend.Op]
+Aindexed2 [in backend.Op]
+Ainstack [in backend.Op]
+alloc_variables_cons [in backend.Csharpminor]
+alloc_variables_nil [in backend.Csharpminor]
+

B

+Bcall [in backend.LTL]
+Bcond [in backend.LTL]
+Bgetstack [in backend.LTL]
+Bgoto [in backend.LTL]
+bind_parameters_cons [in backend.Csharpminor]
+bind_parameters_nil [in backend.Csharpminor]
+Bload [in backend.LTL]
+bool_of_val_int_true [in backend.Values]
+Bop [in backend.LTL]
+Bot [in lib.Lattice]
+Bot_except [in lib.Lattice]
+Breturn [in backend.LTL]
+Bsetstack [in backend.LTL]
+Bstore [in backend.LTL]
+

C

+callstack_dom_cons [in backend.Machabstr2mach]
+callstack_dom_nil [in backend.Machabstr2mach]
+callstack_linked_cons [in backend.Machabstr2mach]
+callstack_linked_nil [in backend.Machabstr2mach]
+callstack_linked_one [in backend.Machabstr2mach]
+CARRY [in backend.PPC]
+Ccomp [in backend.Op]
+Ccompf [in backend.Op]
+Ccompimm [in backend.Op]
+Ccompu [in backend.Op]
+Ccompuimm [in backend.Op]
+CEcond [in backend.Cminor]
+CEcondition [in backend.Cminor]
+CEfalse [in backend.Cminor]
+Ceq [in backend.AST]
+CEtrue [in backend.Cminor]
+Cge [in backend.AST]
+Cgt [in backend.AST]
+Cint [in backend.PPC]
+Cle [in backend.AST]
+Clt [in backend.AST]
+Cmasknotzero [in backend.Op]
+Cmaskzero [in backend.Op]
+Cne [in backend.AST]
+Cnotcompf [in backend.Op]
+Cont [in backend.LTL]
+Cont [in backend.Mem]
+content_inject_cont [in backend.Mem]
+content_inject_datum16 [in backend.Mem]
+content_inject_datum32 [in backend.Mem]
+content_inject_datum64 [in backend.Mem]
+content_inject_datum8 [in backend.Mem]
+content_inject_undef [in backend.Mem]
+CRbit_0 [in backend.PPC]
+CRbit_1 [in backend.PPC]
+CRbit_2 [in backend.PPC]
+CRbit_3 [in backend.PPC]
+CR0_0 [in backend.PPC]
+CR0_1 [in backend.PPC]
+CR0_2 [in backend.PPC]
+CR0_3 [in backend.PPC]
+csr_case1 [in backend.Constprop]
+csr_case2 [in backend.Constprop]
+csr_default [in backend.Constprop]
+Csymbol_high_signed [in backend.PPC]
+Csymbol_high_unsigned [in backend.PPC]
+Csymbol_low_signed [in backend.PPC]
+Csymbol_low_unsigned [in backend.PPC]
+CTR [in backend.PPC]
+

D

+Datum16 [in backend.Mem]
+Datum32 [in backend.Mem]
+Datum64 [in backend.Mem]
+Datum8 [in backend.Mem]
+divu_case1 [in backend.Cmconstr]
+divu_default [in backend.Cmconstr]
+dstepp_refl [in backend.Parallelmove]
+dstepp_trans [in backend.Parallelmove]
+dstep_nop [in backend.Parallelmove]
+dstep_pop [in backend.Parallelmove]
+dstep_pop_loop [in backend.Parallelmove]
+dstep_push [in backend.Parallelmove]
+dstep_start [in backend.Parallelmove]
+

E

+Eaddrof [in backend.Csharpminor]
+Eassign [in backend.Cminor]
+Eassign [in backend.Csharpminor]
+Ecall [in backend.Csharpminor]
+Ecall [in backend.Cminor]
+Econdition [in backend.Csharpminor]
+Econdition [in backend.Cminor]
+Econs [in backend.Cminor]
+Econs [in backend.Csharpminor]
+Elet [in backend.Csharpminor]
+Elet [in backend.Cminor]
+Eletvar [in backend.Cminor]
+Eletvar [in backend.Csharpminor]
+Eload [in backend.Cminor]
+Eload [in backend.Csharpminor]
+Enil [in backend.Csharpminor]
+Enil [in backend.Cminor]
+Eop [in backend.Csharpminor]
+Eop [in backend.Cminor]
+Error [in backend.RTLgen]
+Error [in backend.PPC]
+Estore [in backend.Cminor]
+Estore [in backend.Csharpminor]
+eval_Evar [in backend.Csharpminor]
+eval_Evar [in backend.Cminor]
+eval_static_condition_case1 [in backend.Constprop]
+eval_static_condition_case2 [in backend.Constprop]
+eval_static_condition_case3 [in backend.Constprop]
+eval_static_condition_case4 [in backend.Constprop]
+eval_static_condition_case5 [in backend.Constprop]
+eval_static_condition_case6 [in backend.Constprop]
+eval_static_condition_case7 [in backend.Constprop]
+eval_static_condition_case8 [in backend.Constprop]
+eval_static_condition_default [in backend.Constprop]
+eval_static_operation_case1 [in backend.Constprop]
+eval_static_operation_case11 [in backend.Constprop]
+eval_static_operation_case12 [in backend.Constprop]
+eval_static_operation_case13 [in backend.Constprop]
+eval_static_operation_case14 [in backend.Constprop]
+eval_static_operation_case15 [in backend.Constprop]
+eval_static_operation_case16 [in backend.Constprop]
+eval_static_operation_case17 [in backend.Constprop]
+eval_static_operation_case18 [in backend.Constprop]
+eval_static_operation_case19 [in backend.Constprop]
+eval_static_operation_case2 [in backend.Constprop]
+eval_static_operation_case20 [in backend.Constprop]
+eval_static_operation_case21 [in backend.Constprop]
+eval_static_operation_case22 [in backend.Constprop]
+eval_static_operation_case23 [in backend.Constprop]
+eval_static_operation_case24 [in backend.Constprop]
+eval_static_operation_case25 [in backend.Constprop]
+eval_static_operation_case26 [in backend.Constprop]
+eval_static_operation_case27 [in backend.Constprop]
+eval_static_operation_case28 [in backend.Constprop]
+eval_static_operation_case29 [in backend.Constprop]
+eval_static_operation_case3 [in backend.Constprop]
+eval_static_operation_case30 [in backend.Constprop]
+eval_static_operation_case31 [in backend.Constprop]
+eval_static_operation_case32 [in backend.Constprop]
+eval_static_operation_case33 [in backend.Constprop]
+eval_static_operation_case34 [in backend.Constprop]
+eval_static_operation_case35 [in backend.Constprop]
+eval_static_operation_case36 [in backend.Constprop]
+eval_static_operation_case37 [in backend.Constprop]
+eval_static_operation_case38 [in backend.Constprop]
+eval_static_operation_case39 [in backend.Constprop]
+eval_static_operation_case4 [in backend.Constprop]
+eval_static_operation_case40 [in backend.Constprop]
+eval_static_operation_case41 [in backend.Constprop]
+eval_static_operation_case42 [in backend.Constprop]
+eval_static_operation_case43 [in backend.Constprop]
+eval_static_operation_case44 [in backend.Constprop]
+eval_static_operation_case45 [in backend.Constprop]
+eval_static_operation_case46 [in backend.Constprop]
+eval_static_operation_case47 [in backend.Constprop]
+eval_static_operation_case6 [in backend.Constprop]
+eval_static_operation_case7 [in backend.Constprop]
+eval_static_operation_case8 [in backend.Constprop]
+eval_static_operation_case9 [in backend.Constprop]
+eval_static_operation_default [in backend.Constprop]
+Evar [in backend.Cminor]
+Evar [in backend.Csharpminor]
+exec_Bgetstack [in backend.LTL]
+exec_Iload [in backend.RTL]
+exec_Inop [in backend.RTL]
+exec_Iop [in backend.RTL]
+exec_Lgetstack [in backend.Linear]
+exec_Mgetparam [in backend.Mach]
+exec_Mgetstack [in backend.Mach]
+exec_Mgetstack [in backend.Machabstr]
+exec_Mlabel [in backend.Mach]
+exec_Mlabel [in backend.Machabstr]
+exec_Msetstack [in backend.Mach]
+exec_one [in backend.PPC]
+exec_refl [in backend.PPC]
+exec_step_intro [in backend.PPC]
+exec_straight_refl [in backend.PPCgenproof1]
+exec_straight_step [in backend.PPCgenproof1]
+exec_trans [in backend.PPC]
+

F

+FI_arg [in backend.Stacking]
+FI_local [in backend.Stacking]
+FI_saved_float [in backend.Stacking]
+FI_saved_int [in backend.Stacking]
+FPR0 [in backend.PPC]
+FPR1 [in backend.PPC]
+FPR10 [in backend.PPC]
+FPR11 [in backend.PPC]
+FPR12 [in backend.PPC]
+FPR13 [in backend.PPC]
+FPR14 [in backend.PPC]
+FPR15 [in backend.PPC]
+FPR16 [in backend.PPC]
+FPR17 [in backend.PPC]
+FPR18 [in backend.PPC]
+FPR19 [in backend.PPC]
+FPR2 [in backend.PPC]
+FPR20 [in backend.PPC]
+FPR21 [in backend.PPC]
+FPR22 [in backend.PPC]
+FPR23 [in backend.PPC]
+FPR24 [in backend.PPC]
+FPR25 [in backend.PPC]
+FPR26 [in backend.PPC]
+FPR27 [in backend.PPC]
+FPR28 [in backend.PPC]
+FPR29 [in backend.PPC]
+FPR3 [in backend.PPC]
+FPR30 [in backend.PPC]
+FPR31 [in backend.PPC]
+FPR4 [in backend.PPC]
+FPR5 [in backend.PPC]
+FPR6 [in backend.PPC]
+FPR7 [in backend.PPC]
+FPR8 [in backend.PPC]
+FPR9 [in backend.PPC]
+FR [in backend.PPC]
+frame_match_intro [in backend.Machabstr2mach]
+FT1 [in backend.Locations]
+FT2 [in backend.Locations]
+FT3 [in backend.Locations]
+F1 [in backend.Locations]
+F10 [in backend.Locations]
+F14 [in backend.Locations]
+F15 [in backend.Locations]
+F16 [in backend.Locations]
+F17 [in backend.Locations]
+F18 [in backend.Locations]
+F19 [in backend.Locations]
+F2 [in backend.Locations]
+F20 [in backend.Locations]
+F21 [in backend.Locations]
+F22 [in backend.Locations]
+F23 [in backend.Locations]
+F24 [in backend.Locations]
+F25 [in backend.Locations]
+F26 [in backend.Locations]
+F27 [in backend.Locations]
+F28 [in backend.Locations]
+F29 [in backend.Locations]
+F3 [in backend.Locations]
+F30 [in backend.Locations]
+F31 [in backend.Locations]
+F4 [in backend.Locations]
+F5 [in backend.Locations]
+F6 [in backend.Locations]
+F7 [in backend.Locations]
+F8 [in backend.Locations]
+F9 [in backend.Locations]
+

G

+get_slot_intro [in backend.Machabstr]
+GPR0 [in backend.PPC]
+GPR1 [in backend.PPC]
+GPR10 [in backend.PPC]
+GPR11 [in backend.PPC]
+GPR12 [in backend.PPC]
+GPR13 [in backend.PPC]
+GPR14 [in backend.PPC]
+GPR15 [in backend.PPC]
+GPR16 [in backend.PPC]
+GPR17 [in backend.PPC]
+GPR18 [in backend.PPC]
+GPR19 [in backend.PPC]
+GPR2 [in backend.PPC]
+GPR20 [in backend.PPC]
+GPR21 [in backend.PPC]
+GPR22 [in backend.PPC]
+GPR23 [in backend.PPC]
+GPR24 [in backend.PPC]
+GPR25 [in backend.PPC]
+GPR26 [in backend.PPC]
+GPR27 [in backend.PPC]
+GPR28 [in backend.PPC]
+GPR29 [in backend.PPC]
+GPR3 [in backend.PPC]
+GPR30 [in backend.PPC]
+GPR31 [in backend.PPC]
+GPR4 [in backend.PPC]
+GPR5 [in backend.PPC]
+GPR6 [in backend.PPC]
+GPR7 [in backend.PPC]
+GPR8 [in backend.PPC]
+GPR9 [in backend.PPC]
+

I

+Incoming [in backend.Locations]
+Inj [in lib.Lattice]
+Inop [in backend.RTL]
+insert_lenv_S [in backend.Cmconstrproof]
+insert_lenv_0 [in backend.Cmconstrproof]
+IR [in backend.PPC]
+is_tail_cons [in backend.Linearizeproof]
+is_tail_refl [in backend.Linearizeproof]
+IT1 [in backend.Locations]
+IT2 [in backend.Locations]
+IT3 [in backend.Locations]
+

L

+Lcall [in backend.Linear]
+Lcond [in backend.Linear]
+Leaf [in lib.Maps]
+leaf [in lib.Inclusion]
+Lgetstack [in backend.Linear]
+Lgoto [in backend.Linear]
+list_forall2_cons [in lib.Coqlib]
+list_forall2_nil [in lib.Coqlib]
+list_norepet_cons [in lib.Coqlib]
+list_norepet_nil [in lib.Coqlib]
+Llabel [in backend.Linear]
+Lload [in backend.Linear]
+Load [in backend.CSE]
+Local [in backend.Locations]
+Lop [in backend.Linear]
+LR [in backend.PPC]
+Lreturn [in backend.Linear]
+Lsetstack [in backend.Linear]
+Lstore [in backend.Linear]
+LVarray [in backend.Csharpminor]
+LVscalar [in backend.Csharpminor]
+

M

+Mcall [in backend.Mach]
+Mcond [in backend.Mach]
+mcs_cons [in backend.Cminorgenproof]
+mcs_nil [in backend.Cminorgenproof]
+Mfloat32 [in backend.AST]
+Mfloat64 [in backend.AST]
+Mgetparam [in backend.Mach]
+Mgetstack [in backend.Mach]
+Mgoto [in backend.Mach]
+Mint16signed [in backend.AST]
+Mint16unsigned [in backend.AST]
+Mint32 [in backend.AST]
+Mint8signed [in backend.AST]
+Mint8unsigned [in backend.AST]
+Mlabel [in backend.Mach]
+Mload [in backend.Mach]
+Mop [in backend.Mach]
+Mreturn [in backend.Mach]
+Msetstack [in backend.Mach]
+Mstore [in backend.Mach]
+mulimm_case1 [in backend.Cmconstr]
+mulimm_case2 [in backend.Cmconstr]
+mulimm_default [in backend.Cmconstr]
+mul_case1 [in backend.Cmconstr]
+mul_case2 [in backend.Cmconstr]
+mul_default [in backend.Cmconstr]
+

N

+n [in backend.Op]
+Node [in lib.Maps]
+node [in lib.Inclusion]
+norepet_cons [in backend.Locations]
+norepet_nil [in backend.Locations]
+notint_case1 [in backend.Cmconstr]
+notint_case2 [in backend.Cmconstr]
+notint_case3 [in backend.Cmconstr]
+notint_default [in backend.Cmconstr]
+notin_callstack_cons [in backend.Machabstr2mach]
+notin_callstack_nil [in backend.Machabstr2mach]
+Novalue [in backend.Constprop]
+

O

+Oabsf [in backend.Op]
+Oabsf [in backend.Csharpminor]
+Oadd [in backend.Csharpminor]
+Oadd [in backend.Op]
+Oaddf [in backend.Csharpminor]
+Oaddf [in backend.Op]
+Oaddimm [in backend.Op]
+Oaddrstack [in backend.Op]
+Oaddrsymbol [in backend.Op]
+Oand [in backend.Op]
+Oand [in backend.Csharpminor]
+Oandimm [in backend.Op]
+Ocast16signed [in backend.Csharpminor]
+Ocast16signed [in backend.Op]
+Ocast16unsigned [in backend.Csharpminor]
+Ocast8signed [in backend.Csharpminor]
+Ocast8signed [in backend.Op]
+Ocast8unsigned [in backend.Csharpminor]
+Ocmp [in backend.Op]
+Ocmp [in backend.Csharpminor]
+Ocmpf [in backend.Csharpminor]
+Ocmpu [in backend.Csharpminor]
+Odiv [in backend.Op]
+Odiv [in backend.Csharpminor]
+Odivf [in backend.Op]
+Odivf [in backend.Csharpminor]
+Odivu [in backend.Csharpminor]
+Odivu [in backend.Op]
+Ofloatconst [in backend.Op]
+Ofloatconst [in backend.Csharpminor]
+Ofloatofint [in backend.Op]
+Ofloatofint [in backend.Csharpminor]
+Ofloatofintu [in backend.Csharpminor]
+Ofloatofintu [in backend.Op]
+Ointconst [in backend.Csharpminor]
+Ointconst [in backend.Op]
+Ointoffloat [in backend.Csharpminor]
+Ointoffloat [in backend.Op]
+OK [in backend.RTLgen]
+OK [in backend.PPC]
+Omod [in backend.Csharpminor]
+Omodu [in backend.Csharpminor]
+Omove [in backend.Op]
+Omul [in backend.Csharpminor]
+Omul [in backend.Op]
+Omuladdf [in backend.Op]
+Omulf [in backend.Op]
+Omulf [in backend.Csharpminor]
+Omulimm [in backend.Op]
+Omulsubf [in backend.Op]
+Onand [in backend.Op]
+Onegf [in backend.Csharpminor]
+Onegf [in backend.Op]
+Onor [in backend.Op]
+Onotint [in backend.Csharpminor]
+Onxor [in backend.Op]
+Oor [in backend.Op]
+Oor [in backend.Csharpminor]
+Oorimm [in backend.Op]
+Op [in backend.CSE]
+op_strength_reduction_case1 [in backend.Constprop]
+op_strength_reduction_case10 [in backend.Constprop]
+op_strength_reduction_case11 [in backend.Constprop]
+op_strength_reduction_case12 [in backend.Constprop]
+op_strength_reduction_case2 [in backend.Constprop]
+op_strength_reduction_case3 [in backend.Constprop]
+op_strength_reduction_case4 [in backend.Constprop]
+op_strength_reduction_case5 [in backend.Constprop]
+op_strength_reduction_case6 [in backend.Constprop]
+op_strength_reduction_case7 [in backend.Constprop]
+op_strength_reduction_case8 [in backend.Constprop]
+op_strength_reduction_case9 [in backend.Constprop]
+op_strength_reduction_default [in backend.Constprop]
+Orolm [in backend.Op]
+or_case1 [in backend.Cmconstr]
+or_default [in backend.Cmconstr]
+Oshl [in backend.Csharpminor]
+Oshl [in backend.Op]
+Oshr [in backend.Op]
+Oshr [in backend.Csharpminor]
+Oshrimm [in backend.Op]
+Oshru [in backend.Op]
+Oshru [in backend.Csharpminor]
+Oshrximm [in backend.Op]
+Osingleoffloat [in backend.Op]
+Osingleoffloat [in backend.Csharpminor]
+Osub [in backend.Csharpminor]
+Osub [in backend.Op]
+Osubf [in backend.Csharpminor]
+Osubf [in backend.Op]
+Osubimm [in backend.Op]
+Oundef [in backend.Op]
+Outgoing [in backend.Locations]
+Out_exit [in backend.Csharpminor]
+Out_exit [in backend.Cminor]
+Out_normal [in backend.Cminor]
+Out_normal [in backend.Csharpminor]
+Out_return [in backend.Cminor]
+Out_return [in backend.Csharpminor]
+Oxor [in backend.Op]
+Oxor [in backend.Csharpminor]
+Oxorimm [in backend.Op]
+

P

+Padd [in backend.PPC]
+Paddi [in backend.PPC]
+Paddis [in backend.PPC]
+Paddze [in backend.PPC]
+Pallocframe [in backend.PPC]
+Pandc [in backend.PPC]
+Pandis_ [in backend.PPC]
+Pandi_ [in backend.PPC]
+Pand_ [in backend.PPC]
+Pb [in backend.PPC]
+Pbctr [in backend.PPC]
+Pbctrl [in backend.PPC]
+Pbf [in backend.PPC]
+Pbl [in backend.PPC]
+Pblr [in backend.PPC]
+Pbt [in backend.PPC]
+PC [in backend.PPC]
+Pcmplw [in backend.PPC]
+Pcmplwi [in backend.PPC]
+Pcmpw [in backend.PPC]
+Pcmpwi [in backend.PPC]
+Pcror [in backend.PPC]
+Pdivw [in backend.PPC]
+Pdivwu [in backend.PPC]
+Peqv [in backend.PPC]
+Pextsb [in backend.PPC]
+Pextsh [in backend.PPC]
+Pfabs [in backend.PPC]
+Pfadd [in backend.PPC]
+Pfcmpu [in backend.PPC]
+Pfcti [in backend.PPC]
+Pfdiv [in backend.PPC]
+Pfmadd [in backend.PPC]
+Pfmr [in backend.PPC]
+Pfmsub [in backend.PPC]
+Pfmul [in backend.PPC]
+Pfneg [in backend.PPC]
+Pfreeframe [in backend.PPC]
+Pfrsp [in backend.PPC]
+Pfsub [in backend.PPC]
+Pfundef [in backend.PPC]
+Pictf [in backend.PPC]
+Piuctf [in backend.PPC]
+Piundef [in backend.PPC]
+Plabel [in backend.PPC]
+Plbz [in backend.PPC]
+Plbzx [in backend.PPC]
+Plfd [in backend.PPC]
+Plfdx [in backend.PPC]
+Plfi [in backend.PPC]
+Plfs [in backend.PPC]
+Plfsx [in backend.PPC]
+Plha [in backend.PPC]
+Plhax [in backend.PPC]
+Plhz [in backend.PPC]
+Plhzx [in backend.PPC]
+Plwz [in backend.PPC]
+Plwzx [in backend.PPC]
+Pmfcrbit [in backend.PPC]
+Pmflr [in backend.PPC]
+Pmr [in backend.PPC]
+Pmtctr [in backend.PPC]
+Pmtlr [in backend.PPC]
+Pmulli [in backend.PPC]
+Pmullw [in backend.PPC]
+Pnand [in backend.PPC]
+Pnor [in backend.PPC]
+Por [in backend.PPC]
+Porc [in backend.PPC]
+Pori [in backend.PPC]
+Poris [in backend.PPC]
+Prlwinm [in backend.PPC]
+Pslw [in backend.PPC]
+Psraw [in backend.PPC]
+Psrawi [in backend.PPC]
+Psrw [in backend.PPC]
+Pstb [in backend.PPC]
+Pstbx [in backend.PPC]
+Pstfd [in backend.PPC]
+Pstfdx [in backend.PPC]
+Pstfs [in backend.PPC]
+Pstfsx [in backend.PPC]
+Psth [in backend.PPC]
+Psthx [in backend.PPC]
+Pstw [in backend.PPC]
+Pstwx [in backend.PPC]
+Psubfc [in backend.PPC]
+Psubfic [in backend.PPC]
+Pxor [in backend.PPC]
+Pxori [in backend.PPC]
+Pxoris [in backend.PPC]
+

R

+R [in backend.Locations]
+Return [in backend.LTL]
+return_reg_ok_none [in backend.RTLgenproof1]
+return_reg_ok_some [in backend.RTLgenproof1]
+RLW_Sbad [in lib.Integers]
+RLW_S0 [in lib.Integers]
+RLW_S1 [in lib.Integers]
+RLW_S2 [in lib.Integers]
+RLW_S3 [in lib.Integers]
+RLW_S4 [in lib.Integers]
+RLW_S5 [in lib.Integers]
+RLW_S6 [in lib.Integers]
+rolm_case1 [in backend.Cmconstr]
+rolm_case2 [in backend.Cmconstr]
+rolm_default [in backend.Cmconstr]
+R10 [in backend.Locations]
+R13 [in backend.Locations]
+R14 [in backend.Locations]
+R15 [in backend.Locations]
+R16 [in backend.Locations]
+R17 [in backend.Locations]
+R18 [in backend.Locations]
+R19 [in backend.Locations]
+r2 [in backend.Op]
+r2 [in backend.Op]
+R20 [in backend.Locations]
+R21 [in backend.Locations]
+R22 [in backend.Locations]
+R23 [in backend.Locations]
+R24 [in backend.Locations]
+R25 [in backend.Locations]
+R26 [in backend.Locations]
+R27 [in backend.Locations]
+R28 [in backend.Locations]
+R29 [in backend.Locations]
+R3 [in backend.Locations]
+R30 [in backend.Locations]
+R31 [in backend.Locations]
+R4 [in backend.Locations]
+R5 [in backend.Locations]
+R6 [in backend.Locations]
+R7 [in backend.Locations]
+R8 [in backend.Locations]
+R9 [in backend.Locations]
+

S

+S [in backend.Locations]
+Sblock [in backend.Cminor]
+Sblock [in backend.Csharpminor]
+Scons [in backend.Cminor]
+Scons [in backend.Csharpminor]
+set_slot_intro [in backend.Machabstr]
+Sexit [in backend.Cminor]
+Sexit [in backend.Csharpminor]
+Sexpr [in backend.Cminor]
+Sexpr [in backend.Csharpminor]
+shift_case1 [in backend.Cmconstr]
+shift_default [in backend.Cmconstr]
+Sifthenelse [in backend.Csharpminor]
+Sifthenelse [in backend.Cminor]
+Size16 [in backend.Mem]
+Size32 [in backend.Mem]
+Size64 [in backend.Mem]
+Size8 [in backend.Mem]
+Sloop [in backend.Csharpminor]
+Sloop [in backend.Cminor]
+Snil [in backend.Csharpminor]
+Snil [in backend.Cminor]
+Sreturn [in backend.Csharpminor]
+Sreturn [in backend.Cminor]
+state_incr_intro [in backend.RTLgenproof1]
+stepp_refl [in backend.Parallelmove]
+stepp_trans [in backend.Parallelmove]
+step_loop [in backend.Parallelmove]
+step_nop [in backend.Parallelmove]
+step_pop [in backend.Parallelmove]
+step_push [in backend.Parallelmove]
+step_start [in backend.Parallelmove]
+subf_case1 [in backend.Cmconstr]
+subf_default [in backend.Cmconstr]
+sub_case1 [in backend.Cmconstr]
+sub_case2 [in backend.Cmconstr]
+sub_case3 [in backend.Cmconstr]
+sub_case4 [in backend.Cmconstr]
+sub_default [in backend.Cmconstr]
+

T

+target_regs_cons [in backend.RTLgenproof1]
+target_regs_nil [in backend.RTLgenproof1]
+target_reg_immut_var [in backend.RTLgenproof1]
+Tfloat [in backend.AST]
+Tint [in backend.AST]
+tReg [in backend.RTLtyping]
+tTy [in backend.RTLtyping]
+

U

+Undef [in backend.Mem]
+

V

+val_cons_inject [in backend.Mem]
+val_content_inject_base [in backend.Mem]
+val_content_inject_8 [in backend.Mem]
+val_inject_float [in backend.Mem]
+val_inject_int [in backend.Mem]
+val_inject_ptr [in backend.Mem]
+val_nil_inject [in backend.Mem]
+vars_vals_cons [in backend.Cminorgenproof]
+vars_vals_nil [in backend.Cminorgenproof]
+Var_global [in backend.Cminorgen]
+Var_local [in backend.Cminorgen]
+Var_stack_array [in backend.Cminorgen]
+Var_stack_scalar [in backend.Cminorgen]
+Vfloat [in backend.Values]
+Vint [in backend.Values]
+vlma_cons [in backend.Constpropproof]
+vlma_nil [in backend.Constpropproof]
+Vptr [in backend.Values]
+Vundef [in backend.Values]
+

W

+wt_Bgetstack [in backend.LTLtyping]
+wt_Bop [in backend.LTLtyping]
+wt_Bopmove [in backend.LTLtyping]
+wt_Bopundef [in backend.LTLtyping]
+wt_Bsetstack [in backend.LTLtyping]
+wt_Inop [in backend.RTLtyping]
+wt_Iop [in backend.RTLtyping]
+wt_Iopmove [in backend.RTLtyping]
+wt_Iopundef [in backend.RTLtyping]
+wt_Lgetstack [in backend.Lineartyping]
+wt_Lop [in backend.Lineartyping]
+wt_Lopmove [in backend.Lineartyping]
+wt_Lopundef [in backend.Lineartyping]
+wt_Lsetstack [in backend.Lineartyping]
+wt_Mgetstack [in backend.Machtyping]
+wt_Mlabel [in backend.Machtyping]
+wt_Msetstack [in backend.Machtyping]
+

_

+_ [in backend.Lineartyping]
+_ [in backend.LTLtyping]
+

+

Inductive Index

+

A

+a [in backend.Op]
+a [in backend.Op]
+addf_cases [in backend.Cmconstr]
+addimm_cases [in backend.Cmconstr]
+addressing [in backend.Op]
+addressing_cases [in backend.Cmconstr]
+addr_strength_reduction_cases [in backend.Constprop]
+add_cases [in backend.Cmconstr]
+agree [in backend.Stackingproof]
+alloc_variables [in backend.Csharpminor]
+approx [in backend.Constprop]
+

B

+bin [in lib.Inclusion]
+bind_parameters [in backend.Csharpminor]
+block [in backend.LTL]
+block_contents [in backend.Mem]
+block_contents_inject [in backend.Mem]
+bool_of_val [in backend.Values]
+bounds [in backend.Lineartyping]
+

C

+callstack_dom [in backend.Machabstr2mach]
+callstack_invariant [in backend.Machabstr2mach]
+callstack_linked [in backend.Machabstr2mach]
+comparison [in backend.AST]
+condexpr [in backend.Cminor]
+condition [in backend.Op]
+cond_strength_reduction_cases [in backend.Constprop]
+constant [in backend.PPC]
+content [in backend.Mem]
+content_inject [in backend.Mem]
+cont_for_outcome [in backend.Linearizeproof]
+crbit [in backend.PPC]
+

D

+divu_cases [in backend.Cmconstr]
+dstep [in backend.Parallelmove]
+dstepp [in backend.Parallelmove]
+

E

+eval_expr [in backend.Csharpminor]
+eval_expr [in backend.Cminor]
+eval_static_condition_cases [in backend.Constprop]
+eval_static_operation_cases [in backend.Constprop]
+exec_instr [in backend.Machabstr]
+exec_instr [in backend.RTL]
+exec_instr [in backend.LTL]
+exec_instr [in backend.Linear]
+exec_instr [in backend.Mach]
+exec_step [in backend.PPC]
+exec_steps [in backend.PPC]
+exec_straight [in backend.PPCgenproof1]
+expr [in backend.Csharpminor]
+expr [in backend.Cminor]
+exprlist [in backend.Csharpminor]
+exprlist [in backend.Cminor]
+

F

+frame [in backend.Cminorgenproof]
+frame_env [in backend.Stacking]
+frame_index [in backend.Stacking]
+frame_match [in backend.Machabstr2mach]
+freg [in backend.PPC]
+function [in backend.Mach]
+function [in backend.Csharpminor]
+function [in backend.RTL]
+function [in backend.LTL]
+function [in backend.Cminor]
+function [in backend.Linear]
+

G

+genv [in backend.Globalenvs]
+get_slot [in backend.Machabstr]
+graph [in backend.InterfGraph]
+

I

+immediate [in backend.PPC]
+immediate [in backend.PPC]
+immediate [in backend.PPC]
+immediate [in backend.PPC]
+immediate [in backend.PPC]
+immediate [in backend.PPC]
+Incoming [in backend.LTLtyping]
+Incoming [in backend.Lineartyping]
+insert_lenv [in backend.Cmconstrproof]
+instruction [in backend.Linear]
+instruction [in backend.PPC]
+instruction [in backend.RTL]
+instruction [in backend.Mach]
+int [in lib.Integers]
+ireg [in backend.PPC]
+is_tail [in backend.Linearizeproof]
+

L

+list_forall2 [in lib.Coqlib]
+list_norepet [in lib.Coqlib]
+loc [in backend.Locations]
+local_variable [in backend.Csharpminor]
+

M

+mapping [in backend.RTLgen]
+map_wf [in backend.RTLgenproof1]
+match_callstack [in backend.Cminorgenproof]
+match_env [in backend.Cminorgenproof]
+match_env [in backend.RTLgenproof1]
+match_globalenvs [in backend.Cminorgenproof]
+match_var [in backend.Cminorgenproof]
+mem [in backend.Mem]
+memory_chunk [in backend.AST]
+memory_size [in backend.Mem]
+mem_inject [in backend.Mem]
+mreg [in backend.Locations]
+mulimm_cases [in backend.Cmconstr]
+mul_cases [in backend.Cmconstr]
+myT [in backend.RTLtyping]
+

N

+norepet [in backend.Locations]
+notint_cases [in backend.Cmconstr]
+notin_callstack [in backend.Machabstr2mach]
+numbering [in backend.CSE]
+

O

+operation [in backend.Csharpminor]
+operation [in backend.Op]
+op_strength_reduction_cases [in backend.Constprop]
+or_cases [in backend.Cmconstr]
+outcome [in backend.Cminor]
+outcome [in backend.LTL]
+outcome [in backend.PPC]
+outcome [in backend.Csharpminor]
+outcome_inject [in backend.Cminorgenproof]
+

P

+preg [in backend.PPC]
+program [in backend.AST]
+

R

+res [in backend.RTLgen]
+return_reg_ok [in backend.RTLgenproof1]
+rhs [in backend.CSE]
+rlw_state [in lib.Integers]
+rolm_cases [in backend.Cmconstr]
+

S

+set_slot [in backend.Machabstr]
+shift_cases [in backend.Cmconstr]
+signature [in backend.AST]
+slot [in backend.Locations]
+state [in backend.Kildall]
+state [in backend.RTLgen]
+state [in backend.Kildall]
+state_incr [in backend.RTLgenproof1]
+step [in backend.Parallelmove]
+stepp [in backend.Parallelmove]
+stmt [in backend.Csharpminor]
+stmt [in backend.Cminor]
+stmtlist [in backend.Csharpminor]
+stmtlist [in backend.Cminor]
+subf_cases [in backend.Cmconstr]
+sub_cases [in backend.Cmconstr]
+

T

+target_regs_ok [in backend.RTLgenproof1]
+target_reg_ok [in backend.RTLgenproof1]
+transl_code_at_pc [in backend.PPCgenproof]
+tree [in lib.Maps]
+typ [in backend.AST]
+t_ [in lib.Lattice]
+t_ [in lib.Lattice]
+

U

+unionfind [in lib.union_find]
+

V

+val [in backend.Values]
+val_content_inject [in backend.Mem]
+val_inject [in backend.Mem]
+val_list_inject [in backend.Mem]
+val_list_match_approx [in backend.Constpropproof]
+vars_vals_match [in backend.Cminorgenproof]
+var_info [in backend.Cminorgen]
+

W

+wt_block [in backend.LTLtyping]
+wt_function [in backend.RTLtyping]
+wt_function [in backend.Machtyping]
+wt_instr [in backend.Lineartyping]
+wt_instr [in backend.Machtyping]
+wt_instr [in backend.RTLtyping]
+

+

Definition Index

+

A

+absf [in backend.Values]
+absfloat [in backend.Cmconstr]
+add [in backend.Values]
+add [in lib.Sets]
+add [in backend.Cmconstr]
+add [in backend.RTLtyping]
+add [in lib.Integers]
+addf [in backend.Cmconstr]
+addf [in backend.Values]
+addf_match [in backend.Cmconstr]
+addf_match_aux [in backend.Cmconstr]
+addimm [in backend.PPCgen]
+addimm [in backend.Cmconstr]
+addimm_match [in backend.Cmconstr]
+addimm_1 [in backend.PPCgen]
+addimm_2 [in backend.PPCgen]
+addressing [in backend.Cmconstr]
+addressing_match [in backend.Cmconstr]
+addr_strength_reduction [in backend.Constprop]
+addr_strength_reduction_match [in backend.Constprop]
+addr_taken_expr [in backend.Cminorgen]
+addr_taken_stmt [in backend.Cminorgen]
+add_call [in backend.Allocation]
+add_cond [in backend.Allocation]
+add_edges_instr [in backend.Coloring]
+add_edges_instrs [in backend.Coloring]
+add_entry [in backend.Allocation]
+add_funct [in backend.Globalenvs]
+add_functs [in backend.Globalenvs]
+add_globals [in backend.Globalenvs]
+add_instr [in backend.RTLgen]
+add_interf [in backend.InterfGraph]
+add_interf_call [in backend.Coloring]
+add_interf_entry [in backend.Coloring]
+add_interf_live [in backend.Coloring]
+add_interf_move [in backend.Coloring]
+add_interf_mreg [in backend.InterfGraph]
+add_interf_op [in backend.Coloring]
+add_interf_params [in backend.Coloring]
+add_letvar [in backend.RTLgen]
+add_load [in backend.CSE]
+add_load [in backend.Allocation]
+add_match [in backend.Cmconstr]
+add_match_aux [in backend.Cmconstr]
+add_move [in backend.RTLgen]
+add_move [in backend.Allocation]
+add_op [in backend.Allocation]
+add_op [in backend.CSE]
+add_pref [in backend.InterfGraph]
+add_prefs_call [in backend.Coloring]
+add_pref_mreg [in backend.InterfGraph]
+add_reload [in backend.Allocation]
+add_reloads [in backend.Allocation]
+add_return [in backend.Allocation]
+add_rhs [in backend.CSE]
+add_spill [in backend.Allocation]
+add_store [in backend.Allocation]
+add_successors [in backend.Kildall]
+add_symbol [in backend.Globalenvs]
+add_to_worklist [in backend.Kildall]
+add_undefs [in backend.Allocation]
+add_var [in backend.RTLgen]
+add_vars [in backend.RTLgen]
+agree [in backend.Allocproof]
+agree [in backend.PPCgenproof1]
+align [in lib.Coqlib]
+align_16_top [in backend.Mach]
+alloc [in backend.Mem]
+alloc_of_coloring [in backend.Coloring]
+alloc_reg [in backend.RTLgen]
+alloc_regs [in backend.RTLgen]
+all_interf_regs [in backend.InterfGraph]
+analyze [in backend.Allocation]
+analyze [in backend.Constprop]
+analyze [in backend.CSE]
+and [in lib.Integers]
+and [in backend.Cmconstr]
+and [in backend.Values]
+andimm [in backend.Cmconstr]
+andimm [in backend.PPCgen]
+append [in lib.Maps]
+apply_partial [in backend.Main]
+apply_total [in backend.Main]
+approx_regs [in backend.Constprop]
+assign_variable [in backend.Cminorgen]
+assign_variables [in backend.Cminorgen]
+

B

+base_case_Pmov_dec [in backend.Parallelmove]
+basic_block_list [in backend.Kildall]
+basic_block_map [in backend.Kildall]
+bbmap [in backend.Kildall]
+bind [in backend.RTLgen]
+bind [in backend.Cminorgen]
+bind2 [in backend.RTLgen]
+bin_A [in lib.Inclusion]
+bits_of_Z [in lib.Integers]
+bitwise_binop [in lib.Integers]
+block [in backend.Values]
+block_agree [in backend.Mem]
+block_contents_agree [in backend.Mem]
+block_contents_extends [in backend.Mem]
+bot [in lib.Lattice]
+bot [in lib.Lattice]
+bot [in backend.Constprop]
+bot [in lib.Sets]
+bot [in lib.Lattice]
+branch_target [in backend.Tunneling]
+branch_target_rec [in backend.Tunneling]
+build_compilenv [in backend.Cminorgen]
+

C

+callstack [in backend.Machabstr2mach]
+callstack [in backend.Cminorgenproof]
+call_regs [in backend.LTL]
+cast [in backend.Csharpminor]
+cast16signed [in lib.Integers]
+cast16signed [in backend.Values]
+cast16signed [in backend.Cmconstr]
+cast16unsigned [in backend.Cmconstr]
+cast16unsigned [in backend.Values]
+cast16unsigned [in lib.Integers]
+cast8signed [in backend.Cmconstr]
+cast8signed [in lib.Integers]
+cast8signed [in backend.Values]
+cast8unsigned [in backend.Cmconstr]
+cast8unsigned [in backend.Values]
+cast8unsigned [in lib.Integers]
+check_all_leaves [in lib.Inclusion]
+check_coloring [in backend.Coloring]
+check_coloring_1 [in backend.Coloring]
+check_coloring_2 [in backend.Coloring]
+check_coloring_3 [in backend.Coloring]
+check_cont [in backend.Mem]
+check_equal_on_range [in lib.Integers]
+chunk_of_type [in backend.Mach]
+cleanup_code [in backend.Linearize]
+cleanup_function [in backend.Linearize]
+cmp [in backend.Cmconstr]
+cmp [in backend.Values]
+cmp [in lib.Integers]
+cmpf [in backend.Cmconstr]
+cmpf [in backend.Values]
+cmpu [in backend.Values]
+cmpu [in backend.Cmconstr]
+cmpu [in lib.Integers]
+cmp_mismatch [in backend.Values]
+code [in backend.LTL]
+code [in backend.PPC]
+code [in backend.RTL]
+code [in backend.Linear]
+code [in backend.Mach]
+code_size [in backend.PPCgen]
+code_tail [in backend.PPCgenproof]
+combine [in lib.Maps]
+compare_float [in backend.PPC]
+compare_sint [in backend.PPC]
+compare_uint [in backend.PPC]
+compilenv [in backend.Cminorgen]
+condexpr_of_expr [in backend.Cmconstr]
+conditionalexpr [in backend.Cmconstr]
+cond_strength_reduction [in backend.Constprop]
+cond_strength_reduction_match [in backend.Constprop]
+consistent [in backend.RTLtyping]
+const_high [in backend.PPC]
+const_low [in backend.PPC]
+contentmap [in backend.Mem]
+contentmap_agree [in backend.Mem]
+contentmap_inject [in backend.Mem]
+correct_alloc_instr [in backend.Coloringproof]
+correct_interf_instr [in backend.Coloringproof]
+crbit_for_cond [in backend.PPCgen]
+crbit_for_fcmp [in backend.PPCgen]
+crbit_for_icmp [in backend.PPCgen]
+

D

+decode [in backend.RTLtyping]
+def [in backend.Parallelmove]
+definite [in backend.RTLtyping]
+destroyed_at_call [in backend.Conventions]
+destroyed_at_call_regs [in backend.Conventions]
+diff [in backend.Locations]
+diff_dec [in backend.Parallelmove]
+disjoint [in backend.Locations]
+divf [in backend.Values]
+divf [in backend.Cmconstr]
+divs [in backend.Cmconstr]
+divs [in lib.Integers]
+divs [in backend.Values]
+divu [in backend.Cmconstr]
+divu [in backend.Values]
+divu [in lib.Integers]
+divu_match [in backend.Cmconstr]
+Done_well_formed [in backend.Allocproof_aux]
+drop1 [in backend.Conventions]
+drop2 [in backend.Conventions]
+

E

+elements [in lib.Sets]
+elements [in lib.Maps]
+elt [in lib.Maps]
+elt [in backend.RTLtyping]
+elt [in lib.Sets]
+elt [in lib.union_find]
+elt [in lib.union_find]
+elt [in lib.union_find]
+elt [in lib.Maps]
+elt [in lib.Maps]
+elt [in lib.Maps]
+elt_eq [in lib.Maps]
+elt_eq [in lib.Maps]
+elt_eq [in lib.Maps]
+elt_eq [in lib.Maps]
+empty [in lib.Sets]
+empty [in lib.Maps]
+empty [in lib.union_find]
+empty [in backend.RTLtyping]
+empty [in backend.Globalenvs]
+empty [in backend.Mem]
+empty_block [in backend.Mem]
+empty_env [in backend.Csharpminor]
+empty_frame [in backend.Machabstr]
+empty_graph [in backend.InterfGraph]
+empty_numbering [in backend.CSE]
+encode [in backend.RTLtyping]
+enumerate [in backend.Linearize]
+env [in backend.Csharpminor]
+Env [in backend.Parallelmove]
+env [in backend.Cminor]
+eq [in backend.Mach]
+eq [in lib.Ordered]
+eq [in backend.RTLtyping]
+eq [in backend.CSEproof]
+eq [in lib.Maps]
+eq [in backend.Locations]
+eq [in lib.Ordered]
+eq [in backend.Registers]
+eq [in lib.Ordered]
+eq [in backend.PPC]
+eq [in lib.Integers]
+eqm [in lib.Integers]
+eqmod [in lib.Integers]
+equation_holds [in backend.CSE]
+eq_block [in backend.Values]
+eq_list_valnum [in backend.CSE]
+eq_rhs [in backend.CSE]
+eq_valnum [in backend.CSE]
+error [in backend.RTLtyping]
+error [in backend.RTLgen]
+eval_addressing [in backend.Op]
+eval_addressing_total [in backend.Op]
+eval_compare_null [in backend.Op]
+eval_compare_null [in backend.Csharpminor]
+eval_condition [in backend.Op]
+eval_condition_total [in backend.Op]
+eval_exprlist_prop [in backend.Cminorgenproof]
+eval_expr_prop [in backend.Cminorgenproof]
+eval_funcall_prop [in backend.Cminorgenproof]
+eval_operation [in backend.Op]
+eval_operation [in backend.Csharpminor]
+eval_operation_total [in backend.Op]
+eval_static_condition [in backend.Constprop]
+eval_static_condition_match [in backend.Constprop]
+eval_static_operation [in backend.Constprop]
+eval_static_operation_match [in backend.Constprop]
+exec [in backend.Parallelmove]
+exec_blocks_prop [in backend.Linearizeproof]
+exec_blocks_prop [in backend.Tunnelingproof]
+exec_block_prop [in backend.Linearizeproof]
+exec_block_prop [in backend.Tunnelingproof]
+exec_function_body_prop [in backend.Machabstr2mach]
+exec_function_body_prop [in backend.PPCgenproof]
+exec_function_body_prop [in backend.Machtyping]
+exec_function_prop [in backend.Stackingproof]
+exec_function_prop [in backend.Machtyping]
+exec_function_prop [in backend.PPCgenproof]
+exec_function_prop [in backend.Constpropproof]
+exec_function_prop [in backend.Linearizeproof]
+exec_function_prop [in backend.Machabstr2mach]
+exec_function_prop [in backend.CSEproof]
+exec_function_prop [in backend.Tunnelingproof]
+exec_function_prop [in backend.Allocproof]
+exec_function_subject_reduction [in backend.RTLtyping]
+exec_instr [in backend.PPC]
+exec_instrs_prop [in backend.Allocproof]
+exec_instrs_prop [in backend.Tunnelingproof]
+exec_instrs_prop [in backend.Machabstr2mach]
+exec_instrs_prop [in backend.CSEproof]
+exec_instrs_prop [in backend.Constpropproof]
+exec_instrs_prop [in backend.Linearizeproof]
+exec_instr_prop [in backend.Allocproof]
+exec_instr_prop [in backend.Machabstr2mach]
+exec_instr_prop [in backend.Machtyping]
+exec_instr_prop [in backend.Constpropproof]
+exec_instr_prop [in backend.CSEproof]
+exec_instr_prop [in backend.Tunnelingproof]
+exec_instr_prop [in backend.Stackingproof]
+exec_instr_prop [in backend.Linearizeproof]
+exec_instr_prop [in backend.PPCgenproof]
+exec_instr_subject_reduction [in backend.RTLtyping]
+exec_program [in backend.Csharpminor]
+exec_program [in backend.LTL]
+exec_program [in backend.Cminor]
+exec_program [in backend.RTL]
+exec_program [in backend.Mach]
+exec_program [in backend.Machabstr]
+exec_program [in backend.Linear]
+exec_program [in backend.PPC]
+exec_stmtlist_prop [in backend.Cminorgenproof]
+exec_stmt_prop [in backend.Cminorgenproof]
+extends [in backend.Mem]
+extend_inject [in backend.Mem]
+

F

+find_funct [in backend.Globalenvs]
+find_function [in backend.LTL]
+find_function [in backend.Mach]
+find_function [in backend.RTL]
+find_function [in backend.Linear]
+find_function2 [in backend.Allocproof]
+find_funct_ptr [in backend.Globalenvs]
+find_instr [in backend.PPC]
+find_label [in backend.Mach]
+find_label [in backend.PPCgenproof]
+find_label [in backend.Linear]
+find_letvar [in backend.RTLgen]
+find_load [in backend.CSE]
+find_op [in backend.CSE]
+find_rhs [in backend.CSE]
+find_symbol [in backend.Globalenvs]
+find_symbol_offset [in backend.Op]
+find_valnum_rhs [in backend.CSE]
+find_var [in backend.RTLgen]
+fixpoint [in backend.Kildall]
+fixpoint [in backend.Kildall]
+fixpoint [in backend.Kildall]
+flatten [in lib.Inclusion]
+flatten_aux [in lib.Inclusion]
+floatcomp [in backend.PPCgen]
+floatofint [in backend.Values]
+floatofint [in backend.Cmconstr]
+floatofintu [in backend.Cmconstr]
+floatofintu [in backend.Values]
+float_callee_save [in backend.Lineartyping]
+float_callee_save_regs [in backend.Conventions]
+float_local [in backend.Lineartyping]
+float_param_regs [in backend.Conventions]
+fn_params_names [in backend.Csharpminor]
+fn_variables [in backend.Csharpminor]
+fn_vars_names [in backend.Csharpminor]
+fold [in lib.Sets]
+fold [in lib.Maps]
+fold2 [in backend.RTLtyping]
+for_all [in lib.Sets]
+frame [in backend.Machabstr]
+free [in backend.Mem]
+free_list [in backend.Mem]
+freg_of [in backend.PPCgen]
+function_bounds [in backend.Lineartyping]
+

G

+ge [in lib.Lattice]
+ge [in backend.CSE]
+ge [in lib.Lattice]
+ge [in backend.Constprop]
+ge [in lib.Lattice]
+ge [in lib.Sets]
+genv [in backend.Cminor]
+genv [in backend.LTL]
+genv [in backend.PPC]
+genv [in backend.Csharpminor]
+genv [in backend.RTL]
+genv [in backend.Mach]
+genv [in backend.Linear]
+get [in lib.Maps]
+get [in lib.Maps]
+get [in lib.Maps]
+Get [in backend.Parallelmove]
+get [in backend.Locations]
+get [in lib.Lattice]
+get [in lib.Maps]
+get [in backend.Parallelmove]
+get [in backend.RTLtyping]
+getdst [in backend.Parallelmove]
+getN [in backend.Mem]
+getsrc [in backend.Parallelmove]
+globalenv [in backend.Globalenvs]
+globalenv_initmem [in backend.Globalenvs]
+good_state [in backend.Kildall]
+goto_label [in backend.PPC]
+gpr_or_zero [in backend.PPC]
+graph_incl [in backend.InterfGraph]
+

H

+half_modulus [in lib.Integers]
+has_type [in backend.Values]
+has_type_list [in backend.Values]
+head_but_last [in backend.Parallelmove]
+high_bound [in backend.Mem]
+high_s [in backend.PPCgen]
+high_u [in backend.PPCgen]
+

I

+ident [in backend.AST]
+identify [in lib.union_find]
+identify_base [in lib.union_find]
+ident_eq [in backend.AST]
+ifthenelse [in backend.Cmconstr]
+included [in backend.RTLtyping]
+index [in backend.Locations]
+index [in lib.Maps]
+index [in lib.Maps]
+index_diff [in backend.Stackingproof]
+index_float_callee_save [in backend.Conventions]
+index_int_callee_save [in backend.Conventions]
+index_val [in backend.Stackingproof]
+index_valid [in backend.Stackingproof]
+init [in lib.Maps]
+init [in backend.Locations]
+init [in lib.Maps]
+init [in lib.Maps]
+init_frame [in backend.Machabstr]
+init_mapping [in backend.RTLgen]
+init_mem [in backend.Globalenvs]
+init_regs [in backend.RTL]
+init_state [in backend.RTLgen]
+inject_incr [in backend.Mem]
+insert_bin [in lib.Inclusion]
+interfere [in backend.InterfGraph]
+interfere_mreg [in backend.InterfGraph]
+interf_graph [in backend.Coloring]
+intoffloat [in backend.Cmconstr]
+intoffloat [in backend.Values]
+intval [in backend.Constprop]
+int_callee_save [in backend.Lineartyping]
+int_callee_save_regs [in backend.Conventions]
+int_local [in backend.Lineartyping]
+int_of_one_bits [in lib.Integers]
+int_param_regs [in backend.Conventions]
+in_bounds [in backend.Mem]
+in_incr [in backend.Kildall]
+in_range [in lib.Integers]
+ireg_of [in backend.PPCgen]
+is_basic_block_head [in backend.Kildall]
+is_bool [in backend.Values]
+is_data_reg [in backend.PPCgenproof1]
+is_false [in lib.Integers]
+is_false [in backend.Values]
+is_goto_block [in backend.Tunneling]
+is_label [in backend.PPC]
+is_label [in backend.Mach]
+is_label [in backend.Linear]
+is_move_operation [in backend.Op]
+is_power2 [in lib.Integers]
+is_rlw_mask [in lib.Integers]
+is_rlw_mask_rec [in lib.Integers]
+is_trivial_op [in backend.CSE]
+is_true [in lib.Integers]
+is_true [in backend.Values]
+iterate [in backend.Kildall]
+iter_step [in backend.Kildall]
+

K

+kill_loads [in backend.CSE]
+kill_load_eqs [in backend.CSE]
+

L

+label [in backend.Linear]
+label [in backend.PPC]
+label [in backend.Mach]
+label_pos [in backend.PPC]
+last [in backend.Parallelmove]
+lbl [in backend.Linearize]
+lbl [in backend.Linearize]
+leaf [in lib.Inclusion]
+leaf [in lib.Inclusion]
+leaf [in lib.Inclusion]
+letenv [in backend.Cminor]
+letenv [in backend.Csharpminor]
+lift [in backend.Cmconstr]
+lift_condexpr [in backend.Cmconstr]
+lift_expr [in backend.Cmconstr]
+lift_exprlist [in backend.Cmconstr]
+linearize_block [in backend.Linearize]
+linearize_body [in backend.Linearize]
+linearize_function [in backend.Linearize]
+link_invariant [in backend.Machtyping]
+listsLoc2Moves [in backend.Parallelmove]
+listsLoc2Moves [in backend.Allocation]
+list_disjoint [in lib.Coqlib]
+live0 [in backend.Allocproof]
+load [in backend.Mem]
+load [in backend.Cmconstr]
+loadimm [in backend.PPCgen]
+loadind [in backend.PPCgen]
+loadind_aux [in backend.PPCgen]
+loadv [in backend.Mem]
+load1 [in backend.PPC]
+load2 [in backend.PPC]
+load_contents [in backend.Mem]
+load_result [in backend.Values]
+load_stack [in backend.Mach]
+locset [in backend.LTL]
+locset [in backend.Linear]
+locs_acceptable [in backend.Conventions]
+locs_read_ok [in backend.Alloctyping]
+locs_write_ok [in backend.Alloctyping]
+loc_acceptable [in backend.Conventions]
+loc_arguments [in backend.Conventions]
+loc_arguments_rec [in backend.Conventions]
+loc_argument_acceptable [in backend.Conventions]
+loc_is_acceptable [in backend.Coloring]
+loc_parameters [in backend.Conventions]
+loc_read_ok [in backend.Alloctyping]
+loc_result [in backend.Conventions]
+loc_write_ok [in backend.Alloctyping]
+low_bound [in backend.Mem]
+low_s [in backend.PPCgen]
+low_u [in backend.PPCgen]
+lt [in lib.Integers]
+lt [in lib.Ordered]
+lt [in lib.Ordered]
+lt [in lib.Ordered]
+ltu [in lib.Integers]
+lub [in lib.Lattice]
+lub [in lib.Lattice]
+lub [in lib.Sets]
+lub [in lib.Lattice]
+lub [in backend.Constprop]
+

M

+make_addimm [in backend.Constprop]
+make_andimm [in backend.Constprop]
+make_cast [in backend.Cminorgen]
+make_env [in backend.Stacking]
+make_load [in backend.Cminorgen]
+make_mulimm [in backend.Constprop]
+make_op [in backend.Cminorgen]
+make_orimm [in backend.Constprop]
+make_predecessors [in backend.Kildall]
+make_shlimm [in backend.Constprop]
+make_shrimm [in backend.Constprop]
+make_shruimm [in backend.Constprop]
+make_stackaddr [in backend.Cminorgen]
+make_store [in backend.Cminorgen]
+make_xorimm [in backend.Constprop]
+map [in lib.Maps]
+map [in lib.Maps]
+map [in lib.Maps]
+map [in lib.Maps]
+mapped [in backend.RTLtyping]
+match_return_outcome [in backend.RTLgenproof]
+match_return_reg [in backend.RTLgenproof]
+max_over_instrs [in backend.Lineartyping]
+max_over_list [in backend.Lineartyping]
+max_over_regs_of_funct [in backend.Lineartyping]
+max_over_regs_of_instr [in backend.Lineartyping]
+max_over_slots_of_funct [in backend.Lineartyping]
+max_over_slots_of_instr [in backend.Lineartyping]
+max_signed [in lib.Integers]
+max_unsigned [in lib.Integers]
+mem [in lib.Sets]
+member [in backend.RTLtyping]
+meminj [in backend.Mem]
+mem_chunk [in backend.Mem]
+mem_type [in backend.Machabstr]
+mesure [in backend.Parallelmove]
+min_signed [in lib.Integers]
+mk_env [in backend.RTLtyping]
+mods [in lib.Integers]
+mods [in backend.Cmconstr]
+mods [in backend.Values]
+modu [in lib.Integers]
+modu [in backend.Values]
+modu [in backend.Cmconstr]
+modulus [in lib.Integers]
+mod_aux [in backend.Cmconstr]
+mon [in backend.RTLgen]
+mone [in lib.Integers]
+Move [in backend.Parallelmove]
+Moves [in backend.Parallelmove]
+mreg_bounded [in backend.Lineartyping]
+mreg_type [in backend.Locations]
+mul [in lib.Integers]
+mul [in backend.Cmconstr]
+mul [in backend.Values]
+mulf [in backend.Cmconstr]
+mulf [in backend.Values]
+mulimm [in backend.Cmconstr]
+mulimm_base [in backend.Cmconstr]
+mulimm_match [in backend.Cmconstr]
+mul_match [in backend.Cmconstr]
+mul_match_aux [in backend.Cmconstr]
+mutated_condexpr [in backend.RTLgen]
+mutated_expr [in backend.RTLgen]
+mutated_exprlist [in backend.RTLgen]
+mutated_reg [in backend.RTLgenproof1]
+

N

+nat_le_bool [in lib.Inclusion]
+neg [in backend.Values]
+neg [in lib.Integers]
+negate_comparison [in backend.AST]
+negate_condition [in backend.Op]
+negf [in backend.Values]
+negfloat [in backend.Cmconstr]
+negint [in backend.Cmconstr]
+new_reg [in backend.RTLgen]
+nextinstr [in backend.PPC]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Allocproof_aux]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+nil [in backend.Parallelmove]
+node [in backend.RTL]
+node [in backend.LTL]
+NoOverlap [in backend.Parallelmove]
+noOverlap [in backend.Parallelmove]
+noOverlap_aux [in backend.Parallelmove]
+noRead [in backend.Parallelmove]
+not [in lib.Integers]
+notbool [in backend.Values]
+notbool [in backend.Cmconstr]
+notbool [in lib.Integers]
+notbool_base [in backend.Cmconstr]
+notemporary [in backend.Parallelmove]
+notin [in backend.Locations]
+notint [in backend.Values]
+notint [in backend.Cmconstr]
+notint_match [in backend.Cmconstr]
+noTmp [in backend.Parallelmove]
+noTmpLast [in backend.Parallelmove]
+noWrite [in backend.Parallelmove]
+no_overlap [in backend.Parallelmove]
+no_overlap [in backend.Locations]
+no_overlap_list [in backend.Parallelmove]
+no_overlap_state [in backend.Parallelmove]
+no_overlap_stateD [in backend.Allocproof_aux]
+no_tmp13_state [in backend.Allocproof_aux]
+nullptr [in backend.Mem]
+numbering_holds [in backend.CSE]
+numbering_satisfiable [in backend.CSE]
+num_iterations [in backend.Kildall]
+

O

+offset_of_index [in backend.Stacking]
+offset_sp [in backend.Op]
+of_bool [in backend.Values]
+one [in lib.Integers]
+one_bits [in lib.Integers]
+option_fold2 [in backend.RTLtyping]
+option_map [in lib.Coqlib]
+op_strength_reduction [in backend.Constprop]
+op_strength_reduction_match [in backend.Constprop]
+or [in lib.Integers]
+or [in backend.Values]
+or [in backend.Cmconstr]
+ordered_pair [in backend.InterfGraph]
+orimm [in backend.PPCgen]
+or_match [in backend.Cmconstr]
+outcome_block [in backend.Csharpminor]
+outcome_block [in backend.Cminor]
+outcome_node [in backend.RTLgenproof]
+outcome_result_value [in backend.Cminor]
+outcome_result_value [in backend.Csharpminor]
+outgoing_slot [in backend.Lineartyping]
+outgoing_space [in backend.Lineartyping]
+overlap [in backend.Locations]
+overlap_aux [in backend.Locations]
+

P

+parallel_move [in backend.Allocation]
+parallel_move_order [in backend.Allocation]
+parameter_of_argument [in backend.Conventions]
+path [in backend.Parallelmove]
+peq [in lib.Coqlib]
+pexec [in backend.Parallelmove]
+Ple [in lib.Coqlib]
+Plt [in lib.Coqlib]
+plt [in lib.Coqlib]
+Pmov [in backend.Parallelmove]
+positive_rec [in lib.Coqlib]
+powerserie [in lib.Integers]
+predecessors [in backend.Kildall]
+preg_of [in backend.PPCgenproof1]
+program [in backend.LTL]
+program [in backend.Cminor]
+program [in backend.Linear]
+program [in backend.RTL]
+program [in backend.Csharpminor]
+program [in backend.PPC]
+program [in backend.Mach]
+propagate_succ [in backend.Kildall]
+propagate_successors [in backend.Kildall]
+propagate_succ_list [in backend.Kildall]
+Pstate [in backend.Kildall]
+p_move [in backend.Allocproof_aux]
+P_move [in backend.Parallelmove]
+

R

+R [in backend.Coloring]
+reachable [in backend.Linearize]
+reachable_aux [in backend.Linearize]
+reg [in backend.Registers]
+Reg [in backend.Parallelmove]
+regalloc [in backend.Coloring]
+regenv [in backend.RTLtyping]
+reglist [in backend.LTL]
+regmap_optget [in backend.Registers]
+regmap_optset [in backend.Registers]
+regset [in backend.Mach]
+regset [in backend.RTL]
+regset [in backend.PPC]
+regs_for [in backend.Allocation]
+regs_for_rec [in backend.Allocation]
+regs_match_approx [in backend.Constpropproof]
+regs_of_instr [in backend.Lineartyping]
+reg_for [in backend.Allocation]
+reg_fresh [in backend.RTLgenproof1]
+reg_in_map [in backend.RTLgenproof1]
+reg_list_dead [in backend.Allocation]
+reg_list_live [in backend.Allocation]
+reg_of_crbit [in backend.PPC]
+reg_option_live [in backend.Allocation]
+reg_sum_live [in backend.Allocation]
+reg_valid [in backend.RTLgenproof1]
+reg_valnum [in backend.CSE]
+remove [in lib.Sets]
+remove [in lib.Maps]
+remove_all_leaves [in lib.Inclusion]
+repet [in backend.RTLtyping]
+replace_last_s [in backend.Parallelmove]
+repr [in lib.union_find]
+repr [in lib.Integers]
+repr_aux [in lib.union_find]
+repr_order [in lib.union_find]
+repr_rec [in lib.union_find]
+reserve_instr [in backend.RTLgen]
+restore_callee_save [in backend.Stacking]
+restore_float_callee_save [in backend.Stacking]
+restore_int_callee_save [in backend.Stacking]
+result [in backend.Kildall]
+reswellFormed [in backend.Allocproof_aux]
+ret [in backend.RTLgen]
+return_regs [in backend.LTL]
+ret_reg [in backend.RTLgen]
+rhs_evals_to [in backend.CSEproof]
+right [in backend.Parallelmove]
+rlw_accepting [in lib.Integers]
+rlw_transition [in lib.Integers]
+rol [in lib.Integers]
+rolm [in backend.Values]
+rolm [in backend.Cmconstr]
+rolm [in lib.Integers]
+rolm_match [in backend.Cmconstr]
+

S

+sameclass [in lib.union_find]
+sameclass [in lib.union_find]
+sameEnv [in backend.Parallelmove]
+sameExec [in backend.Parallelmove]
+same_expr_pure [in backend.Cmconstr]
+same_typ [in backend.Coloring]
+save_callee_save [in backend.Stacking]
+save_float_callee_save [in backend.Stacking]
+save_int_callee_save [in backend.Stacking]
+set [in lib.Maps]
+set [in backend.Locations]
+set [in lib.Maps]
+set [in lib.Maps]
+set [in lib.Lattice]
+set [in lib.Maps]
+setN [in backend.Mem]
+set_cont [in backend.Mem]
+set_locals [in backend.Cminor]
+set_params [in backend.Cminor]
+Sexec [in backend.Parallelmove]
+sexec [in backend.Parallelmove]
+shift_match [in backend.Cmconstr]
+shift_sp [in backend.Stackingproof]
+shl [in lib.Integers]
+shl [in backend.Cmconstr]
+shl [in backend.Values]
+shlimm [in backend.Cmconstr]
+shr [in lib.Integers]
+shr [in backend.Cmconstr]
+shr [in backend.Values]
+shru [in backend.Cmconstr]
+shru [in lib.Integers]
+shru [in backend.Values]
+shruimm [in backend.Cmconstr]
+shrx [in lib.Integers]
+shrx [in backend.Values]
+shr_carry [in backend.Values]
+shr_carry [in lib.Integers]
+signed [in lib.Integers]
+simpleDest [in backend.Parallelmove]
+singleoffloat [in backend.Values]
+singleoffloat [in backend.Cmconstr]
+sizeof [in backend.Csharpminor]
+size_arguments [in backend.Conventions]
+size_arguments_rec [in backend.Conventions]
+size_chunk [in backend.Mem]
+size_mem [in backend.Mem]
+slots_of_instr [in backend.Lineartyping]
+slot_bounded [in backend.Lineartyping]
+slot_bounded [in backend.LTLtyping]
+slot_type [in backend.Locations]
+Some [in backend.Parallelmove]
+sort_bin [in lib.Inclusion]
+split_move [in backend.Parallelmove]
+split_move' [in backend.Parallelmove]
+starts_with [in backend.Linearize]
+start_state [in backend.Kildall]
+start_state_in [in backend.Kildall]
+start_state_wrk [in backend.Kildall]
+State [in backend.Parallelmove]
+StateBeing [in backend.Parallelmove]
+StateDone [in backend.Parallelmove]
+StateToMove [in backend.Parallelmove]
+state_extends [in backend.RTLgenproof1]
+state_invariant [in backend.Kildall]
+step [in backend.Kildall]
+step [in backend.Kildall]
+stepf [in backend.Parallelmove]
+stepf' [in backend.Parallelmove]
+stepInv [in backend.Parallelmove]
+step_NF [in backend.Parallelmove]
+store [in backend.Cmconstr]
+store [in backend.Mem]
+storeind [in backend.PPCgen]
+storeind_aux [in backend.PPCgen]
+storev [in backend.Mem]
+store1 [in backend.PPC]
+store2 [in backend.PPC]
+store_contents [in backend.Mem]
+store_parameters [in backend.Cminorgen]
+store_stack [in backend.Mach]
+sub [in backend.Values]
+sub [in lib.Integers]
+sub [in backend.Cmconstr]
+subf [in backend.Values]
+subf [in backend.Cmconstr]
+subf_match [in backend.Cmconstr]
+sub_match [in backend.Cmconstr]
+sub_match_aux [in backend.Cmconstr]
+successors [in backend.LTL]
+successors [in backend.RTL]
+successors_aux [in backend.LTL]
+sum_left_map [in lib.Coqlib]
+swap_comparison [in backend.AST]
+symbol_offset [in backend.PPC]
+s1 [in backend.Linearize]
+

T

+t [in backend.PPC]
+t [in lib.Ordered]
+t [in lib.Maps]
+t [in lib.Maps]
+t [in lib.Lattice]
+t [in backend.Locations]
+t [in backend.Constprop]
+t [in lib.Ordered]
+t [in backend.Globalenvs]
+t [in lib.Lattice]
+T [in backend.RTLtyping]
+T [in lib.union_find]
+t [in backend.CSEproof]
+t [in backend.Locations]
+t [in lib.Maps]
+T [in backend.Parallelmove]
+t [in lib.Maps]
+T [in backend.RTLtyping]
+t [in backend.InterfGraph]
+t [in lib.Maps]
+t [in lib.Ordered]
+t [in lib.Lattice]
+t [in backend.Mach]
+t [in lib.Sets]
+t [in lib.Maps]
+t [in backend.CSE]
+temporaries [in backend.Conventions]
+temporaries1 [in backend.Allocproof_aux]
+temporaries1_3 [in backend.Allocproof_aux]
+temporaries2 [in backend.Allocproof_aux]
+teq [in backend.RTLtyping]
+test_inclusion [in lib.Inclusion]
+Tint [in backend.Allocation]
+top [in lib.Lattice]
+top [in lib.Lattice]
+top [in backend.CSE]
+top [in backend.Constprop]
+top [in lib.Lattice]
+transfer [in backend.Allocation]
+transfer [in backend.Constprop]
+transfer [in backend.CSE]
+transform_partial_program [in backend.AST]
+transform_program [in backend.AST]
+transf_cminor_function [in backend.Main]
+transf_cminor_program [in backend.Main]
+transf_cminor_program2 [in backend.Main]
+transf_code [in backend.Constprop]
+transf_code [in backend.CSE]
+transf_csharpminor_function [in backend.Main]
+transf_csharpminor_program [in backend.Main]
+transf_csharpminor_program2 [in backend.Main]
+transf_entrypoint [in backend.Allocation]
+transf_function [in backend.Linearize]
+transf_function [in backend.Allocation]
+transf_function [in backend.CSE]
+transf_function [in backend.RTL]
+transf_function [in backend.PPCgen]
+transf_function [in backend.Stacking]
+transf_function [in backend.Constprop]
+transf_instr [in backend.Allocation]
+transf_instr [in backend.Constprop]
+transf_instr [in backend.CSE]
+transf_partial [in backend.Globalenvs]
+transf_partial_program [in backend.AST]
+transf_program [in backend.CSE]
+transf_program [in backend.PPCgen]
+transf_program [in backend.Stacking]
+transf_program [in backend.Constprop]
+transf_program [in backend.Allocation]
+transf_program [in backend.Linearize]
+transf_program [in backend.AST]
+transl_addr [in backend.Stacking]
+transl_body [in backend.Stacking]
+transl_code [in backend.PPCgen]
+transl_code [in backend.Stacking]
+transl_cond [in backend.PPCgen]
+transl_condition_correct [in backend.RTLgenproof]
+transl_condition_incr_pred [in backend.RTLgenproof1]
+transl_expr [in backend.RTLgen]
+transl_expr [in backend.Cminorgen]
+transl_exprlist_correct [in backend.RTLgenproof]
+transl_exprlist_incr_pred [in backend.RTLgenproof1]
+transl_expr_correct [in backend.RTLgenproof]
+transl_expr_incr_pred [in backend.RTLgenproof1]
+transl_fun [in backend.RTLgen]
+transl_function [in backend.Cminorgen]
+transl_function [in backend.PPCgen]
+transl_function [in backend.RTLgen]
+transl_function_correct [in backend.RTLgenproof]
+transl_instr [in backend.PPCgen]
+transl_instr [in backend.Stacking]
+transl_load_store [in backend.PPCgen]
+transl_op [in backend.Stacking]
+transl_op [in backend.PPCgen]
+transl_program [in backend.RTLgen]
+transl_program [in backend.Cminorgen]
+transl_stmt [in backend.Cminorgen]
+transl_stmt [in backend.RTLgen]
+transl_stmtlist_correct [in backend.RTLgenproof]
+transl_stmtlist_incr_pred [in backend.RTLgenproof1]
+transl_stmt_correct [in backend.RTLgenproof]
+transl_stmt_incr_pred [in backend.RTLgenproof1]
+tunneled_code [in backend.Tunnelingproof]
+tunnel_block [in backend.Tunneling]
+tunnel_function [in backend.Tunneling]
+tunnel_outcome [in backend.Tunnelingproof]
+tunnel_program [in backend.Tunneling]
+type [in backend.Locations]
+typenv [in backend.Registers]
+typesize [in backend.AST]
+typesize [in backend.Locations]
+type_of_addressing [in backend.Op]
+type_of_chunk [in backend.Op]
+type_of_condition [in backend.Op]
+type_of_index [in backend.Stackingproof]
+type_of_operation [in backend.Op]
+type_of_sig_res [in backend.RTLtyping]
+type_rtl_arg [in backend.RTLtyping]
+type_rtl_function [in backend.RTLtyping]
+type_rtl_instr [in backend.RTLtyping]
+type_rtl_ros [in backend.RTLtyping]
+

U

+unchecked_store [in backend.Mem]
+union [in lib.Sets]
+unique_labels [in backend.Linearizeproof]
+unsigned [in lib.Integers]
+update [in backend.Mem]
+update [in backend.Parallelmove]
+update_instr [in backend.RTLgen]
+

V

+valid_block [in backend.Mem]
+valid_outcome [in backend.Linearizeproof]
+valid_pointer [in backend.Mem]
+valnum [in backend.CSE]
+valnum_reg [in backend.CSE]
+valnum_regs [in backend.CSE]
+Value [in backend.Parallelmove]
+valu_agree [in backend.CSEproof]
+val_cond_reg [in backend.PPC]
+val_match_approx [in backend.Constpropproof]
+val_normalized [in backend.Cminorgenproof]
+var_addr [in backend.Cminorgen]
+var_get [in backend.Cminorgen]
+var_set [in backend.Cminorgen]
+Vfalse [in backend.Values]
+Vmone [in backend.Values]
+Vone [in backend.Values]
+Vtrue [in backend.Values]
+Vzero [in backend.Values]
+

W

+wf_equation [in backend.CSEproof]
+wf_numbering [in backend.CSEproof]
+wf_rhs [in backend.CSEproof]
+wordsize [in lib.Integers]
+wt_content [in backend.Machtyping]
+wt_frame [in backend.Machtyping]
+wt_function [in backend.LTLtyping]
+wt_function [in backend.Lineartyping]
+wt_instrs [in backend.Stackingtyping]
+wt_program [in backend.Lineartyping]
+wt_program [in backend.RTLtyping]
+wt_program [in backend.LTLtyping]
+wt_program [in backend.Machtyping]
+wt_regset [in backend.RTLtyping]
+wt_regset [in backend.Machtyping]
+

X

+xcombine_l [in lib.Maps]
+xcombine_r [in lib.Maps]
+xelements [in lib.Maps]
+xget [in lib.Maps]
+xkeys [in lib.Maps]
+xmap [in lib.Maps]
+xor [in backend.Cmconstr]
+xor [in backend.Values]
+xor [in lib.Integers]
+xorimm [in backend.PPCgen]
+

Z

+Zdiv_round [in lib.Integers]
+zeq [in lib.Coqlib]
+zero [in lib.Integers]
+zle [in lib.Coqlib]
+zlt [in lib.Coqlib]
+Zmod_round [in lib.Integers]
+ztonat [in backend.Mem]
+Z_bin_decomp [in lib.Integers]
+Z_of_bits [in lib.Integers]
+Z_one_bits [in lib.Integers]
+Z_shift_add [in lib.Integers]
+

+

Module Index

+

A

+Approx [in backend.Constprop]
+

B

+BACKWARD_DATAFLOW_SOLVER [in backend.Kildall]
+Backward_Dataflow_Solver [in backend.Kildall]
+BBlock_solver [in backend.Kildall]
+BBLOCK_SOLVER [in backend.Kildall]
+

D

+D [in backend.Constprop]
+Dataflow_Solver [in backend.Kildall]
+DATAFLOW_SOLVER [in backend.Kildall]
+DS [in backend.Kildall]
+DS [in backend.Constprop]
+DS [in backend.Linearize]
+DS [in backend.Allocation]
+

E

+ELEMENT [in lib.union_find]
+EMap [in lib.Maps]
+EQUALITY_TYPE [in lib.Maps]
+

F

+Float [in lib.Floats]
+

G

+Genv [in backend.Globalenvs]
+GENV [in backend.Globalenvs]
+

I

+Identset [in backend.Cminorgen]
+IMap [in lib.Maps]
+IndexedMreg [in backend.Locations]
+INDEXED_TYPE [in lib.Maps]
+Int [in lib.Integers]
+

L

+L [in backend.Kildall]
+L [in backend.Kildall]
+L [in backend.Kildall]
+L [in backend.Kildall]
+L [in backend.Kildall]
+L [in backend.Kildall]
+L [in backend.Kildall]
+L [in backend.Kildall]
+L [in backend.Kildall]
+LBoolean [in lib.Lattice]
+LFlat [in lib.Lattice]
+Loc [in backend.Locations]
+Locmap [in backend.Locations]
+LPMap [in lib.Lattice]
+

M

+MakeSet [in lib.Sets]
+MAP [in lib.Maps]
+MAP [in lib.union_find]
+mymap [in backend.RTLtyping]
+myreg [in backend.RTLtyping]
+

N

+NIndexed [in lib.Maps]
+NMap [in lib.Maps]
+Numbering [in backend.CSE]
+

O

+OrderedIndexed [in lib.Ordered]
+OrderedMreg [in backend.InterfGraph]
+OrderedPair [in lib.Ordered]
+OrderedPositive [in lib.Ordered]
+OrderedReg [in backend.InterfGraph]
+OrderedRegMreg [in backend.InterfGraph]
+OrderedRegReg [in backend.InterfGraph]
+ORDERED_TYPE_WITH_TOP [in backend.Kildall]
+

P

+PMap [in lib.Maps]
+PregEq [in backend.PPC]
+Pregmap [in backend.PPC]
+PTree [in lib.Maps]
+

R

+Reg [in backend.Registers]
+RegEq [in backend.Mach]
+Regmap [in backend.Mach]
+Regmap [in backend.Registers]
+Regset [in backend.Registers]
+

S

+SEMILATTICE [in lib.Lattice]
+SEMILATTICE_WITH_TOP [in lib.Lattice]
+SetDepRegMreg [in backend.InterfGraph]
+SetDepRegReg [in backend.InterfGraph]
+SetRegMreg [in backend.InterfGraph]
+SetRegReg [in backend.InterfGraph]
+Solver [in backend.CSE]
+

T

+TREE [in lib.Maps]
+

U

+Uf [in backend.RTLtyping]
+UNIONFIND [in lib.union_find]
+Unionfind [in lib.union_find]
+

V

+Val [in backend.Values]
+ValnumEq [in backend.CSEproof]
+VMap [in backend.CSEproof]
+

Z

+ZIndexed [in lib.Maps]
+ZMap [in lib.Maps]
+

+

Library Index

+

A

+Allocation
+Allocproof
+Allocproof_aux
+Alloctyping
+Alloctyping_aux
+AST
+

C

+Cmconstr
+Cmconstrproof
+Cminor
+Cminorgen
+Cminorgenproof
+Coloring
+Coloringproof
+Constprop
+Constpropproof
+Conventions
+Coqlib
+CSE
+CSEproof
+Csharpminor
+

F

+Floats
+

G

+Globalenvs
+

I

+Inclusion
+Integers
+InterfGraph
+

K

+Kildall
+

L

+Lattice
+Linear
+Linearize
+Linearizeproof
+Linearizetyping
+Lineartyping
+Locations
+LTL
+LTLtyping
+

M

+Mach
+Machabstr
+Machabstr2mach
+Machtyping
+Main
+Maps
+Mem
+

O

+Op
+Ordered
+

P

+Parallelmove
+PPC
+PPCgen
+PPCgenproof
+PPCgenproof1
+

R

+Registers
+RTL
+RTLgen
+RTLgenproof
+RTLgenproof1
+RTLtyping
+

S

+Sets
+Stacking
+Stackingproof
+Stackingtyping
+

T

+Tunneling
+Tunnelingproof
+Tunnelingtyping
+

U

+union_find
+

V

+Values
+

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Global IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(3806 entries)
Axiom IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(39 entries)
Lemma IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(1753 entries)
Constructor IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(700 entries)
Inductive IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(155 entries)
Definition IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(1017 entries)
Module IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(78 entries)
Library IndexABCDEFGHIJKLMNOPQRSTUVWXYZ_(64 entries)
+
This page has been generated by coqdoc + + \ No newline at end of file diff --git a/doc/removeproofs b/doc/removeproofs new file mode 100755 index 0000000..0ebe3a8 --- /dev/null +++ b/doc/removeproofs @@ -0,0 +1,8 @@ +#!/bin/sh + +for i in $*; do + mv $i $i.bak + sed -e '/Proof<\/code>\./,/Qed<\/code>\./d' $i.bak > $i + rm $i.bak +done + diff --git a/doc/style.css b/doc/style.css new file mode 100644 index 0000000..9c1eb49 --- /dev/null +++ b/doc/style.css @@ -0,0 +1,32 @@ +a:visited {color : #416DFF; text-decoration : none; } +a:link {color : #416DFF; text-decoration : none; font-weight : bold} +a:hover {color : Red; text-decoration : underline; } +a:active {color : Red; text-decoration : underline; } +.keyword { font-weight : bold ; color : Red } +.keywordsign { color : #C04600 } +.superscript { font-size : 4 } +.subscript { font-size : 4 } +.comment { color : Green } +.constructor { color : Blue } +.string { color : Maroon } +.warning { color : Red ; font-weight : bold } +.info { margin-left : 3em; margin-right : 3em } +#.title1 { font-size : 20pt ; background-color : #416DFF } +#.title2 { font-size : 20pt ; background-color : #418DFF } +#.title3 { font-size : 20pt ; background-color : #41ADFF } +#.title4 { font-size : 20pt ; background-color : #41CDFF } +#.title5 { font-size : 20pt ; background-color : #41EDFF } +#.title6 { font-size : 20pt ; background-color : #41FFFF } +body { + color: black; background: white; + margin-left: 10%; margin-right: 5%; +} +tr { background-color : White } +# .doc { background-color :#aaeeff } +# .doc { background-color :#66ff66 } +.doc { margin-left: -5%; } +.docright { margin-left: 40%; } +h1 { margin-left: -10%; text-align: right; } +h2 { margin-left: -5%; } +h3,h4,h5,h6 { margin-left: -3%; } +hr { margin-left: -10%; margin-right:-10%; } -- cgit v1.2.3