Module Clflags

module Clflags: sig .. end

---

module Int_arg_helper: sig .. end

module Float_arg_helper: sig .. end

type inlining_arguments = {

	inline_call_cost : int option;
	inline_alloc_cost : int option;
	inline_prim_cost : int option;
	inline_branch_cost : int option;
	inline_indirect_cost : int option;
	inline_lifting_benefit : int option;
	inline_branch_factor : float option;
	inline_max_depth : int option;
	inline_max_unroll : int option;
	inline_threshold : float option;
	inline_toplevel_threshold : int option;

}

let classic_arguments: inlining_arguments;

let o1_arguments: inlining_arguments;

let o2_arguments: inlining_arguments;

let o3_arguments: inlining_arguments;

let use_inlining_arguments_set: (~round: int=?, inlining_arguments) => unit;

let objfiles: ref(list(string));

let ccobjs: ref(list(string));

let dllibs: ref(list(string));

let compile_only: ref(bool);

let output_name: ref(option(string));

let include_dirs: ref(list(string));

let no_std_include: ref(bool);

let print_types: ref(bool);

let make_archive: ref(bool);

let debug: ref(bool);

let debug_full: ref(bool);

let unsafe: ref(bool);

let use_linscan: ref(bool);

let link_everything: ref(bool);

let custom_runtime: ref(bool);

let no_check_prims: ref(bool);

let bytecode_compatible_32: ref(bool);

let output_c_object: ref(bool);

let output_complete_object: ref(bool);

let output_complete_executable: ref(bool);

let all_ccopts: ref(list(string));

let classic: ref(bool);

let nopervasives: ref(bool);

let match_context_rows: ref(int);

let open_modules: ref(list(string));

let preprocessor: ref(option(string));

let all_ppx: ref(list(string));

let absname: ref(bool);

let annotations: ref(bool);

let binary_annotations: ref(bool);

let use_threads: ref(bool);

let noassert: ref(bool);

let verbose: ref(bool);

let noprompt: ref(bool);

let nopromptcont: ref(bool);

let init_file: ref(option(string));

let noinit: ref(bool);

let noversion: ref(bool);

let use_prims: ref(string);

let use_runtime: ref(string);

let plugin: ref(bool);

let principal: ref(bool);

let real_paths: ref(bool);

let recursive_types: ref(bool);

let strict_sequence: ref(bool);

let strict_formats: ref(bool);

let applicative_functors: ref(bool);

let make_runtime: ref(bool);

let c_compiler: ref(option(string));

let no_auto_link: ref(bool);

let dllpaths: ref(list(string));

let make_package: ref(bool);

let for_package: ref(option(string));

let error_size: ref(int);

let float_const_prop: ref(bool);

let transparent_modules: ref(bool);

let unique_ids: ref(bool);

let locations: ref(bool);

let dump_source: ref(bool);

let dump_parsetree: ref(bool);

let dump_typedtree: ref(bool);

let dump_rawlambda: ref(bool);

let dump_lambda: ref(bool);

let dump_rawclambda: ref(bool);

let dump_clambda: ref(bool);

let dump_rawflambda: ref(bool);

let dump_flambda: ref(bool);

let dump_flambda_let: ref(option(int));

let dump_instr: ref(bool);

let keep_camlprimc_file: ref(bool);

let keep_asm_file: ref(bool);

let optimize_for_speed: ref(bool);

let dump_cmm: ref(bool);

let dump_selection: ref(bool);

let dump_cse: ref(bool);

let dump_live: ref(bool);

let dump_avail: ref(bool);

let debug_runavail: ref(bool);

let dump_spill: ref(bool);

let dump_split: ref(bool);

let dump_interf: ref(bool);

let dump_prefer: ref(bool);

let dump_regalloc: ref(bool);

let dump_reload: ref(bool);

let dump_scheduling: ref(bool);

let dump_linear: ref(bool);

let dump_interval: ref(bool);

let keep_startup_file: ref(bool);

let dump_combine: ref(bool);

let native_code: ref(bool);

let default_inline_threshold: float;

let inline_threshold: ref(Float_arg_helper.parsed);

let inlining_report: ref(bool);

let simplify_rounds: ref(option(int));

let default_simplify_rounds: ref(int);

let rounds: unit => int;

let default_inline_max_unroll: int;

let inline_max_unroll: ref(Int_arg_helper.parsed);

let default_inline_toplevel_threshold: int;

let inline_toplevel_threshold: ref(Int_arg_helper.parsed);

let default_inline_call_cost: int;

let default_inline_alloc_cost: int;

let default_inline_prim_cost: int;

let default_inline_branch_cost: int;

let default_inline_indirect_cost: int;

let default_inline_lifting_benefit: int;

let inline_call_cost: ref(Int_arg_helper.parsed);

let inline_alloc_cost: ref(Int_arg_helper.parsed);

let inline_prim_cost: ref(Int_arg_helper.parsed);

let inline_branch_cost: ref(Int_arg_helper.parsed);

let inline_indirect_cost: ref(Int_arg_helper.parsed);

let inline_lifting_benefit: ref(Int_arg_helper.parsed);

let default_inline_branch_factor: float;

let inline_branch_factor: ref(Float_arg_helper.parsed);

let dont_write_files: ref(bool);

let std_include_flag: string => string;

let std_include_dir: unit => list(string);

let shared: ref(bool);

let dlcode: ref(bool);

let pic_code: ref(bool);

let runtime_variant: ref(string);

let with_runtime: ref(bool);

let force_slash: ref(bool);

let keep_docs: ref(bool);

let keep_locs: ref(bool);

let unsafe_string: ref(bool);

let opaque: ref(bool);

let profile_columns: ref(list(Profile.column));

let flambda_invariant_checks: ref(bool);

let unbox_closures: ref(bool);

let unbox_closures_factor: ref(int);

let default_unbox_closures_factor: int;

let unbox_free_vars_of_closures: ref(bool);

let unbox_specialised_args: ref(bool);

let clambda_checks: ref(bool);

let default_inline_max_depth: int;

let inline_max_depth: ref(Int_arg_helper.parsed);

let remove_unused_arguments: ref(bool);

let dump_flambda_verbose: ref(bool);

let classic_inlining: ref(bool);

let afl_instrument: ref(bool);

let afl_inst_ratio: ref(int);

let function_sections: ref(bool);

let all_passes: ref(list(string));

let dumped_pass: string => bool;

let set_dumped_pass: (string, bool) => unit;

let dump_into_file: ref(bool);

type 'a env_reader = {

	parse : string -> 'a option;
	print : 'a -> string;
	usage : string;
	env_var : string;

}

let color: ref(option(Misc.Color.setting));

let color_reader: env_reader(Misc.Color.setting);

let error_style: ref(option(Misc.Error_style.setting));

let error_style_reader: env_reader(Misc.Error_style.setting);

let unboxed_types: ref(bool);

let insn_sched: ref(bool);

let insn_sched_default: bool;

module Compiler_pass: sig .. end

let stop_after: ref(option(Compiler_pass.t));

let should_stop_after: Compiler_pass.t => bool;

let set_save_ir_after: (Compiler_pass.t, bool) => unit;

let should_save_ir_after: Compiler_pass.t => bool;

let arg_spec: ref(list((string, Arg.spec, string)));

let add_arguments: (string, list((string, Arg.spec, string))) => unit;

let parse_arguments: (array(string), Arg.anon_fun, string) => unit;

let print_arguments: string => unit;

let reset_arguments: unit => unit;