diff options
Diffstat (limited to 'lib/hipe/main')
| -rw-r--r-- | lib/hipe/main/Makefile | 117 | ||||
| -rw-r--r-- | lib/hipe/main/hipe.app.src | 222 | ||||
| -rw-r--r-- | lib/hipe/main/hipe.appup.src | 19 | ||||
| -rw-r--r-- | lib/hipe/main/hipe.erl | 1555 | ||||
| -rw-r--r-- | lib/hipe/main/hipe.hrl.src | 322 | ||||
| -rw-r--r-- | lib/hipe/main/hipe_main.erl | 549 |
6 files changed, 2784 insertions, 0 deletions
diff --git a/lib/hipe/main/Makefile b/lib/hipe/main/Makefile new file mode 100644 index 0000000000..0ac522b1b2 --- /dev/null +++ b/lib/hipe/main/Makefile @@ -0,0 +1,117 @@ +# +# %CopyrightBegin% +# +# Copyright Ericsson AB 2001-2009. All Rights Reserved. +# +# The contents of this file are subject to the Erlang Public License, +# Version 1.1, (the "License"); you may not use this file except in +# compliance with the License. You should have received a copy of the +# Erlang Public License along with this software. If not, it can be +# retrieved online at http://www.erlang.org/. +# +# Software distributed under the License is distributed on an "AS IS" +# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +# the License for the specific language governing rights and limitations +# under the License. +# +# %CopyrightEnd% +# + +ifndef EBIN +EBIN = ../ebin +endif + +ifndef DOCS +DOCS = ../doc +endif + +include $(ERL_TOP)/make/target.mk +include $(ERL_TOP)/make/$(TARGET)/otp.mk + +# ---------------------------------------------------- +# Application version +# ---------------------------------------------------- +include ../vsn.mk +VSN=$(HIPE_VSN) + +# ---------------------------------------------------- +# Release directory specification +# ---------------------------------------------------- +RELSYSDIR = $(RELEASE_PATH)/lib/hipe-$(VSN) + +# ---------------------------------------------------- +# Target Specs +# ---------------------------------------------------- +ifdef HIPE_ENABLED +HIPE_MODULES = hipe +else +HIPE_MODULES = +endif +MODULES = hipe_main $(HIPE_MODULES) + +## hipe.hrl is automatically generated from hipe.hrl.src -- see below +HRL_FILES= hipe.hrl +ERL_FILES= $(MODULES:%=%.erl) +TARGET_FILES= $(MODULES:%=$(EBIN)/%.$(EMULATOR)) $(APP_TARGET) $(APPUP_TARGET) +DOC_FILES= $(MODULES:%=$(DOCS)/%.html) + +APP_FILE= hipe.app +APP_SRC= $(APP_FILE).src +APP_TARGET= $(EBIN)/$(APP_FILE) + +APPUP_FILE= hipe.appup +APPUP_SRC= $(APPUP_FILE).src +APPUP_TARGET= $(EBIN)/$(APPUP_FILE) + +# ---------------------------------------------------- +# FLAGS +# ---------------------------------------------------- + +include ../native.mk + +ERL_COMPILE_FLAGS += +nowarn_shadow_vars +warn_missing_spec +warn_untyped_record + +# ---------------------------------------------------- +# Targets +# ---------------------------------------------------- + +hipe.hrl: ../vsn.mk hipe.hrl.src + sed -e "s;%VSN%;$(HIPE_VSN);" ../../hipe/main/hipe.hrl.src > ../../hipe/main/hipe.hrl + +$(EBIN)/hipe.beam: hipe.hrl ../../compiler/src/beam_disasm.hrl +$(EBIN)/hipe_main.beam: hipe.hrl ../icode/hipe_icode.hrl #../rtl/hipe_rtl.hrl + +debug opt: $(TARGET_FILES) + +docs: $(DOC_FILES) + +clean: + rm -f $(TARGET_FILES) $(DOC_FILES) $(HRL_FILES) + rm -f core + +$(DOCS)/%.html:%.erl + erl -noshell -run edoc_run file '"$<"' '[{dir, "$(DOCS)"}]' -s init stop + +# ---------------------------------------------------- +# Special Build Targets +# ---------------------------------------------------- + +$(APP_TARGET): $(APP_SRC) ../vsn.mk + sed -e 's;%VSN%;$(VSN);' $< > $@ + +$(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk + sed -e 's;%VSN%;$(VSN);' $< > $@ + +# ---------------------------------------------------- +# Release Target +# ---------------------------------------------------- +include $(ERL_TOP)/make/otp_release_targets.mk + +release_spec: opt + $(INSTALL_DATA) ../vsn.mk $(RELSYSDIR) + $(INSTALL_DIR) $(RELSYSDIR)/main + $(INSTALL_DATA) $(ERL_FILES) $(HRL_FILES) $(RELSYSDIR)/main + $(INSTALL_DIR) $(RELSYSDIR)/ebin + $(INSTALL_DATA) $(TARGET_FILES) $(RELSYSDIR)/ebin + +release_docs_spec: diff --git a/lib/hipe/main/hipe.app.src b/lib/hipe/main/hipe.app.src new file mode 100644 index 0000000000..e5d6d1e540 --- /dev/null +++ b/lib/hipe/main/hipe.app.src @@ -0,0 +1,222 @@ +%% This is an -*- erlang -*- file. +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2002-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% + +{application, hipe, + [{description, "HiPE Native Code Compiler, version %VSN%"}, + {vsn, "%VSN%"}, + {modules, [cerl_cconv, + cerl_closurean, + cerl_hipeify, + cerl_hybrid_transform, + cerl_lib, + cerl_messagean, + cerl_pmatch, + cerl_prettypr, + cerl_to_icode, + cerl_typean, + erl_bif_types, + erl_types, + hipe, + hipe_adj_list, + hipe_amd64_assemble, + hipe_amd64_defuse, + hipe_amd64_encode, + hipe_amd64_frame, + hipe_amd64_liveness, + hipe_amd64_main, + hipe_amd64_pp, + hipe_amd64_ra, + hipe_amd64_ra_finalise, + hipe_amd64_ra_ls, + hipe_amd64_ra_naive, + hipe_amd64_ra_postconditions, + hipe_amd64_ra_sse2_postconditions, + hipe_amd64_ra_x87_ls, + hipe_amd64_registers, + hipe_amd64_specific, + hipe_amd64_specific_sse2, + hipe_amd64_specific_x87, + hipe_amd64_spill_restore, + hipe_amd64_x87, + hipe_arm, + hipe_arm_assemble, + hipe_arm_cfg, + hipe_arm_defuse, + hipe_arm_encode, + hipe_arm_finalise, + hipe_arm_frame, + hipe_arm_liveness_gpr, + hipe_arm_main, + hipe_arm_pp, + hipe_arm_ra, + hipe_arm_ra_finalise, + hipe_arm_ra_ls, + hipe_arm_ra_naive, + hipe_arm_ra_postconditions, + hipe_arm_registers, + hipe_arm_specific, + hipe_bb, + hipe_beam_to_icode, + hipe_ceach, + hipe_coalescing_regalloc, + hipe_consttab, + hipe_data_pp, + hipe_digraph, + hipe_dominators, + hipe_dot, + hipe_gen_cfg, + hipe_gensym, + hipe_graph_coloring_regalloc, + hipe_icode, + hipe_icode2rtl, + hipe_icode_bincomp, + hipe_icode_callgraph, + hipe_icode_cfg, + hipe_icode_coordinator, + hipe_icode_ebb, + hipe_icode_exceptions, + hipe_icode_fp, + hipe_icode_heap_test, + hipe_icode_inline_bifs, + hipe_icode_instruction_counter, + hipe_icode_liveness, + hipe_icode_mulret, + hipe_icode_pp, + hipe_icode_primops, + hipe_icode_range, + hipe_icode_ssa, + hipe_icode_ssa_const_prop, + hipe_icode_ssa_copy_prop, + hipe_icode_ssa_struct_reuse, + hipe_icode_split_arith, + hipe_icode_type, + hipe_ig, + hipe_ig_moves, + hipe_jit, + hipe_ls_regalloc, + hipe_main, + hipe_moves, + hipe_node_sets, + hipe_optimistic_regalloc, + hipe_pack_constants, + hipe_ppc, + hipe_ppc_assemble, + hipe_ppc_cfg, + hipe_ppc_defuse, + hipe_ppc_encode, + hipe_ppc_finalise, + hipe_ppc_frame, + hipe_ppc_liveness_all, + hipe_ppc_liveness_fpr, + hipe_ppc_liveness_gpr, + hipe_ppc_main, + hipe_ppc_pp, + hipe_ppc_ra, + hipe_ppc_ra_finalise, + hipe_ppc_ra_ls, + hipe_ppc_ra_naive, + hipe_ppc_ra_postconditions, + hipe_ppc_ra_postconditions_fp, + hipe_ppc_registers, + hipe_ppc_specific, + hipe_ppc_specific_fp, + hipe_profile, + hipe_reg_worklists, + hipe_regalloc_loop, + hipe_rtl, + hipe_rtl_arch, + hipe_rtl_arith_32, + hipe_rtl_arith_64, + hipe_rtl_binary, + hipe_rtl_binary_match, + hipe_rtl_binary_construct, + hipe_rtl_cfg, + hipe_rtl_cleanup_const, + hipe_rtl_exceptions, + hipe_rtl_lcm, + hipe_rtl_liveness, + hipe_rtl_mk_switch, + hipe_rtl_primops, + hipe_rtl_ssa, + hipe_rtl_ssa_const_prop, + hipe_rtl_ssa_avail_expr, + hipe_rtl_ssapre, + hipe_rtl_symbolic, + hipe_rtl_to_amd64, + hipe_rtl_to_arm, + hipe_rtl_to_ppc, + hipe_rtl_to_sparc, + hipe_rtl_to_x86, + hipe_rtl_varmap, + hipe_sdi, + hipe_sparc, + hipe_sparc_assemble, + hipe_sparc_cfg, + hipe_sparc_defuse, + hipe_sparc_encode, + hipe_sparc_finalise, + hipe_sparc_frame, + hipe_sparc_liveness_all, + hipe_sparc_liveness_fpr, + hipe_sparc_liveness_gpr, + hipe_sparc_main, + hipe_sparc_pp, + hipe_sparc_ra, + hipe_sparc_ra_finalise, + hipe_sparc_ra_ls, + hipe_sparc_ra_naive, + hipe_sparc_ra_postconditions, + hipe_sparc_ra_postconditions_fp, + hipe_sparc_registers, + hipe_sparc_specific, + hipe_sparc_specific_fp, + hipe_spillcost, + hipe_spillmin, + hipe_spillmin_color, + hipe_spillmin_scan, + hipe_tagscheme, + hipe_temp_map, + hipe_timing, + hipe_tool, + hipe_vectors, + hipe_x86, + hipe_x86_assemble, + hipe_x86_cfg, + hipe_x86_defuse, + hipe_x86_encode, + hipe_x86_frame, + hipe_x86_liveness, + hipe_x86_main, + hipe_x86_postpass, + hipe_x86_pp, + hipe_x86_ra, + hipe_x86_ra_finalise, + hipe_x86_ra_ls, + hipe_x86_ra_naive, + hipe_x86_ra_postconditions, + hipe_x86_ra_x87_ls, + hipe_x86_registers, + hipe_x86_specific, + hipe_x86_specific_x87, + hipe_x86_spill_restore, + hipe_x86_x87]}, + {registered,[]}, + {applications, [kernel,stdlib]}, + {env, []}]}. diff --git a/lib/hipe/main/hipe.appup.src b/lib/hipe/main/hipe.appup.src new file mode 100644 index 0000000000..1d5a0d93f5 --- /dev/null +++ b/lib/hipe/main/hipe.appup.src @@ -0,0 +1,19 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2002-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +{"%VSN%",[],[]}. diff --git a/lib/hipe/main/hipe.erl b/lib/hipe/main/hipe.erl new file mode 100644 index 0000000000..ed722fecba --- /dev/null +++ b/lib/hipe/main/hipe.erl @@ -0,0 +1,1555 @@ +%% -*- erlang-indent-level: 2 -*- +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2001-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +%% ==================================================================== +%% Copyright (c) 1998 by Erik Johansson. All Rights Reserved +%% ==================================================================== +%% Filename : hipe.erl +%% Module : hipe +%% Purpose : +%% Notes : +%% History : * 1998-01-28 Erik Johansson ([email protected]): Created. +%% CVS : $Id$ +%% ==================================================================== +%% @doc This is the direct interface to the HiPE compiler. +%% +%% <h3>Normal use</h3> +%% +%% <p>The normal way to native-compile an Erlang module using HiPE is to +%% include the atom <code>native</code> in the Erlang compiler options, +%% as in: +%% +%% <pre> 1> c(my_module, [native]).</pre></p> +%% +%% <p>Options to the HiPE compiler are then passed as follows: +%% +%% <pre> 1> c(my_module, [native,{hipe,Options}]).</pre></p> +%% +%% <p>For on-line help in the Erlang shell, call <a +%% href="#help-0"><code>hipe:help()</code></a>. Details on HiPE compiler +%% options are given by <a +%% href="#help_options-0"><code>hipe:help_options()</code></a>.</p> +%% +%% <h3>Using the direct interface - for advanced users only</h3> +%% +%% To compile a module or a specific function to native code and +%% automatically load the code into memory, call <a +%% href="#c-1"><code>hipe:c(Module)</code></a> or <a +%% href="#c-2"><code>hipe:c(Module, Options)</code></a>. Note that all +%% options are specific to the HiPE compiler. See the <a +%% href="#index">function index</a> for other compiler functions. +%% +%% <h3>Main Options</h3> +%% +%% Options are processed in the order they appear in the list; an +%% early option will shadow a later one. +%% <dl> +%% <dt><code>o0, 'O0', o1, 'O1', o2, 'O2', o3, 'O3'</code></dt> +%% <dd>Set optimization level (default 2).</dd> +%% +%% <dt><code>load</code></dt> +%% <dd>Automatically load the code into memory after compiling.</dd> +%% +%% <dt><code>time</code></dt> +%% <dd>Reports the compilation times for the different stages +%% of the compiler. Call <a +%% href="#help_option-1"><code>hipe:help_option(time)</code></a> for +%% details.</dd> +%% +%% <dt><code>{timeout, Time}</code></dt> +%% <dd>Sets the time the compiler is allowed to use for the +%% compilation. <code>Time</code> is time in ms or the atom +%% <code>infinity</code> (the default).</dd> +%% +%% <dt><code>verbose</code></dt> +%% <dd>Make the HiPE compiler output information about what it is +%% being done.</dd> +%% </dl> +%% +%% <h3>Advanced Options</h3> +%% +%% Note: You can also specify <code>{Option, false}</code> to turn a +%% particular option off, or <code>{Option, true}</code> to force it on. +%% Boolean-valued (<code>true</code>/<code>false</code>) options also +%% have negative-form aliases, e.g. <code>no_load</code> = <code>{load, +%% false}</code>. +%% +%% <p><dl> +%% <dt><code>debug</code></dt> +%% <dd>Outputs internal debugging information during +%% compilation.</dd> +%% +%% <dt><code>icode_ssa_copy_prop</code></dt> +%% <dd>Performs copy propagation on the SSA form on the Icode +%% level.</dd> +%% +%% <dt><code>icode_ssa_const_prop</code></dt> +%% <dd>Performs sparse conditional constant propagation on the SSA +%% form on the Icode level.</dd> +%% +%% <dt><code>icode_ssa_struct_reuse</code></dt> +%% <dd>Tries to factor out identical tuple and list constructions +%% on the Icode level.</dd> +%% +%% <dt><code>icode_type</code></dt> +%% <dd>Simplifies the code by employing type analysis and propagation +%% on the Icode level.</dd> +%% +%% <dt><code>icode_range</code></dt> +%% <dd>Performs integer range analysis on the Icode level.</dd> +%% +%% <dt><code>pp_all</code></dt> +%% <dd>Equivalent to <code>[pp_beam, pp_icode, pp_rtl, +%% pp_native]</code>.</dd> +%% +%% <dt><code>pp_asm</code></dt> +%% <dd>Prints the assembly listing with addresses and bytecode. +%% Currently available for x86 only.</dd> +%% +%% <dt><code>pp_beam, {pp_beam, {file, File}}</code></dt> +%% <dd>Display the input Beam code to stdout or file.</dd> +%% +%% <dt><code>pp_icode, {pp_icode, {file, File}}, +%% {pp_icode, {only, Functions}}</code></dt> +%% <dd>Pretty-print Icode intermediate code to stdout or file.</dd> +%% +%% <dt><code>pp_native, {pp_native, {file, File}}, +%% {pp_native, {only, Functions}}</code></dt> +%% <dd>Pretty-print native code to stdout or file.</dd> +%% +%% <dt><code>pp_opt_icode, {pp_opt_icode, {file, File}}, +%% {pp_opt_icode, {only, Functions}}</code></dt> +%% <dd>Pretty-print optimized Icode to stdout or file.</dd> +%% +%% <dt><code>pp_rtl, {pp_rtl, {file, File}}, +%% {pp_rtl, {only, Functions}}</code></dt> +%% <dd>Pretty-print RTL intermediate code to stdout or file.</dd> +%% +%% <dt><code>regalloc</code></dt> +%% <dd>Select register allocation algorithm. Used as +%% <code>{regalloc, Method}</code>. +%% +%% <p><code>Method</code> is one of the following: +%% <ul> +%% <li><code>naive</code>: spills everything (for debugging and +%% testing only).</li> +%% <li><code>linear_scan</code>: fast compilation; not so good if +%% only few registers available.</li> +%% <li><code>graph_color</code>: slower, but gives better +%% performance.</li> +%% <li><code>coalescing</code>: tries hard to use registers; can be +%% very slow, but typically results in code with best performance.</li> +%% </ul></p></dd> +%% +%% <dt><code>remove_comments</code></dt> +%% <dd>Remove comments from intermediate code.</dd> +%% +%% <dt><code>rtl_ssa_const_prop</code></dt> +%% <dd>Performs sparse conditional constant propagation on the SSA +%% form on the RTL level. </dd> +%% +%% <dt><code>rtl_lcm</code></dt> +%% <dd>Lazy Code Motion on RTL.</dd> +%% +%% <dt><code>rtl_ssapre</code></dt> +%% <dd>Lazy Partial Redundancy Elimination on RTL (SSA level).</dd> +%% +%% <dt><code>use_indexing</code></dt> +%% <dd>Use indexing for multiple-choice branch selection.</dd> +%% +%% <dt><code>use_callgraph</code></dt> +%% <dd>Use a static call graph for determining the order in which +%% the functions of a module should be compiled (in reversed +%% topological sort order).</dd> +%% </dl></p> +%% +%% <h3>Debugging Options</h3> +%% (May require that some modules have been +%% compiled with the <code>DEBUG</code> flag.) +%% <dl> +%% <dt><code>rtl_show_translation</code></dt> +%% <dd>Prints each step in the translation from Icode to RTL</dd> +%% </dl> +%% +%% @end +%% ==================================================================== + +-module(hipe). + +-export([c/1, + c/2, + f/1, + f/2, + compile/1, + compile/2, + compile/4, + compile_core/4, + file/1, + file/2, + load/1, + help/0, + help_hiper/0, + help_options/0, + help_option/1, + help_debug_options/0, + version/0]). + +-ifndef(DEBUG). +-define(DEBUG,true). +-endif. + +-include("hipe.hrl"). +-include("../../compiler/src/beam_disasm.hrl"). + +%%------------------------------------------------------------------- +%% Basic type declaration for exported functions of the 'hipe' module +%%------------------------------------------------------------------- + +-type mod() :: atom(). +-type c_unit() :: mod() | mfa(). +-type f_unit() :: mod() | binary(). +-type ret_rtl() :: [_]. +-type c_ret() :: {'ok', c_unit()} | {'error', term()} | + {'ok', c_unit(), ret_rtl()}. %% The last for debugging only +-type compile_file() :: atom() | string() | binary(). +-type compile_ret() :: {hipe_architecture(), binary()} | list(). + +%%------------------------------------------------------------------- + +-define(COMPILE_DEFAULTS, [o2]). +-define(DEFAULT_TIMEOUT, infinity). + +%%------------------------------------------------------------------- + +%% @spec load(Mod) -> {module, Mod} | {error, Reason} +%% Mod = mod() +%% Reason = term() +%% +%% @doc Like load/2, but tries to locate a BEAM file automatically. +%% +%% @see load/2 + +-spec load(Mod) -> {'module', Mod} | {'error', term()} + when is_subtype(Mod, mod()). + +load(Mod) -> + load(Mod, beam_file(Mod)). + +%% @spec load(Mod, BeamFileName) -> {module, Mod} | {error, Reason} +%% Mod = mod() +%% Reason = term() +%% BeamFileName = string() +%% filename() = term() +%% +%% @type mod() = atom(). A module name. +%% +%% @doc User interface for loading code into memory. The code can be +%% given as a native code binary or as the file name of a BEAM file +%% which should contain a native-code chunk. If only the module name is +%% given (see <code>load/1</code>), the BEAM file is located +%% automatically. +%% +%% @see load/1 + +-spec load(Mod, string()) -> {'module', Mod} | {'error', term()} + when is_subtype(Mod, mod()). + +load(Mod, BeamFileName) when is_list(BeamFileName) -> + Architecture = erlang:system_info(hipe_architecture), + ChunkName = hipe_unified_loader:chunk_name(Architecture), + case beam_lib:chunks(BeamFileName, [ChunkName]) of + {ok,{_,[{_,Bin}]}} when is_binary(Bin) -> do_load(Mod, Bin, Bin); + Error -> {error, Error} + end. + +%% @spec c(Name) -> {ok, Name} | {error, Reason} +%% Name = mod() | mfa() +%% Reason = term() +%% +%% @equiv c(Name, []) + +-spec c(c_unit()) -> c_ret(). + +c(Name) -> + c(Name, []). + +%% @spec c(Name, options()) -> {ok, Name} | {error, Reason} +%% Name = mod() | mfa() +%% options() = [option()] +%% option() = term() +%% Reason = term() +%% +%% @type mfa() = {M::mod(),F::fun(),A::arity()}. +%% A fully qualified function name. +%% +%% @type fun() = atom(). A function identifier. +%% +%% @type arity() = integer(). A function arity; always nonnegative. +%% +%% @doc User-friendly native code compiler interface. Reads BEAM code +%% from the corresponding "Module<code>.beam</code>" file in the system +%% path, and compiles either a single function or the whole module to +%% native code. By default, the compiled code is loaded directly. See +%% above for documentation of options. +%% +%% @see c/1 +%% @see c/3 +%% @see f/2 +%% @see compile/2 + +-spec c(c_unit(), comp_options()) -> c_ret(). + +c(Name, Options) -> + c(Name, beam_file(Name), Options). + +%% @spec c(Name, File, options()) -> {ok, Name} | {error, Reason} +%% Name = mod() | mfa() +%% File = filename() | binary() +%% Reason = term() +%% +%% @doc Like <code>c/2</code>, but reads BEAM code from the specified +%% <code>File</code>. +%% +%% @see c/2 +%% @see f/2 + +c(Name, File, Opts) -> + %% No server if only one function is compiled + Opts1 = user_compile_opts(Opts), + case compile(Name, File, Opts1) of + {ok, Res} -> + case proplists:get_bool(to_rtl, Opts1) of + true -> {ok, Name, Res}; + false -> {ok, Name} + end; + Other -> + Other + end. + +%% @spec f(File) -> {ok, Name} | {error, Reason} +%% File = filename() | binary() +%% Name = mod() +%% Reason = term() +%% +%% @equiv f(File, []) + +-spec f(f_unit()) -> {'ok', mod()} | {'error', term()}. + +f(File) -> + f(File, []). + +%% @spec f(File, options()) -> {ok, Name} | {error, Reason} +%% File = filename() | binary() +%% Name = mod() +%% Reason = term() +%% +%% @doc Like <code>c/3</code>, but takes the module name from the +%% specified <code>File</code>. This always compiles the whole module; +%% there is no possibility to compile just a single function. +%% +%% @see c/3 + +-spec f(f_unit(), comp_options()) -> {'ok', mod()} | {'error', term()}. + +f(File, Opts) -> + case file(File, user_compile_opts(Opts)) of + {ok, Name, _} -> + {ok, Name}; + Other -> + Other + end. + +-define(USER_DEFAULTS, [load]). + +user_compile_opts(Opts) -> + Opts ++ ?USER_DEFAULTS. + + +%% @spec compile(Name) -> {ok, {Target,Binary}} | {error, Reason} +%% Name = mod() | mfa() +%% Binary = binary() +%% Reason = term() +%% +%% @equiv compile(Name, []) + +-spec compile(c_unit()) -> {'ok', compile_ret()} | {'error', term()}. + +compile(Name) -> + compile(Name, []). + +%% @spec compile(Name, options()) -> {ok, {Target,Binary}} | {error, Reason} +%% Name = mod() | mfa() +%% Binary = binary() +%% Reason = term() +%% +%% @doc Direct compiler interface, for advanced use. This just compiles +%% the named function or module, reading BEAM code from the +%% corresponding "Module<code>.beam</code>" file in the system path. +%% Returns <code>{ok, Binary}</code> if successful, or <code>{error, +%% Reason}</code> otherwise. By default, it does <em>not</em> load the +%% binary to memory (the <code>load</code> option can be used to +%% activate automatic loading). <code>File</code> can be either a file +%% name or a binary containing the BEAM code for the module. +%% +%% @see c/2 +%% @see compile/1 +%% @see compile/3 +%% @see file/2 +%% @see load/2 + +-spec compile(c_unit(), comp_options()) -> {'ok', compile_ret()} | {'error', _}. + +compile(Name, Options) -> + compile(Name, beam_file(Name), Options). + +-spec beam_file(mod() | mfa()) -> string(). + +beam_file({M,F,A}) when is_atom(M), is_atom(F), is_integer(A), A >= 0 -> + beam_file(M); +beam_file(Module) when is_atom(Module) -> + case code:which(Module) of + non_existing -> + ?error_msg("Cannot find ~w.beam file.",[Module]), + ?EXIT({cant_find_beam_file,Module}); + File -> % string() + File + end. + +%% @spec compile(Name, File, options()) -> +%% {ok, {Target, Binary}} | {error, Reason} +%% Name = mod() | mfa() +%% File = filename() | binary() +%% Binary = binary() +%% Reason = term() +%% +%% @doc Like <code>compile/2</code>, but reads BEAM code from the +%% specified <code>File</code>. +%% +%% @see compile/2 + +-spec compile(c_unit(), compile_file(), comp_options()) -> + {'ok', compile_ret()} | {'error', term()}. + +compile(Name, File, Opts0) -> + Opts1 = expand_kt2(Opts0), + Opts = + case Name of + {_Mod, _Fun, _Arity} -> + [no_concurrent_comp|Opts1]; + _ -> + Opts1 + end, + case proplists:get_value(core, Opts) of + true when is_binary(File) -> + ?error_msg("Cannot get Core Erlang code from BEAM binary.",[]), + ?EXIT({cant_compile_core_from_binary}); + true -> + case filename:find_src(filename:rootname(File, ".beam")) of + {error, _} -> + ?error_msg("Cannot find source code for ~p.",[File]), + ?EXIT({cant_find_source_code}); + {Source, CompOpts} -> + CoreOpts = [X || X = {core_transform, _} <- Opts], + %%io:format("Using: ~w\n", [CoreOpts]), + case compile:file(Source, CoreOpts ++ [to_core, binary|CompOpts]) of + {ok, _, Core} -> + compile_core(Name, Core, File, Opts); + Error -> + ?error_msg("Error compiling ~p:\n~p.",[File, Error]), + ?EXIT({cant_compile_source_code}) + end + end; + {src_file, Source} -> + CoreOpts1 = [X || X = {core_transform, _} <- Opts], + CoreOpts2 = [report_errors, to_core, binary, {i,"../include"}|CoreOpts1], + %% io:format("Using: ~w\n", [CoreOpts2]), + case compile:file(Source, CoreOpts2) of + {ok, _, Core} -> + compile_core(Name, Core, File, Opts); + Error -> + ?error_msg("Error compiling ~p:\n~p\n",[Source, Error]), + ?EXIT({cant_compile_source_code, Error}) + end; + Other when Other =:= false; Other =:= undefined -> + NewOpts = + case proplists:get_value(use_callgraph, Opts) of + No when No =:= false; No =:= undefined -> Opts; + _ -> + case Name of + {_M,_F,_A} -> + %% There is no point in using the callgraph or concurrent_comp + %% when analyzing just one function. + [no_use_callgraph, no_concurrent_comp|Opts]; + _ -> Opts + end + end, + DisasmFun = fun (_) -> disasm(File) end, + IcodeFun = fun (Code, Opts_) -> + get_beam_icode(Name, Code, File, Opts_) + end, + run_compiler(Name, DisasmFun, IcodeFun, NewOpts) + end. + +-spec compile_core(mod(), _, compile_file(), comp_options()) -> + {'ok', compile_ret()} | {'error', term()}. + +compile_core(Name, Core0, File, Opts) -> + Core = cerl:from_records(Core0), + Core1 = case (erlang:system_info(heap_type) =:= hybrid) + andalso proplists:get_bool(hybrid, Opts) of + true -> cerl_hybrid_transform:transform(Core, Opts); + false -> Core + end, + compile(Name, Core1, File, Opts). + +%% @spec compile(Name, Core, File, options()) -> +%% {ok, {Target, Binary}} | {error, Reason} +%% Name = mod() +%% Core = coreErlang() | [] +%% File = filename() | binary() +%% Binary = binary() +%% Reason = term() +%% +%% @doc Like <code>compile/3</code>, but unless <code>Core</code> is +%% <code>[]</code>, low-level code is generated from the given Core +%% Erlang code instead of from the BEAM code. +%% +%% <p>Note that only whole modules can be compiled with this +%% function.</p> +%% +%% @see compile/3 + +-spec compile(mod(), _, compile_file(), comp_options()) -> + {'ok', compile_ret()} | {'error', term()}. + +compile(Name, [], File, Opts) -> + compile(Name, File, Opts); +compile(Name, Core, File, Opts) when is_atom(Name) -> + DisasmFun = fun (_) -> {false, []} end, + IcodeFun = fun (_, Opts) -> + get_core_icode(Name, Core, File, Opts) + end, + run_compiler(Name, DisasmFun, IcodeFun, Opts). + +%% @spec file(File) -> {ok, Name, {Target, Binary}} | {error, Reason} +%% File = filename() | binary() +%% Name = mod() | mfa() +%% Binary = binary() +%% Reason = term() +%% +%% @equiv file(File, []) + +-spec file(Mod) -> {'ok', Mod, compile_ret()} | {'error', term()} + when is_subtype(Mod, mod()). + +file(File) -> + file(File, []). + +%% @spec file(File, options()) -> {ok, Name, {Target,Binary}} | {error, Reason} +%% File = filename() +%% Name = mod() | mfa() +%% Binary = binary() +%% Reason = term() +%% +%% @doc Like <code>compile/2</code>, but takes the module name from the +%% specified <code>File</code>. Returns both the name and the final +%% binary if successful. +%% +%% @see file/1 +%% @see compile/2 + +-spec file(Mod, comp_options()) -> {'ok', Mod, compile_ret()} + | {'error', term()} + when is_subtype(Mod, mod()). +file(File, Options) when is_atom(File) -> + case beam_lib:info(File) of + L when is_list(L) -> + {module, Mod} = lists:keyfind(module, 1, L), + case compile(Mod, File, Options) of + {ok, CompRet} -> + {ok, Mod, CompRet}; + Other -> + Other + end; + Error -> + Error + end. + + +%%----------------------------------------------------------------------- +%% The rest are internal functions: +%%----------------------------------------------------------------------- + +%% @doc +%% Get BEAM code from `.beam' files or directly from binaries. +%% File is either a file name or a binary containing the BEAM code. + +disasm(File) -> + case beam_disasm:file(File) of + #beam_file{labeled_exports = LabeledExports, + compile_info = CompInfo, + code = BeamCode} -> + {options, CompOpts} = lists:keyfind(options, 1, CompInfo), + HCompOpts = case lists:keyfind(hipe, 1, CompOpts) of + {hipe, L} when is_list(L) -> L; + {hipe, X} -> [X]; + _ -> [] + end, + Exports = fix_beam_exports(LabeledExports), + {{BeamCode, Exports}, HCompOpts}; + {error, _Mod, Error} -> + io:format("~s\n", [beam_lib:format_error(Error)]), + ?EXIT(no_beam_code) + end. + +fix_beam_exports(BeamExports) -> + fix_beam_exports(BeamExports, []). + +fix_beam_exports([{F,A,_}|BeamExports], Exports) -> + fix_beam_exports(BeamExports, [{F,A} | Exports]); +fix_beam_exports([], Exports) -> + Exports. + +get_beam_icode({M,_F,_A} = MFA, {BeamCode, Exports}, _File, Options) -> + ?option_time({ok, Icode} = + (catch {ok, hipe_beam_to_icode:mfa(BeamCode, MFA, Options)}), + "BEAM-to-Icode", Options), + {{M, Exports, Icode}, false}; +get_beam_icode(Mod, {BeamCode, Exports}, File, Options) -> + ?option_time({ok, Icode} = + (catch {ok, hipe_beam_to_icode:module(BeamCode, Options)}), + "BEAM-to-Icode", Options), + BeamBin = get_beam_code(File), + {{Mod, Exports, Icode}, BeamBin}. + +get_core_icode(Mod, Core, File, Options) -> + ?option_time({ok, Icode} = + (catch {ok, cerl_to_icode:module(Core, Options)}), + "BEAM-to-Icode", Options), + NeedBeamCode = not proplists:get_bool(load, Options), + BeamBin = + case NeedBeamCode of + true -> []; + false -> get_beam_code(File) + end, + Exports = [cerl:var_name(V) || V <- cerl:module_exports(Core)], + {{Mod, Exports, Icode}, BeamBin}. + +get_beam_code(Bin) when is_binary(Bin) -> Bin; +get_beam_code(FileName) -> + case erl_prim_loader:get_file(FileName) of + {ok,Bin,_} -> + Bin; + error -> + ?EXIT(no_beam_file) + end. + + +%% --------------------------------------------------------------------- +%% All compilations go through this function. Note that it receives only +%% "basic" options. Name is just used for verbosity. The DisasmFun and +%% IcodeFun only collect the Icode; most of the real work is done in the +%% 'finalize' function. + +run_compiler(Name, DisasmFun, IcodeFun, Opts0) -> + Opts = expand_basic_options(Opts0 ++ ?COMPILE_DEFAULTS), + ?when_option(verbose, Opts, ?debug_msg("Compiling: ~p\n",[Name])), + ?option_start_time("Compile", Opts), + Res = run_compiler_1(DisasmFun, IcodeFun, Opts), + ?option_stop_time("Compile", Opts), + Res. + +run_compiler_1(DisasmFun, IcodeFun, Options) -> + Parent = self(), + {trap_exit,TrapExit} = process_info(Parent, trap_exit), + %% Spawn a compilation process CompProc. In case this process gets + %% killed, the trap_exit flag is restored to that of the Parent process. + process_flag(trap_exit, true), + CompProc = spawn_link(fun () -> + %% Compiler process + set_architecture(Options), + pre_init(Options), + %% The full option expansion is not done + %% until the DisasmFun returns. + {Code, CompOpts} = DisasmFun(Options), + Opts = expand_options(Options ++ CompOpts), + check_options(Opts), + ?when_option(verbose, Options, + ?debug_msg("Options: ~p.\n",[Opts])), + init(Opts), + {Icode, WholeModule} = IcodeFun(Code, Opts), + CompRes = compile_finish(Icode, WholeModule, Opts), + compiler_return(CompRes, Parent) + end), + Timeout = case proplists:get_value(timeout, Options) of + N when is_integer(N), N >= 0 -> N; + undefined -> ?DEFAULT_TIMEOUT; + infinity -> infinity; + Other -> + ?WARNING_MSG("Bad timeout value: ~P\n" + "Using default timeout limit.\n", + [Other, 5]), + ?DEFAULT_TIMEOUT + end, + receive + {'EXIT', CompProc, normal} -> ok; + {'EXIT', CompProc, Reason} -> exit(Reason) + after Timeout -> + %% Kill the compilation process + exit(CompProc, kill), + receive {'EXIT', CompProc, _} -> ok end, + flush(), + ?error_msg("ERROR: Compilation timed out.\n",[]), + exit(timed_out) + end, + Result = receive {CompProc, Res} -> Res end, + process_flag(trap_exit, TrapExit), + Result. + +flush() -> + receive + _ -> flush() + after 0 -> + ok + end. + +compiler_return(Res, Client) -> + Client ! {self(), Res}. + +compile_finish({Mod, Exports, Icode}, WholeModule, Options) -> + Res = finalize(Icode, Mod, Exports, WholeModule, Options), + post(Res, Icode, Options). + + +%% ------------------------------------------------------------------------- +%% finalize/5 +%% compiles, assembles, and optionally loads a list of `{MFA, Icode}' pairs, +%% and returns `{ok, {TargetArch, Binary}}' or `{error, Reason, Stack}'. + +finalize(OrigList, Mod, Exports, WholeModule, Opts) -> + List = icode_multret(OrigList, Mod, Opts, Exports), + {T1Compile,_} = erlang:statistics(runtime), + CompiledCode = + case proplists:get_value(use_callgraph, Opts) of + true -> + %% Compiling the functions bottom-up by using a call graph + CallGraph = hipe_icode_callgraph:construct(List), + OrdList = hipe_icode_callgraph:to_list(CallGraph), + finalize_fun(OrdList, Exports, Opts); + _ -> + %% Compiling the functions bottom-up by reversing the list + OrdList = lists:reverse(List), + finalize_fun(OrdList, Exports, Opts) + end, + {T2Compile,_} = erlang:statistics(runtime), + ?when_option(verbose, Opts, + ?debug_msg("Compiled ~p in ~.2f s\n", + [Mod,(T2Compile-T1Compile)/1000])), + case proplists:get_bool(to_rtl, Opts) of + true -> + {ok, CompiledCode}; + false -> + Closures = + [MFA || {MFA, Icode} <- List, + hipe_icode:icode_is_closure(Icode)], + {T1,_} = erlang:statistics(runtime), + ?when_option(verbose, Opts, ?debug_msg("Assembling ~w",[Mod])), + try assemble(CompiledCode, Closures, Exports, Opts) of + Bin -> + {T2,_} = erlang:statistics(runtime), + ?when_option(verbose, Opts, + ?debug_untagged_msg(" in ~.2f s\n", + [(T2-T1)/1000])), + {module,Mod} = maybe_load(Mod, Bin, WholeModule, Opts), + TargetArch = get(hipe_target_arch), + {ok, {TargetArch,Bin}} + catch + error:Error -> + {error,Error,erlang:get_stacktrace()} + end + end. + +finalize_fun(MfaIcodeList, Exports, Opts) -> + case proplists:get_value(concurrent_comp, Opts) of + FalseVal when (FalseVal =:= undefined) orelse (FalseVal =:= false) -> + [finalize_fun_sequential(MFAIcode, Opts, #comp_servers{}) + || {_MFA, _Icode} = MFAIcode <- MfaIcodeList]; + TrueVal when (TrueVal =:= true) or (TrueVal =:= debug) -> + finalize_fun_concurrent(MfaIcodeList, Exports, Opts) + end. + +finalize_fun_concurrent(MfaIcodeList, Exports, Opts) -> + Self = self(), + case MfaIcodeList of + [{{M,_,_},_}|_] -> + CallGraph = hipe_icode_callgraph:construct_callgraph(MfaIcodeList), + Closures = [{MFA, true} || {MFA, Icode} <- MfaIcodeList, + hipe_icode:icode_is_closure(Icode)], + Exported = [{{M, F, A}, false} || {F, A} <- Exports], + NonEscaping = [MFA || {{_M, F, A} = MFA, Icode} <- MfaIcodeList, + not lists:member({F, A}, Exports), + not hipe_icode:icode_is_closure(Icode)], + Escaping = Closures ++ Exported, + TypeServerFun = + fun() -> + hipe_icode_coordinator:coordinate(CallGraph, Escaping, + NonEscaping, hipe_icode_type) + end, + TypeServer = spawn_link(TypeServerFun), + PPServerFun = + fun() -> + pp_server_start(Opts) + end, + PPServer = spawn_link(PPServerFun), + RangeServerFun = + fun() -> + hipe_icode_coordinator:coordinate(CallGraph, Escaping, + NonEscaping, hipe_icode_range) + end, + RangeServer = spawn_link(RangeServerFun), + Servers = #comp_servers{pp_server = PPServer, + range = RangeServer, + type = TypeServer}, + CompFuns = + [fun() -> + set_architecture(Opts), + pre_init(Opts), + init(Opts), + Self ! finalize_fun_sequential(IcodeFun, Opts, Servers) + end || IcodeFun <- MfaIcodeList], + lists:foreach(fun (F) -> spawn_link(F) end, CompFuns), + Final = [receive Res when element(1, Res) =:= MFA -> Res end + || {MFA, _} <- MfaIcodeList], + lists:foreach(fun (Pid) -> stop_and_wait(Pid) end, + [PPServer, TypeServer, RangeServer]), + Final; + [] -> + [] + end. + +stop_and_wait(Pid) -> + Pid ! {stop, self()}, + receive + _ -> ok + end. + +finalize_fun_sequential({MFA, Icode}, Opts, Servers) -> + {T1, _} = erlang:statistics(runtime), + ?when_option(verbose, Opts, ?debug_msg("Compiling ~w~n", [MFA])), + try hipe_main:compile_icode(MFA, Icode, Opts, Servers) of + {native, _Platform, {unprofiled, Code}} -> + {T2, _} = erlang:statistics(runtime), + ?when_option(verbose, Opts, + ?debug_msg("Compiled ~w in ~.2f s\n", [MFA,(T2-T1)/1000])), + {MFA, Code}; + {rtl, LinearRtl} -> + {MFA, LinearRtl} + catch + error:Error -> + ?when_option(verbose, Opts, ?debug_untagged_msg("\n", [])), + ErrorInfo = {Error, erlang:get_stacktrace()}, + ?error_msg("ERROR: ~p~n", [ErrorInfo]), + ?EXIT(ErrorInfo) + end. + +pp_server_start(Opts) -> + set_architecture(Opts), + garbage_collect(), + pp_server(). + +pp_server() -> + receive + {print, Fun} -> + Fun(), pp_server(); + {stop, Pid} -> + Pid ! {done, self()}; + _ -> + pp_server() + end. + +icode_multret(List, Mod, Opts, Exports) -> + case proplists:get_bool(icode_multret, Opts) of + true -> + hipe_icode_mulret:mult_ret(List, Mod, Opts, Exports); + false -> + List + end. + +maybe_load(Mod, Bin, WholeModule, Opts) -> + case proplists:get_bool(load, Opts) of + false -> + {module, Mod}; + true -> + ?when_option(verbose, Opts, ?debug_msg("Loading/linking\n", [])), + do_load(Mod, Bin, WholeModule) + end. + +do_load(Mod, Bin, WholeModule) -> + HostArch = get(hipe_host_arch), + TargetArch = get(hipe_target_arch), + %% Make sure we can do the load. + if HostArch =/= TargetArch -> + ?EXIT({host_and_target_arch_differ, HostArch, TargetArch}); + true -> ok + end, + case WholeModule of + false -> + %% In this case, the emulated code for the module must be loaded. + {module, Mod} = code:ensure_loaded(Mod), + code:load_native_partial(Mod, Bin); + BinCode when is_binary(BinCode) -> + case code:is_sticky(Mod) of + true -> + %% We unpack and repack the Beam binary as a workaround to + %% ensure that it is not compressed. + {ok, _, Chunks} = beam_lib:all_chunks(WholeModule), + {ok, Beam} = beam_lib:build_module(Chunks), + %% Don't purge or register sticky mods; just load native. + code:load_native_sticky(Mod, Bin, Beam); + false -> + %% Normal loading of a whole module + Architecture = erlang:system_info(hipe_architecture), + ChunkName = hipe_unified_loader:chunk_name(Architecture), + {ok, _, Chunks0} = beam_lib:all_chunks(WholeModule), + Chunks = [{ChunkName, Bin}|lists:keydelete(ChunkName, 1, Chunks0)], + {ok, BeamPlusNative} = beam_lib:build_module(Chunks), + code:load_binary(Mod, code:which(Mod), BeamPlusNative) + end + end. + +assemble(CompiledCode, Closures, Exports, Options) -> + case get(hipe_target_arch) of + ultrasparc -> + hipe_sparc_assemble:assemble(CompiledCode, Closures, Exports, Options); + powerpc -> + hipe_ppc_assemble:assemble(CompiledCode, Closures, Exports, Options); + arm -> + hipe_arm_assemble:assemble(CompiledCode, Closures, Exports, Options); + x86 -> + hipe_x86_assemble:assemble(CompiledCode, Closures, Exports, Options); + amd64 -> + hipe_amd64_assemble:assemble(CompiledCode, Closures, Exports, Options); + Arch -> + ?EXIT({executing_on_an_unsupported_architecture, Arch}) + end. + +%% -------------------------------------------------------------------- + +%% Initialise host and target architectures. Target defaults to host, +%% but can be overridden by passing an option {target, Target}. + +set_architecture(Options) -> + put(hipe_host_arch, erlang:system_info(hipe_architecture)), + put(hipe_target_arch, + proplists:get_value(target, Options, get(hipe_host_arch))), + ok. + +%% This sets up some globally accessed stuff that are needed by the +%% compiler process before it even gets the full list of options. +%% Therefore, this expands the current set of options for local use. + +pre_init(Opts) -> + Options = expand_options(Opts), + %% Initialise some counters used for measurements and benchmarking. If + %% the option 'measure_regalloc' is given the compilation will return + %% a keylist with the counter values. + put(hipe_time, + case proplists:get_value(time, Options, false) of + true -> [hipe, hipe_main]; + OptTime -> OptTime + end), + lists:foreach(fun (T) -> ?set_hipe_timer_val(T, 0) end, hipe_timers()), + lists:foreach(fun (Counter) -> + case Counter of + {CounterName, InitVal} -> put(CounterName, InitVal); + CounterName -> put(CounterName, 0) + end + end, + proplists:get_value(counters, Options, [])), + put(hipe_debug, proplists:get_bool(debug, Options)), + put(hipe_inline_fp, proplists:get_bool(inline_fp, Options)), + ok. + +%% Prepare the compiler process by setting up variables which are +%% accessed globally. Options have been fully expanded at ths point. + +init(_Options) -> + put(callersavetime, 0), + put(totalspill, {0,0}), + put(spilledtemps, 0), + put(pre_ra_instrs, 0), + put(post_ra_instrs, 0), + put(pre_ra_temps, 0), + put(post_ra_temps, 0), + put(noregs, 0), + put(bbs, 0), + ok. + +%% -------------------------------------------------------------------- + +post(Res, Icode, Options) -> + TimerVals = + case proplists:get_value(timers, Options) of + Timers when is_list(Timers) -> + [{Timer, ?get_hipe_timer_val(Timer)} || Timer <- Timers]; + _ -> [] + end, + CounterVals = + case proplists:get_value(counters, Options) of + Counters when is_list(Counters) -> + [case Counter of + {CounterName, _InitVal} -> {CounterName, get(CounterName)}; + CounterName -> {CounterName, get(CounterName)} + end + || Counter <- Counters]; + _ -> [] + end, + Measures = + case proplists:get_bool(measure_regalloc, Options) of + true -> + get(); % return whole process dictionary list (simplest way...) + false -> [] + end, + Info = TimerVals ++ CounterVals ++ Measures, + case proplists:get_bool(get_called_modules, Options) of + true -> + CalledMods = hipe_icode_callgraph:get_called_modules(Icode), + case Info of + [] -> + {Res, {called_modules, CalledMods}}; + _ -> + {Res, {info, Info}, {called_modules, CalledMods}} + end; + false -> + case Info of + [] -> + Res; + _ -> + {Res, {info, Info}} + end + end. + +%% -------------------------------------------------------------------- + +%% @doc Returns the current HiPE version as a string(). +-spec version() -> string(). + +version() -> + ?VERSION_STRING(). + +%% -------------------------------------------------------------------- +%% D O C U M E N T A T I O N - H E L P +%% -------------------------------------------------------------------- + +%% @doc Prints on-line documentation to the standard output. +-spec help() -> 'ok'. + +help() -> + M = + "The HiPE Compiler (Version " ++ ?VERSION_STRING() ++ ")\n" ++ + "\n" ++ + " The normal way to native-compile Erlang code using HiPE is to\n" ++ + " include `native' in the Erlang compiler options, as in:\n" ++ + " 1> c(my_module, [native]).\n" ++ + " Options to the HiPE compiler must then be passed as follows:\n" ++ + " 1> c(my_module, [native,{hipe,Options}]).\n" ++ + " Use `help_options()' for details.\n" ++ + "\n" ++ + " Utility functions:\n" ++ + " help()\n" ++ + " Prints this message.\n" ++ + " help_options()\n" ++ + " Prints a description of options recognized by the\n" ++ + " HiPE compiler.\n" ++ + " help_option(Option)\n" ++ + " Prints a description of that option.\n" ++ + " help_debug_options()\n" ++ + " Prints a description of debug options.\n" ++ + " version() ->\n" ++ + " Returns the HiPE version as a string'.\n" ++ + "\n" ++ + " For HiPE developers only:\n" ++ + " Use `help_hiper()' for information about HiPE's low-level interface\n", + io:put_chars(M), + ok. + +-spec help_hiper() -> 'ok'. + +help_hiper() -> + M = + " This interface is supposed to be used by HiPE-developers only!\n" ++ + " Note that all options are specific to the HiPE compiler.\n" ++ + " c(Name,Options)\n" ++ + " Compiles the module or function Name and loads it\n" ++ + " to memory. Name is an atom or a tuple {M,F,A}.\n" ++ + " c(Name)\n" ++ + " As above, but using only default options.\n" ++ + " f(File,Options)\n" ++ + " As c(Name,File,Options), but taking the module name\n" ++ + " from File.\n" ++ + " f(File)\n" ++ + " As above, but using only default options.\n" ++ + " compile(Name,Options)\n" ++ + " Compiles the module or function Name to a binary.\n" ++ + " By default, this does not load to memory.\n" ++ + " compile(Name)\n" ++ + " As above, but using only default options.\n" ++ + " file(File,Options)\n" ++ + " As compile(Name,File,Options), but taking the\n" ++ + " module name from File.\n" ++ + " file(File)\n" ++ + " As above, but using only default options.\n" ++ + " load(Module)\n" ++ + " Loads the named module into memory.\n", + io:put_chars(M), + ok. + +%% TODO: it should be possible to specify the target somehow when asking +%% for available options. Right now, you only see host machine options. + +%% @doc Prints documentation about options to the standard output. +-spec help_options() -> 'ok'. + +help_options() -> + set_architecture([]), %% needed for target-specific option expansion + O1 = expand_options([o1]), + O2 = expand_options([o2]), + O3 = expand_options([o3]), + io:format("HiPE Compiler Options\n" ++ + " Boolean-valued options generally have corresponding " ++ + "aliases `no_...',\n" ++ + " and can also be specified as `{Option, true}' " ++ + "or `{Option, false}.\n\n" ++ + " General boolean options:\n" ++ + " ~p.\n\n" ++ + " Non-boolean options:\n" ++ + " o#, where 0 =< # =< 3:\n" ++ + " Select optimization level (the default is 2).\n\n" ++ + " Further options can be found below; " ++ + "use `hipe:help_option(Name)' for details.\n\n" ++ + " Aliases:\n" ++ + " pp_all = ~p,\n" ++ + " pp_sparc = pp_native,\n" ++ + " pp_x86 = pp_native,\n" ++ + " pp_amd64 = pp_native,\n" ++ + " pp_ppc = pp_native,\n" ++ + " o0,\n" ++ + " o1 = ~p,\n" ++ + " o2 = ~p ++ o1,\n" ++ + " o3 = ~p ++ o2.\n", + [ordsets:from_list([verbose, debug, time, load, pp_beam, + pp_icode, pp_rtl, pp_native, pp_asm, + timeout]), + expand_options([pp_all]), + O1 -- [o1], + (O2 -- O1) -- [o2], + (O3 -- O2) -- [o3]]), + ok. + +%% Documentation of the individual options. +%% If you add an option, please add help-text here. + +-spec option_text(atom()) -> string(). + +option_text('O') -> + "Specify optimization level. Used as o1, o2, o3.\n" ++ + " At the moment levels 0 - 3 are implemented.\n" ++ + " Aliases: 'O1', 'O2', O3'."; +option_text(caller_save_spill_restore) -> + "Activates caller save register spills and restores"; +option_text(debug) -> + "Outputs internal debugging information during compilation"; +option_text(icode_range) -> + "Performs integer range analysis on the Icode level"; +option_text(icode_ssa_check) -> + "Checks whether Icode is on SSA form or not\n"; +option_text(icode_ssa_copy_prop) -> + "Performs copy propagation on Icode SSA"; +option_text(icode_ssa_const_prop) -> + "Performs sparse conditional constant propagation on Icode SSA"; +option_text(icode_ssa_struct_reuse) -> + "Factors out common tuple and list constructions on Icode SSA"; +option_text(icode_type) -> + "Performs type analysis on the Icode level" ++ + "and then simplifies the code based on the results of this analysis"; +option_text(load) -> + "Automatically load the produced native code into memory"; +option_text(peephole) -> + "Enables peephole optimizations"; +option_text(pmatch) -> + "Enables pattern matching compilation when compiling from Core; " ++ + "has no effect when compiling from BEAM bytecode"; +option_text(pp_asm) -> + "Displays assembly listing with addresses and bytecode\n" ++ + "Currently available for x86 only"; +option_text(pp_beam) -> + "Display the input BEAM code"; +option_text(pp_icode) -> + "Display the intermediate HiPE-ICode"; +option_text(pp_rtl) -> + "Display the intermediate HiPE-RTL code"; +option_text(pp_rtl_lcm) -> + "Display the intermediate HiPE-RTL lazy code motion sets"; +option_text(pp_rtl_ssapre) -> + "Display the intermediate HiPE-RTL A-SSAPRE sets"; +option_text(pp_native) -> + "Display the generated (back-end specific) native code"; +option_text(regalloc) -> + "Select register allocation algorithm. Used as {regalloc, METHOD}.\n" ++ + " Currently available methods:\n" ++ + " naive - spills everything (for debugging and testing)\n" ++ + " linear_scan - fast; not so good if few registers available\n" ++ + " graph_color - slow, but gives OK performance\n" ++ + " coalescing - slower, tries hard to use registers\n" ++ + " optimistic - another variant of a coalescing allocator"; +option_text(remove_comments) -> + "Strip comments from intermediate code"; +option_text(rtl_ssa) -> + "Perform SSA conversion on the RTL level -- default starting at O2"; +option_text(rtl_ssa_const_prop) -> + "Performs sparse conditional constant propagation on RTL SSA"; +option_text(rtl_lcm) -> + "Perform Lazy Code Motion on RTL"; +option_text(rtl_ssapre) -> + "Perform A-SSAPRE on RTL"; +option_text(time) -> + "Reports the compilation times for the different stages\n" ++ + "of the compiler.\n" ++ + " {time, Module} reports timings for the module Module.\n" ++ + " {time, [M1, M2, M3]} reports timings for the specified modules.\n" ++ + " {time, all} reports timings all modules.\n" ++ + " time reports timings for the main module.\n"; +option_text(timeout) -> + "Specify compilation time limit in ms. Used as {timeout, LIMIT}.\n" ++ + " The limit must be a non-negative integer or the atom 'infinity'.\n" ++ + " The current default limit is 15 minutes (900000 ms)."; +option_text(use_indexing) -> + "Use indexing for multiple-choice branch selection."; +option_text(use_callgraph) -> + "Compile the functions in a module according to a reversed topological " ++ + "sorted order to gain more information when using a persistent lookup " ++ + "table for storing intra-modular type information."; +option_text(verbose) -> + "Output information about what is being done"; +option_text(Opt) when is_atom(Opt) -> + "". + +%% @doc Prints documentation about a specific option to the standard output. +-spec help_option(comp_option()) -> 'ok'. + +help_option(Opt) -> + set_architecture([]), %% needed for target-specific option expansion + case expand_options([Opt]) of + [Opt] -> + Name = if is_atom(Opt) -> Opt; + tuple_size(Opt) =:= 2 -> element(1, Opt) + end, + case option_text(Name) of + "" -> + case lists:member(Name, opt_keys()) of + true -> + io:format("~w - Sorry, this option is not documented yet.\n", + [Name]); + _ -> + io:format("Unknown option ~p.\n", [Name]) + end; + Txt -> + io:fwrite("~w - ~s\n", [Name, Txt]) + end; + Opts -> + io:fwrite("This is an alias for: ~p.\n", [Opts]) + end, + ok. + +%% @doc Prints documentation about debugging options to the standard +%% output. +-spec help_debug_options() -> 'ok'. + +help_debug_options() -> + io:format("HiPE compiler debug options:\n" ++ + " Might require that some modules have been compiled " ++ + "with the debug flag.\n" ++ + " rtl_show_translation - Prints each step in the\n" ++ + " translation from Icode to RTL\n", + []), + ok. + +hipe_timers() -> + [time_ra]. + +%% ____________________________________________________________________ +%% +%% Option expansion + +%% These are currently in use, but not documented: +%% +%% count_instrs: +%% icode_type: +%% icode_range: +%% {ls_order, Order}: +%% {regalloc, Algorithm}: +%% remove_comments +%% timeregalloc: +%% timers +%% use_indexing + +%% Valid option keys. (Don't list aliases or negations - the check is +%% done after the options have been expanded to normal form.) + +opt_keys() -> + [ + binary_opt, + bitlevel_binaries, + caller_save_spill_restore, + concurrent_comp, + core, + core_transform, + counters, + count_instrs, + count_spills, + count_temps, + debug, + get_called_modules, + split_arith, + split_arith_unsafe, + icode_inline_bifs, + icode_ssa_check, + icode_ssa_copy_prop, + icode_ssa_const_prop, + icode_ssa_struct_reuse, + icode_type, + icode_range, + icode_multret, + inline_fp, + ls_order, + load, + measure_regalloc, + peephole, + pmatch, + pp_asm, + pp_beam, + pp_icode, + pp_icode_ssa, + pp_icode_split_arith, + pp_opt_icode, + pp_range_icode, + pp_typed_icode, + pp_icode_liveness, + pp_native, + pp_rtl, + pp_rtl_liveness, + pp_rtl_ssa, + pp_rtl_lcm, + pp_rtl_ssapre, + pp_rtl_linear, + regalloc, + remove_comments, + rtl_ssa, + rtl_ssa_const_prop, + rtl_lcm, + rtl_ssapre, + rtl_show_translation, + spillmin_color, + target, + time, + timeout, + timeregalloc, + timers, + to_rtl, + use_indexing, + use_inline_atom_search, + use_callgraph, + use_clusters, + use_jumptable, + verbose, + %% verbose_spills, + x87]. + +%% Definitions: + +o1_opts() -> + Common = [inline_fp, pmatch, peephole], + case get(hipe_target_arch) of + ultrasparc -> + Common; + powerpc -> + Common; + arm -> + Common -- [inline_fp]; % Pointless optimising for absent hardware + x86 -> + [x87 | Common]; % XXX: Temporary until x86 has sse2 + amd64 -> + Common; + Arch -> + ?EXIT({executing_on_an_unsupported_architecture,Arch}) + end. + +o2_opts() -> + Common = [icode_ssa_const_prop, icode_ssa_copy_prop, % icode_ssa_struct_reuse, + icode_type, icode_inline_bifs, rtl_lcm, + rtl_ssa, rtl_ssa_const_prop, + spillmin_color, use_indexing, remove_comments, + concurrent_comp, binary_opt | o1_opts()], + case get(hipe_target_arch) of + ultrasparc -> + Common; + powerpc -> + Common; + arm -> + Common; + x86 -> + Common; + % [rtl_ssapre | Common]; + amd64 -> + [icode_range | Common]; % range analysis is effective on 64 bits + Arch -> + ?EXIT({executing_on_an_unsupported_architecture,Arch}) + end. + +o3_opts() -> + Common = [icode_range, {regalloc,coalescing} | o2_opts()], + case get(hipe_target_arch) of + ultrasparc -> + Common; + powerpc -> + Common; + arm -> + Common; + x86 -> + Common; + amd64 -> + Common; + Arch -> + ?EXIT({executing_on_an_unsupported_architecture,Arch}) + end. + +%% Note that in general, the normal form for options should be positive. +%% This is a good programming convention, so that tests in the code say +%% "if 'x' ..." instead of "if not 'no_x' ...". + +opt_negations() -> + [{no_binary_opt, binary_opt}, + {no_bitlevel_binaries, bitlevel_binaries}, + {no_core, core}, + {no_debug, debug}, + {no_get_called_modules, get_called_modules}, + {no_split_arith, split_arith}, + {no_concurrent_comp, concurrent_comp}, + {no_icode_inline_bifs, icode_inline_bifs}, + {no_icode_range, icode_range}, + {no_icode_split_arith, icode_split_arith}, + {no_icode_ssa_check, icode_ssa_check}, + {no_icode_ssa_copy_prop, icode_ssa_copy_prop}, + {no_icode_ssa_const_prop, icode_ssa_const_prop}, + {no_icode_ssa_struct_reuse, icode_ssa_struct_reuse}, + {no_icode_type, icode_type}, + {no_inline_fp, inline_fp}, + {no_load, load}, + {no_peephole, peephole}, + {no_pmatch, pmatch}, + {no_pp_beam, pp_beam}, + {no_pp_icode, pp_icode}, + {no_pp_icode_ssa, pp_icode_ssa}, + {no_pp_opt_icode, pp_opt_icode}, + {no_pp_typed_icode, pp_typed_icode}, + {no_pp_rtl, pp_rtl}, + {no_pp_native, pp_native}, + {no_pp_rtl_lcm, pp_rtl_lcm}, + {no_pp_rtl_ssapre, pp_rtl_ssapre}, + {no_remove_comments, remove_comments}, + {no_rtl_ssa, rtl_ssa}, + {no_rtl_ssa_const_prop, rtl_ssa_const_prop}, + {no_rtl_lcm, rtl_lcm}, + {no_rtl_ssapre, rtl_ssapre}, + {no_rtl_show_translation, rtl_show_translation}, + {no_time, time}, + {no_use_callgraph, use_callgraph}, + {no_use_clusters, use_clusters}, + {no_use_inline_atom_search, use_inline_atom_search}, + {no_use_indexing, use_indexing}]. + +%% Don't use negative forms in right-hand sides of aliases and expansions! +%% We only expand negations once, before the other expansions are done. + +opt_aliases() -> + [{'O0', o0}, + {'O1', o1}, + {'O2', o2}, + {'O3', o3}, + {pp_sparc, pp_native}, + {pp_x86, pp_native}, + {pp_amd64, pp_native}, + {pp_ppc, pp_native}]. + +opt_basic_expansions() -> + [{pp_all, [pp_beam, pp_icode, pp_rtl, pp_native]}]. + +opt_expansions() -> + [{o1, o1_opts()}, + {o2, o2_opts()}, + {o3, o3_opts()}, + {x87, [x87, inline_fp]}, + {inline_fp, case get(hipe_target_arch) of %% XXX: Temporary until x86 + x86 -> [x87, inline_fp]; %% has sse2 + _ -> [inline_fp] end}]. + +%% This expands "basic" options, which may be tested early and cannot be +%% in conflict with options found in the source code. + +-spec expand_basic_options(comp_options()) -> comp_options(). + +expand_basic_options(Opts) -> + proplists:normalize(Opts, [{negations, opt_negations()}, + {aliases, opt_aliases()}, + {expand, opt_basic_expansions()}]). + +-spec expand_kt2(comp_options()) -> comp_options(). + +expand_kt2(Opts) -> + proplists:normalize(Opts, [{expand, [{kt2_type, + [{use_callgraph, fixpoint}, core, + {core_transform, cerl_typean}]}]}]). + +%% Note that set_architecture/1 must be called first, and that the given +%% list should contain the total set of options, since things like 'o2' +%% are expanded here. Basic expansions are processed here also, since +%% this function is called from the help functions. + +-spec expand_options(comp_options()) -> comp_options(). + +expand_options(Opts) -> + proplists:normalize(Opts, [{negations, opt_negations()}, + {aliases, opt_aliases()}, + {expand, opt_basic_expansions()}, + {expand, opt_expansions()}]). + +-spec check_options(comp_options()) -> 'ok'. + +check_options(Opts) -> + Keys = ordsets:from_list(opt_keys()), + Used = ordsets:from_list(proplists:get_keys(Opts)), + case ordsets:subtract(Used, Keys) of + [] -> + ok; + L -> + ?WARNING_MSG("Unknown options: ~p.\n", [L]), + ok + end. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% diff --git a/lib/hipe/main/hipe.hrl.src b/lib/hipe/main/hipe.hrl.src new file mode 100644 index 0000000000..a1fbeda9cf --- /dev/null +++ b/lib/hipe/main/hipe.hrl.src @@ -0,0 +1,322 @@ +%% -*- erlang-indent-level: 2 -*- +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2001-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Filename : hipe.hrl (automatically generated by hipe.hrl.src) +%% Purpose : Defines some useful macros for debugging and error +%% reporting. +%% +%% History : * 2000-11-03 Erik Johansson ([email protected]): Created. +%% ==================================================================== +%% +%% Defines: +%% msg/2 - Works like io:format but prepends +%% ?MSGTAG to the message. +%% If LOGGING is defined then error_logger is used, +%% or rather its substitute in code_server. +%% untagged_msg/2 - Like msg/2 but without the tag. +%% WARNING_MSG/2 - Prints a tagged warning. +%% error_msg/2 - Logs a tagged error. +%% debug_msg/2 - Prints a tagged msg if DEBUG is defined. +%% IF_DEBUG(A,B) - Executes A if DEBUG is defined B otherwise. +%% IF_DEBUG(Lvl,A,B) - Executes A if DEBUG is defined to a value >= Lvl +%% otherwise B is executed. +%% EXIT - Exits with added module and line info. +%% ASSERT - Exits if the expresion does not evaluate to true. +%% VERBOSE_ASSSERT - A message is printed even when an asertion is true. +%% TIME_STMNT(Stmnt, String, FreeVar) +%% - Times the statemnet Stmnt if TIMING is on. +%% The execution time is bound to FreeVar. +%% String is printed after the execution +%% followed by the execution time in seconds and +%% a newline. +%% +%% Flags: +%% DEBUG - Turns on debugging. (Can be defined to a integer +%% value to determine the level of debugging) +%% VERBOSE - More info is printed... +%% HIPE_LOGGING - Turn on logging of messages with erl_logger. +%% DO_ASSERT - Turn on Assertions. +%% TIMING - Turn on timing. +%% HIPE_INSTRUMENT_COMPILER - Turn on instrumentation of the compiler. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +-define(VERSION_STRING(),"%VSN%"). +-define(MSGTAG, "<HiPE (v " ++ ?VERSION_STRING() ++ ")> "). + +%% +%% Define the message macros with or without logging, +%% depending on the value of the HIPE_LOGGING flag. +%% + +-ifdef(HIPE_LOGGING). +-define(msg(Msg, Args), + code_server:info_msg(?MSGTAG ++ Msg, Args)). +-define(untagged_msg(Msg, Args), + code_server:info_msg(Msg, Args)). +-else. +-define(msg(Msg, Args), + io:format(?MSGTAG ++ Msg, Args)). +-define(untagged_msg(Msg, Args), + io:format(Msg, Args)). +-endif. + +%% +%% Define error and warning messages. +%% +-define(error_msg(Msg, Args), + code_server:error_msg(?MSGTAG ++ + "Error: [~s:~w]: " ++ Msg, + [?MODULE,?LINE|Args])). +-define(WARNING_MSG(Msg, Args), + ?msg("Warning: [~s:~w]: " ++ Msg, [?MODULE,?LINE|Args])). + +%% +%% Define the macros that are dependent on the debug flag. +%% + +-ifdef(DEBUG). +-define(debug_msg(Msg,Data), ?msg(Msg,Data)). +-define(debug_untagged_msg(Msg,Data), ?untagged_msg(Msg,Data)). +-define(IF_DEBUG(DebugAction,NoDebugAction), DebugAction). +-define(IF_DEBUG_LEVEL(Level,DebugAction,NoDebugAction), + if (Level =< ?DEBUG) -> DebugAction; true -> NoDebugAction end). +-else. +-define(debug_msg(Msg,Data), no_debug). +-define(debug_untagged_msg(Msg,Data), no_debug). +-define(IF_DEBUG(DebugAction,NoDebugAction), NoDebugAction). +-define(IF_DEBUG_LEVEL(Level,DebugAction,NoDebugAction), NoDebugAction). +-endif. + +%% +%% Define the exit macro +%% +-ifdef(VERBOSE). +-define(EXIT(Reason), erlang:error({?MODULE,?LINE,Reason})). +-else. +-define(EXIT(Reason), + ?msg("EXITED with reason ~w @~w:~w\n", [Reason,?MODULE,?LINE]), + erlang:error({?MODULE,?LINE,Reason})). +-endif. + +%% +%% Assertions. +%% +-ifdef(DO_ASSERT). +-define(VERBOSE_ASSERT(X), + case X of + true -> + io:format("Assertion ok ~w ~w\n",[?MODULE,?LINE]), + true; + __ASSVAL_R -> + io:format("Assertion failed ~w ~w: ~p\n", + [?MODULE,?LINE, __ASSVAL_R]), + ?EXIT(assertion_failed) + end). +-define(ASSERT(X), + case X of + true -> true; + _ -> ?EXIT(assertion_failed) + end). +-else. +-define(ASSERT(X),true). +-define(VERBOSE_ASSERT(X),true). +-endif. + + +%% Use this to display info, save stuff and so on. +%% Vars cannot be exported from __Action +-define(when_option(__Opt,__Opts,__Action), + case proplists:get_bool(__Opt,__Opts) of + true -> __Action; + false -> ok + end). + +%% Timing macros + +-ifdef(TIMING). +-define(TIME_STMNT(STMNT,Msg,Timer), + Timer = hipe_timing:start_timer(), + STMNT, + ?untagged_msg(Msg ++ "~.2f s\n",[hipe_timing:stop_timer(Timer)/1000])). +-else. +-define(TIME_STMNT(STMNT,Msg,Timer),STMNT). +-endif. + +-define(start_timer(Text), hipe_timing:start(Text, ?MODULE)). +-define(stop_timer(Text), hipe_timing:stop(Text, ?MODULE)). +-define(start_hipe_timer(Timer), hipe_timing:start_hipe_timer(Timer)). +-define(stop_hipe_timer(Timer), hipe_timing:stop_hipe_timer(Timer)). +-define(get_hipe_timer_val(Timer), get(Timer)). +-define(set_hipe_timer_val(Timer, Val), put(Timer, Val)). +-define(option_time(Stmnt, Text, Options), + if true -> ?when_option(time, Options, ?start_timer(Text)), + fun(R) -> + ?when_option(time, Options, ?stop_timer(Text)), + R + end(Stmnt)end). + +-define(option_start_time(Text,Options), + ?when_option(time, Options, ?start_timer(Text))). + +-define(option_stop_time(Text,Options), + ?when_option(time, Options, ?stop_timer(Text))). + +-define(opt_start_timer(Text), + hipe_timing:start_optional_timer(Text,?MODULE)). +-define(opt_stop_timer(Text), + hipe_timing:stop_optional_timer(Text,?MODULE)). + +%% +%% Turn on instrumentation of the compiler. +%% +-ifdef(HIPE_INSTRUMENT_COMPILER). + +-define(count_pre_ra_instructions(Options, NoInstrs), + ?when_option(count_instrs, Options, + put(pre_ra_instrs, + get(pre_ra_instrs)+ NoInstrs))). +-define(count_post_ra_instructions(Options, NoInstrs), + ?when_option(count_instrs, Options, + put(post_ra_instrs, + get(post_ra_instrs)+ NoInstrs))). + +-define(start_time_regalloc(Options), + ?when_option(timeregalloc, Options, + put(regalloctime1,erlang:statistics(runtime)))). +-define(stop_time_regalloc(Options), + ?when_option(timeregalloc, Options, + put(regalloctime, + get(regalloctime) + + (element(1,erlang:statistics(runtime)) + -element(1,get(regalloctime1)))))). +-define(start_time_caller_saves(Options), + ?when_option(timeregalloc, Options, + put(callersavetime1,erlang:statistics(runtime)))). +-define(stop_time_caller_saves(Options), + ?when_option(timeregalloc, Options, + put(callersavetime, + get(callersavetime) + + (element(1,erlang:statistics(runtime)) + -element(1,get(callersavetime1)))))). + +-define(count_pre_ra_temps(Options, NoTemps), + ?when_option(count_temps, Options, + put(pre_ra_temps, + get(pre_ra_temps)+ NoTemps))). +-define(count_post_ra_temps(Options, NoTemps), + ?when_option(count_temps, Options, + put(post_ra_temps, + get(post_ra_temps)+ NoTemps))). + +-define(inc_counter(Counter, Val), + case get(Counter) of + undefined -> true; + _ -> put(Counter, Val + get(Counter)) + end). + +-define(cons_counter(Counter, Val), + case get(Counter) of + undefined -> true; + _ -> put(Counter, [Val|get(Counter)]) + end). + +-define(update_counter(Counter, Val, Op), + case get(Counter) of + undefined -> true; + _ -> put(Counter, get(Counter) Op Val) + end). + +-define(start_ra_instrumentation(Options, NoInstrs, NoTemps), + begin + ?count_pre_ra_instructions(Options, NoInstrs), + ?count_pre_ra_temps(Options, NoTemps), + case get(counter_mem_temps) of + undefined -> true; + _ -> put(counter_mfa_mem_temps,[]) + end, + ?start_time_regalloc(Options) + end). +-define(stop_ra_instrumentation(Options, NoInstrs, NoTemps), + begin + ?stop_time_regalloc(Options), + ?count_post_ra_instructions(Options, NoInstrs), + ?cons_counter(counter_mem_temps, get(counter_mfa_mem_temps)), + ?cons_counter(ra_all_iterations_counter, get(ra_iteration_counter)), + put(ra_iteration_counter,0), + ?count_post_ra_temps(Options, NoTemps) + end). + +-define(add_spills(Options, NoSpills), + ?when_option(count_spills, Options, + put(spilledtemps, get(spilledtemps) + NoSpills))). + +-define(optional_start_timer(Timer, Options), + case lists:member(Timer, proplists:get_value(timers,Options++[{timers,[]}])) of + true -> ?start_hipe_timer(Timer); + false -> true + end). +-define(optional_stop_timer(Timer, Options), + case lists:member(Timer, proplists:get_value(timers,Options++[{timers,[]}])) of + true -> ?stop_hipe_timer(Timer); + false -> true + end). + +-else. %% HIPE_INSTRUMENT_COMPILER + +-define(count_pre_ra_instructions(Options, NoInstrs), no_instrumentation). +-define(count_post_ra_instructions(Options, NoInstrs),no_instrumentation). +-define(start_time_regalloc(Options), no_instrumentation). +-define(stop_time_regalloc(Options), no_instrumentation). +-define(start_time_caller_saves(Options), no_instrumentation). +-define(stop_time_caller_saves(Options), no_instrumentation). +-define(count_pre_ra_temps(Options, NoTemps), no_instrumentation). +-define(count_post_ra_temps(Options, NoTemps), no_instrumentation). +-define(start_ra_instrumentation(Options, NoInstrs, NoTemps),no_instrumentation). +-define(stop_ra_instrumentation(Options, NoInstrs, NoTemps),no_instrumentation). +-define(add_spills(Options, NoSpills), no_instrumentation). +-define(optional_start_timer(Options, Timer), no_instrumentation). +-define(optional_stop_timer(Options, Timer), no_instrumentation). +-define(inc_counter(Counter, Val), no_instrumentation). +-define(update_counter(Counter, Val, Op), no_instrumentation). +-define(cons_counter(Counter, Val), no_instrumentation). + +-endif. %% HIPE_INSTRUMENT_COMPILER + +%%---------------------------------------------------------------------------- +%% Records defined in the hipe module used in other parts of the compiler +%%---------------------------------------------------------------------------- + +-record(comp_servers, {pp_server :: pid(), range :: pid(), type :: pid()}). + +%%---------------------------------------------------------------------------- +%% Basic types of the 'hipe' application used in other parts of the system +%%---------------------------------------------------------------------------- + +-type comp_option() :: atom() | {atom(), atom()}. +-type comp_options() :: [comp_option()]. + +-type hipe_architecture() :: + 'amd64' | 'arm' | 'powerpc' | 'ppc64' | 'ultrasparc' | 'x86'. + +-type hipe_map() :: [{non_neg_integer(), + 'unknown' | {'reg' | 'fp_reg' | 'spill', + non_neg_integer()}}]. +-type hipe_temp_map() :: tuple(). +-type hipe_spill_map() :: [{non_neg_integer(), {'spill',non_neg_integer()}}]. diff --git a/lib/hipe/main/hipe_main.erl b/lib/hipe/main/hipe_main.erl new file mode 100644 index 0000000000..fe9bc83fd2 --- /dev/null +++ b/lib/hipe/main/hipe_main.erl @@ -0,0 +1,549 @@ +%% -*- erlang-indent-level: 2 -*- +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2001-2009. All Rights Reserved. +%% +%% The contents of this file are subject to the Erlang Public License, +%% Version 1.1, (the "License"); you may not use this file except in +%% compliance with the License. You should have received a copy of the +%% Erlang Public License along with this software. If not, it can be +%% retrieved online at http://www.erlang.org/. +%% +%% Software distributed under the License is distributed on an "AS IS" +%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See +%% the License for the specific language governing rights and limitations +%% under the License. +%% +%% %CopyrightEnd% +%% +%% @doc This is the HiPE compiler's main "loop". +%% +%% <h3>Purpose</h3> +%% +%% <p> This module provides code which compiles a single Erlang +%% function, represented as linear ICode all the way down to a linear +%% native code representation (which depends on the 'hipe_target_arch' +%% global variable). </p> +%% +%% @end +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +%%===================================================================== + +-module(hipe_main). +-export([compile_icode/4]). + +%%===================================================================== + +-ifndef(DEBUG). +-define(DEBUG,1). +-endif. + +-define(HIPE_INSTRUMENT_COMPILER, true). %% Turn on instrumentation. + +-include("hipe.hrl"). +-include("../icode/hipe_icode.hrl"). +%%-include("../rtl/hipe_rtl.hrl"). + +%%===================================================================== + +-type comp_icode_ret() :: {'native',hipe_architecture(),{'unprofiled',_}} + | {'rtl',tuple()}. + +%%===================================================================== + +%% @spec compile_icode(MFA::mfa(), +%% LinearIcode::#icode{}, +%% CompilerOptions::comp_options(), +%% CompServers::#comp_servers()) -> +%% {native,Platform,{unprofiled,NativeCode}} | {rtl,RTLCode} +%% +%% @doc Compiles the Icode (in linear form) of a single MFA down to +%% native code for the platform of the target architecture. +%% CompilerOptions influence the steps of this compilation process. +%% +%% <p> In particular, the compiler option '<code>to_rtl</code>' stops +%% compilation after translation to RTL (in which case RTL code is +%% generated). The compiler options must have already been expanded +%% (cf. `<a href="hipe.html">hipe:expand_options</a>'). </p> + +-spec compile_icode(mfa(), #icode{}, comp_options(), #comp_servers{}) -> + comp_icode_ret(). + +compile_icode(MFA, LinearIcode, Options, Servers) -> + compile_icode(MFA, LinearIcode, Options, Servers, get(hipe_debug)). + +%%-------------------------------------------------------------------- +%% +%% The following constraints apply to the passes on Icode: +%% +%% 1. The no_comment pass must be done on linear form; +%% +%% 2. linear_to_cfg, which turns linear form into a CFG, must be +%% performed before any of the passes on CFG form; +%% +%% 3. handle_exceptions must be performed before icode_ssa; +%% +%% 4. split_arith should be performed after icode_ssa for +%% effectiveness reasons (and perhaps to work at all); +%% +%% 5. remove_trivial_bbs should be performed last to tidy up the CFG. +%% +%%--------------------------------------------------------------------- + +compile_icode(MFA, LinearIcode0, Options, Servers, DebugState) -> + %% Set up gensym with the right ranges for this function. + {LMin,LMax} = hipe_icode:icode_label_range(LinearIcode0), + hipe_gensym:set_label_range(icode, LMin, LMax+1), + {VMin,VMax} = hipe_icode:icode_var_range(LinearIcode0), + hipe_gensym:set_var_range(icode, VMin, VMax+1), + %%hipe_icode_pp:pp(LinearIcode0), + ?opt_start_timer("Icode"), + LinearIcode1 = icode_no_comment(LinearIcode0, Options), + IcodeCfg0 = icode_linear_to_cfg(LinearIcode1, Options), + %%hipe_icode_cfg:pp(IcodeCfg1), + IcodeCfg1 = icode_handle_exceptions(IcodeCfg0, MFA, Options), + IcodeCfg3 = icode_inline_bifs(IcodeCfg1, Options), + pp(IcodeCfg3, MFA, icode, pp_icode, Options, Servers), + IcodeCfg4 = icode_ssa(IcodeCfg3, MFA, Options, Servers), + IcodeCfg5 = icode_split_arith(IcodeCfg4, MFA, Options), + pp(IcodeCfg5, MFA, icode, pp_icode_split_arith, Options, Servers), + IcodeCfg6 = icode_heap_test(IcodeCfg5, Options), + IcodeCfg7 = icode_remove_trivial_bbs(IcodeCfg6, Options), + pp(IcodeCfg7, MFA, icode, pp_opt_icode, Options, Servers), + pp(IcodeCfg7, MFA, icode_liveness, pp_icode_liveness, Options, Servers), + FinalIcode = hipe_icode_cfg:cfg_to_linear(IcodeCfg7), + ?opt_stop_timer("Icode"), + LinearRTL = ?option_time(icode_to_rtl(MFA,FinalIcode,Options, Servers), + "RTL", Options), + case proplists:get_bool(to_rtl, Options) of + false -> + rtl_to_native(MFA, LinearRTL, Options, DebugState); + true -> + put(hipe_debug, DebugState), + {rtl, LinearRTL} + end. + +%%---------------------------------------------------------------- +%% +%% Icode passes +%% +%%---------------------------------------------------------------- + +icode_no_comment(LinearIcode, Options) -> + case proplists:get_bool(remove_comments, Options) of + true -> + ?option_time(hipe_icode:strip_comments(LinearIcode), + "Icode remove comments", Options); + _ -> + LinearIcode + end. + +icode_linear_to_cfg(LinearIcode, Options) -> + ?option_time(hipe_icode_cfg:linear_to_cfg(LinearIcode), + "transform linear Icode to CFG", Options). + +icode_ssa_binary_pass(IcodeSSA, Options) -> + case proplists:get_bool(binary_opt, Options) of + true -> + ?option_time(hipe_icode_bincomp:cfg(IcodeSSA), + "Icode binary pass", Options); + false -> + IcodeSSA + end. + +icode_handle_exceptions(IcodeCfg, MFA, Options) -> + debug("Icode fix catches: ~w~n", [MFA], Options), + ?option_time(hipe_icode_exceptions:fix_catches(IcodeCfg), + "Icode fix catches", Options). + +icode_inline_bifs(IcodeCfg, Options) -> + case proplists:get_bool(icode_inline_bifs, Options) of + true -> + ?option_time(hipe_icode_inline_bifs:cfg(IcodeCfg), + "Icode inline bifs", Options); + false -> + IcodeCfg + end. + +%%--------------------------------------------------------------------- + +icode_split_arith(IcodeCfg, MFA, Options) -> + case proplists:get_bool(split_arith, Options) orelse + proplists:get_bool(split_arith_unsafe, Options) of + true -> + ?option_time(hipe_icode_split_arith:cfg(IcodeCfg, MFA, Options), + "Icode split arith", Options); + false -> + IcodeCfg + end. + +icode_heap_test(IcodeCfg, Options) -> + ?option_time(hipe_icode_heap_test:cfg(IcodeCfg), + "Icode heap_test", Options). + +icode_remove_trivial_bbs(IcodeCfg, Options) -> + ?option_time(hipe_icode_cfg:remove_trivial_bbs(IcodeCfg), + "Icode trivial BB removal", Options). + +pp(Cfg, MFA, Level, PrintOption, Options, Servers) -> + perform_io(pp_fun(Cfg, MFA, get_pp_module(Level), + proplists:get_value(PrintOption, Options)), + Servers#comp_servers.pp_server). + +pp_fun(Cfg, MFA, PP, PrintOptionValue) -> + case PrintOptionValue of + true -> + fun() -> PP:pp(Cfg) end; + {only, Lst} when is_list(Lst) -> + case lists:member(MFA, Lst) of + true -> + fun() -> PP:pp(Cfg) end; + false -> + no_fun + end; + {only, MFA} -> + fun() -> PP:pp(Cfg) end; + {file, FileName} -> + fun() -> + {ok, File} = file:open(FileName, [write,append]), + PP:pp(File, Cfg), + file:close(File) + end; + _ -> + no_fun + end. + +get_pp_module(icode) -> hipe_icode_cfg; +get_pp_module(rtl) -> hipe_rtl_cfg; +get_pp_module(rtl_linear) -> hipe_rtl; +get_pp_module(icode_liveness) -> hipe_icode_liveness; +get_pp_module(rtl_liveness) -> hipe_rtl_liveness. + +perform_io(no_fun, _) -> ok; +perform_io(Fun,PPServer) when is_pid(PPServer) -> + PPServer ! {print,Fun}; +perform_io(Fun, undefined) -> + Fun(). + + +%%-------------------------------------------------------------------- +%% +%% Icode passes on SSA form. The following constraints are applicable: +%% +%% 1. ssa_convert must be first and ssa_unconvert last +%% +%% 2. ssa_dead_code must be run after the other passes +%% +%% 3. The present order was chosen to maximize effectiveness as +%% ssa_const_prop might make ssa_type_info more effective +%% +%% 4. ssa_check could be put in between all passes to make sure that +%% they preserve SSA-ness +%% +%%--------------------------------------------------------------------- + +icode_ssa(IcodeCfg0, MFA, Options, Servers) -> + ?opt_start_timer("Icode SSA passes"), + IcodeSSA0 = icode_ssa_convert(IcodeCfg0, Options), + pp(IcodeSSA0, MFA, icode, pp_icode_ssa, Options, Servers), + IcodeSSA1 = icode_ssa_const_prop(IcodeSSA0, Options), + IcodeSSA2 = icode_ssa_dead_code_elimination(IcodeSSA1, Options), + IcodeSSA3 = icode_ssa_copy_prop(IcodeSSA2, Options), + IcodeSSA3a = icode_ssa_binary_pass(IcodeSSA3, Options), + IcodeSSA4 = icode_ssa_type(IcodeSSA3a, MFA, Options, Servers), + IcodeSSA5 = icode_ssa_dead_code_elimination(IcodeSSA4, Options), + IcodeSSA6 = icode_ssa_struct_reuse(IcodeSSA5, Options), + icode_ssa_check(IcodeSSA6, Options), %% just for sanity + pp(IcodeSSA6, MFA, icode, pp_icode_ssa, Options, Servers), + IcodeCfg = icode_ssa_unconvert(IcodeSSA6, Options), + ?opt_stop_timer("Icode SSA passes"), + IcodeCfg. + +icode_ssa_type(IcodeSSA, MFA, Options, Servers) -> + case proplists:get_value(icode_type, Options) of + false -> IcodeSSA; + undefined -> IcodeSSA; + true -> + AnnIcode1 = icode_ssa_type_info(IcodeSSA, MFA, Options, Servers), + pp(AnnIcode1, MFA, icode, pp_typed_icode, Options, Servers), + AnnIcode2 = + case proplists:get_bool(inline_fp, Options) of + true -> hipe_icode_fp:cfg(AnnIcode1); + false -> AnnIcode1 + end, + AnnIcode3 = icode_range_analysis(AnnIcode2, MFA, Options, Servers), + pp(AnnIcode3, MFA, icode, pp_range_icode, Options, Servers), + hipe_icode_type:unannotate_cfg(AnnIcode3) + end. + +icode_ssa_convert(IcodeCfg, Options) -> + ?option_time(hipe_icode_ssa:convert(IcodeCfg), + "Icode SSA conversion", Options). + +icode_ssa_const_prop(IcodeSSA, Options) -> + case proplists:get_bool(icode_ssa_const_prop, Options) of + true -> + ?option_time(Tmp=hipe_icode_ssa_const_prop:propagate(IcodeSSA), + "Icode SSA sparse conditional constant propagation", Options), + ?option_time(hipe_icode_ssa:remove_dead_code(Tmp), + "Icode SSA dead code elimination pass 1", Options); + false -> + IcodeSSA + end. + +icode_ssa_copy_prop(IcodeSSA, Options) -> + case proplists:get_bool(icode_ssa_copy_prop, Options) of + true -> + ?option_time(hipe_icode_ssa_copy_prop:cfg(IcodeSSA), + "Icode SSA copy propagation", Options); + false -> + IcodeSSA + end. + +icode_ssa_struct_reuse(IcodeSSA, Options) -> + case proplists:get_value(icode_ssa_struct_reuse, Options) of + true -> + ?option_time(hipe_icode_ssa_struct_reuse:struct_reuse(IcodeSSA), + "Icode SSA structure reuse", Options); + _ -> + IcodeSSA + end. + +icode_ssa_type_info(IcodeSSA, MFA, Options, Servers) -> + ?option_time(hipe_icode_type:cfg(IcodeSSA, MFA, Options, Servers), + "Icode SSA type info", Options). + +icode_range_analysis(IcodeSSA, MFA, Options, Servers) -> + case proplists:get_bool(icode_range, Options) of + true -> + ?option_time(hipe_icode_range:cfg(IcodeSSA, MFA, Options, Servers), + "Icode SSA integer range analysis", Options); + false -> + IcodeSSA + end. + +icode_ssa_dead_code_elimination(IcodeSSA, Options) -> + IcodeSSA1 = ?option_time(hipe_icode_ssa:remove_dead_code(IcodeSSA), + "Icode SSA dead code elimination pass 2", + Options), + hipe_icode_cfg:remove_unreachable_code(IcodeSSA1). + +icode_ssa_check(IcodeSSA, Options) -> + ?when_option(icode_ssa_check, Options, + ?option_time(hipe_icode_ssa:check(IcodeSSA), + "Icode check for SSA-ness", Options)). + +icode_ssa_unconvert(IcodeSSA, Options) -> + ?option_time(hipe_icode_ssa:unconvert(IcodeSSA), + "Icode SSA unconversion", Options). + + +%%===================================================================== +%% +%% @spec icode_to_rtl(MFA::mfa(), Icode, options()) -> Linear_RTL_code +%% @end +%%===================================================================== + +%%--------------------------------------------------------------------- +%% +%% The passes on RTL are as follows: +%% +%% 1. The translation to RTL, in particular the way exceptions are +%% currently handled in RTL, introduces some unreachable code. +%% Therefore, unreachable code is removed early on followed by a +%% pass that removes trivial basic blocks so as to have smaller +%% code to play with. +%% +%% 2. Code is then converted to SSA so as to perform as many +%% optimizations as possible in this pass. +%% Currently, the following optimizations are performed on SSA: +%% - sparse conditional constant propagation (controlled by an option) +%% - dead code elimination +%% - detection of available exceptions +%% - partial redundancy elimination (controlled by an option) +%% Finally, code is converted back to non-SSA form. +%% +%% 3. rtl_symbolic expands some symbolic instructions. +%% +%% 4. rtl_lcm performs a lazy code motion on RTL. +%% +%%---------------------------------------------------------------------- + +icode_to_rtl(MFA, Icode, Options, Servers) -> + debug("ICODE -> RTL: ~w, ~w~n", [MFA, hash(Icode)], Options), + LinearRTL = translate_to_rtl(Icode, Options), + pp(LinearRTL, MFA, rtl_linear, pp_rtl_linear, Options, Servers), + RtlCfg = initialize_rtl_cfg(LinearRTL, Options), + %% hipe_rtl_cfg:pp(RtlCfg), + RtlCfg0 = hipe_rtl_cfg:remove_unreachable_code(RtlCfg), + RtlCfg1 = hipe_rtl_cfg:remove_trivial_bbs(RtlCfg0), + %% hipe_rtl_cfg:pp(RtlCfg1), + RtlCfg2 = rtl_ssa(RtlCfg1, Options), + RtlCfg3 = rtl_symbolic(RtlCfg2, Options), + %% hipe_rtl_cfg:pp(RtlCfg3), + pp(RtlCfg3, MFA, rtl_liveness, pp_rtl_liveness, Options, Servers), + RtlCfg4 = rtl_lcm(RtlCfg3, Options), + pp(RtlCfg4, MFA, rtl, pp_rtl, Options, Servers), + LinearRTL1 = hipe_rtl_cfg:linearize(RtlCfg4), + LinearRTL2 = hipe_rtl_cleanup_const:cleanup(LinearRTL1), + %% hipe_rtl:pp(standard_io, LinearRTL2), + LinearRTL2. + +translate_to_rtl(Icode, Options) -> + %% GC tests should have been added in the conversion to Icode. + ?option_time(hipe_icode2rtl:translate(Icode, Options), + "translate", Options). + +initialize_rtl_cfg(LinearRTL, Options) -> + ?option_time(hipe_rtl_cfg:init(LinearRTL), "to cfg", Options). + +rtl_symbolic(RtlCfg, Options) -> + ?option_time(hipe_rtl_symbolic:expand(RtlCfg), + "Expansion of symbolic instructions", Options). + +%%---------------------------------------------------------------------- +%% +%% RTL passes on SSA form. The following constraints are applicable: +%% +%% 1. ssa_convert must be first and ssa_unconvert last. +%% +%% 2. dead_code_elimination should be performed after conditional +%% constant propagation in order to cleanup dead code that might +%% be created by that pass. +%% +%% 3. avail_expr ... (PER ADD THIS) +%% +%% 4. rtl_ssapre performs A-SSAPRE and has to be done after all other +%% optimizations. +%% +%% 5. ssa_check could be put in between all passes to make sure that +%% they preserve SSA-ness. +%% +%%---------------------------------------------------------------------- + +rtl_ssa(RtlCfg0, Options) -> + case proplists:get_bool(rtl_ssa, Options) of + true -> + ?opt_start_timer("RTL SSA passes"), + RtlSSA0 = rtl_ssa_convert(RtlCfg0, Options), + RtlSSA1 = rtl_ssa_const_prop(RtlSSA0, Options), + %% RtlSSA1a = rtl_ssa_copy_prop(RtlSSA1, Options), + RtlSSA2 = rtl_ssa_dead_code_elimination(RtlSSA1, Options), + RtlSSA3 = rtl_ssa_avail_expr(RtlSSA2, Options), + RtlSSA4 = rtl_ssapre(RtlSSA3, Options), + %% rtl_ssa_check(RtlSSA4, Options), %% just for sanity + RtlCfg = rtl_ssa_unconvert(RtlSSA4, Options), + case proplists:get_bool(pp_rtl_ssa, Options) of + true -> + io:format("%%------------- After SSA un-conversion -----------\n"), + hipe_rtl_cfg:pp(RtlCfg); + false -> + ok + end, + ?opt_stop_timer("RTL SSA passes"), + RtlCfg; + false -> + RtlCfg0 + end. + +rtl_ssa_convert(RtlCfg, Options) -> + case proplists:get_bool(pp_rtl_ssa, Options) of + true -> + io:format("%%------------- Before SSA conversion --------------\n"), + hipe_rtl_cfg:pp(RtlCfg), + io:format("%%------------- After SSA conversion --------------\n"), + RtlCfgSSA = hipe_rtl_ssa:convert(RtlCfg), + hipe_rtl_cfg:pp(RtlCfgSSA), + io:format("%%------------- SSA check warnings below -----------\n"), + hipe_rtl_ssa:check(RtlCfgSSA), + RtlCfgSSA; + false -> + ?option_time(hipe_rtl_ssa:convert(RtlCfg), + "RTL SSA conversion", Options) + end. + +rtl_ssa_const_prop(RtlCfgSSA, Options) -> + case proplists:get_bool(rtl_ssa_const_prop, Options) of + true -> + ?option_time(hipe_rtl_ssa_const_prop:propagate(RtlCfgSSA), + "RTL SSA sparse conditional constant propagation", Options); + false -> + RtlCfgSSA + end. + +rtl_ssa_dead_code_elimination(RtlCfgSSA, Options) -> + ?option_time(hipe_rtl_ssa:remove_dead_code(RtlCfgSSA), + "RTL SSA dead code elimination", Options). + +rtl_ssa_avail_expr(RtlCfgSSA, Options) -> + ?option_time(hipe_rtl_ssa_avail_expr:cfg(RtlCfgSSA), + "RTL SSA heap optimizations", Options). + +%%--------------------------------------------------------------------- + +rtl_ssapre(RtlCfg, Options) -> + case proplists:get_bool(rtl_ssapre, Options) of + true -> + ?opt_start_timer("Partial Redundancy Elimination (A-SSAPRE)"), + NewRtlCfg = hipe_rtl_ssapre:rtl_ssapre(RtlCfg, Options), + ?opt_stop_timer("Partial Redundancy Elimination (A-SSAPRE)"), + NewRtlCfg; + false -> + RtlCfg + end. + +%%--------------------------------------------------------------------- + +rtl_ssa_unconvert(RtlCfgSSA, Options) -> + ?option_time(hipe_rtl_ssa:unconvert(RtlCfgSSA), + "RTL SSA un-convert", Options). + +%%--------------------------------------------------------------------- + +rtl_lcm(RtlCfg, Options) -> + case proplists:get_bool(rtl_lcm, Options) of + true -> + ?opt_start_timer("RTL lazy code motion"), + %% ?option_time(hipe_rtl_lcm:rtl_lcm(RtlCfg, Options), + %% "RTL lazy code motion", Options); + RtlCfg1 = hipe_rtl_lcm:rtl_lcm(RtlCfg, Options), + ?opt_stop_timer("RTL lazy code motion"), + RtlCfg1; + false -> + RtlCfg + end. + +%%===================================================================== +%% Translation to native code takes place in the corresponding back-end +%%===================================================================== + +rtl_to_native(MFA, LinearRTL, Options, DebugState) -> + ?opt_start_timer("Native code"), + LinearNativeCode = + case get(hipe_target_arch) of + ultrasparc -> + hipe_sparc_main:rtl_to_sparc(MFA, LinearRTL, Options); + powerpc -> + hipe_ppc_main:rtl_to_ppc(MFA, LinearRTL, Options); + arm -> + hipe_arm_main:rtl_to_arm(MFA, LinearRTL, Options); + x86 -> + hipe_x86_main:rtl_to_x86(MFA, LinearRTL, Options); + amd64 -> + hipe_amd64_main:rtl_to_amd64(MFA, LinearRTL, Options) + end, + ?opt_stop_timer("Native code"), + put(hipe_debug, DebugState), + LinearNativeCode. + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Debugging stuff ... +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +debug(Text, Args, Options) -> + ?when_option(debug, Options, ?msg(Text,Args)). + +hash(X) -> + erlang:phash(X, 16#7f3f5f1). |