Add flags to enable/disable specific optimizations

src/aeso_ast_to_fcode.erl

@@ -184,7 +184,7 @@ ast_to_fcode(Code, Options) ->
 optimize(FCode1, Options) ->
     Verbose = lists:member(pp_fcode, Options),
     [io:format("-- Before lambda lifting --\n~s\n\n", [format_fcode(FCode1)]) || Verbose],
-    FCode2 = optimize_fcode(FCode1),
+    FCode2 = optimize_fcode(FCode1, Options),
     [ io:format("-- After optimization --\n~s\n\n", [format_fcode(FCode2)]) || Verbose, FCode2 /= FCode1 ],
     FCode3 = lambda_lift(FCode2),
     [ io:format("-- After lambda lifting --\n~s\n\n", [format_fcode(FCode3)]) || Verbose, FCode3 /= FCode2 ],
@@ -1287,20 +1287,30 @@ lambda_lift_exprs(Layout, As) -> [lambda_lift_expr(Layout, A) || A <- As].
 %% - Constant propagation
 %% - Inlining
 
--spec optimize_fcode(fcode()) -> fcode().
+-spec optimize_fcode(fcode(), [option()]) -> fcode().
-optimize_fcode(Code = #{ functions := Funs }) ->
+optimize_fcode(Code = #{ functions := Funs }, Options) ->
-    Code1 = Code#{ functions := maps:map(fun(Name, Def) -> optimize_fun(Code, Name, Def) end, Funs) },
+    Code1 = Code#{ functions := maps:map(fun(Name, Def) -> optimize_fun(Code, Name, Def, Options) end, Funs) },
     eliminate_dead_code(Code1).
 
--spec optimize_fun(fcode(), fun_name(), fun_def()) -> fun_def().
+-spec optimize_fun(fcode(), fun_name(), fun_def(), [option()]) -> fun_def().
-optimize_fun(Fcode, Fun, Def = #{ body := Body }) ->
+optimize_fun(Fcode, Fun, Def = #{ body := Body0 }, Options) ->
-    %% io:format("Optimizing ~p =\n~s\n", [_Fun, prettypr:format(pp_fexpr(_Body))]),
+    All = proplists:get_value(optimizate_all, Options, true),
-    Def#{ body := drop_unused_lets(
+
-                  simplifier(
+    Inliner              = proplists:get_value(optimizate_inliner,                Options, All),
-                  let_floating(
+    InlineLocalFunctions = proplists:get_value(optimizate_inline_local_functions, Options, All),
-                  bind_subexpressions(
+    BindSubexpressions   = proplists:get_value(optimizate_bind_subexpressions,    Options, All),
-                  inline_local_functions(
+    LetFloating          = proplists:get_value(optimizate_let_floating,           Options, All),
-                  inliner(Fcode, Fun, Body)))))) }.
+    Simplifier           = proplists:get_value(optimizate_simplifier,             Options, All),
+    DropUnusedLets       = proplists:get_value(optimizate_drop_unused_lets,       Options, All),
+
+    Body1 = if Inliner              -> inliner   (Fcode, Fun, Body0); true -> Body0 end,
+    Body2 = if InlineLocalFunctions -> inline_local_functions(Body1); true -> Body1 end,
+    Body3 = if BindSubexpressions   -> bind_subexpressions   (Body2); true -> Body2 end,
+    Body4 = if LetFloating          -> let_floating          (Body3); true -> Body3 end,
+    Body5 = if Simplifier           -> simplifier            (Body4); true -> Body4 end,
+    Body6 = if DropUnusedLets       -> drop_unused_lets      (Body5); true -> Body5 end,
+
+    Def#{ body := Body6 }.
 
 %% --- Inlining ---
 

src/aeso_fcode_to_fate.erl

@@ -77,7 +77,7 @@ compile(ChildContracts, FCode, Options) ->
     #{ contract_name := ContractName,
        functions     := Functions } = FCode,
     SFuns  = functions_to_scode(ChildContracts, ContractName, Functions, Options),
-    SFuns1 = optimize_scode(SFuns, Options),
+    SFuns1 = proplists:get_value(optimize_scode, Options, true) andalso optimize_scode(SFuns, Options),
     FateCode = to_basic_blocks(SFuns1),
     ?debug(compile, Options, "~s\n", [aeb_fate_asm:pp(FateCode)]),
     FateCode.