← Back to branch summary

~statik/ubuntu/maverick/erlang/erlang-merge-testing

« back to all changes in this revision

Viewing changes to lib/hipe/icode/hipe_icode_ssa_struct_reuse.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-05-01 10:14:38 UTC
  • mfrom: (3.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090501101438-6qlr6rsdxgyzrg2z
Tags: 1:13.b-dfsg-2
* Cleaned up patches: removed unneeded patch which helped to support
  different SCTP library versions, made sure that changes for m68k
  architecture applied only when building on this architecture.
* Removed duplicated information from binary packages descriptions.
* Don't require libsctp-dev build-dependency on solaris-i386 architecture
  which allows to build Erlang on Nexenta (thanks to Tim Spriggs for
  the suggestion).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/hipe/icode/hipe_icode_ssa_struct_reuse.erl
1
1
%% -*- erlang-indent-level: 2 -*-
 
2
%%
 
3
%% %CopyrightBegin%
 
4
%% 
 
5
%% Copyright Ericsson AB 2007-2009. All Rights Reserved.
 
6
%% 
 
7
%% The contents of this file are subject to the Erlang Public License,
 
8
%% Version 1.1, (the "License"); you may not use this file except in
 
9
%% compliance with the License. You should have received a copy of the
 
10
%% Erlang Public License along with this software. If not, it can be
 
11
%% retrieved online at http://www.erlang.org/.
 
12
%% 
 
13
%% Software distributed under the License is distributed on an "AS IS"
 
14
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 
15
%% the License for the specific language governing rights and limitations
 
16
%% under the License.
 
17
%% 
 
18
%% %CopyrightEnd%
 
19
%%
2
20
%%%=======================================================================
3
21
%% File        : hipe_icode_ssa_struct_reuse.erl
4
22
%% Author      : Ragnar Osterlund <ragoster@gmail.com>
15
33
%%=======================================================================
16
34
 
17
35
-module(hipe_icode_ssa_struct_reuse).
 
36
 
18
37
-export([struct_reuse/1]).
19
38
 
20
39
-include("../main/hipe.hrl").
51
70
%% var - maps variables to expression value numbers. These variables are
52
71
%% defined or used by the structure expressions.
53
72
 
54
 
-record(maps, {var = gb_trees:empty()   :: gb_tree(),
 
73
-record(maps, {var   = gb_trees:empty() :: gb_tree(),
55
74
               instr = gb_trees:empty() :: gb_tree(),
56
 
               expr = gb_trees:empty()  :: gb_tree()
57
 
              }).
 
75
               expr  = gb_trees:empty() :: gb_tree()}).
58
76
 
59
77
maps_var(#maps{var = Out}) -> Out.
60
78
maps_instr(#maps{instr = Out}) -> Out.
85
103
maps_balance(Maps) ->
86
104
  Maps#maps{instr = gb_trees:balance(maps_instr(Maps)),
87
105
            expr = gb_trees:balance(maps_expr(Maps)),
88
 
            var = gb_trees:balance(maps_var(Maps))
89
 
           }.
 
106
            var = gb_trees:balance(maps_var(Maps))}.
90
107
 
91
108
maps_expr_key_enter(Expr, Maps) ->
92
109
  NewMaps = maps_instr_enter(expr_key(Expr), expr_id(Expr), Maps),
152
169
%% exprid - a expression value number which is the expression that
153
170
%%          the variable is defined by.
154
171
 
155
 
-record(varinfo, {use = ?SETS:new()     :: ?SET(_),
156
 
                  ref = none            :: 'none' | {non_neg_integer(),non_neg_integer()},
157
 
                  elem = none           :: 'none' | {icode_var(), non_neg_integer()},
158
 
                  exprid = none         :: 'none' | non_neg_integer()}).
 
172
-record(varinfo, {use = ?SETS:new() :: ?SET(_),
 
173
                  ref = none        :: 'none' | {non_neg_integer(),non_neg_integer()},
 
174
                  elem = none       :: 'none' | {icode_var(), non_neg_integer()},
 
175
                  exprid = none     :: 'none' | non_neg_integer()}).
159
176
 
160
177
varinfo_exprid(#varinfo{exprid = Out}) -> Out.
161
178
 
340
357
%%      has been inserted is used to move the reduction test.
341
358
 
342
359
-record(update, {inserted     = gb_trees:empty() :: gb_tree(),
343
 
                 del_red_test = false            :: bool()
344
 
                }).
 
360
                 del_red_test = false            :: bool()}).
345
361
 
346
362
update_inserted_lookup(#update{inserted = Inserted}, ExprId) ->
347
363
  gb_trees:lookup(ExprId, Inserted).
348
364
 
349
365
update_inserted_add_new(Update = #update{inserted = Inserted}, ExprId, Defs) ->
350
 
  VarList =  
351
 
    lists:map(fun(Def) ->
352
 
                  case hipe_icode:is_var(Def) of
353
 
                    true -> hipe_icode:mk_new_var();
354
 
                    false ->
355
 
                      case hipe_icode:is_reg(Def) of
356
 
                        true -> hipe_icode:mk_new_reg();
357
 
                        false ->
358
 
                          case hipe_icode:is_fvar(Def) of
359
 
                            true -> hipe_icode:mk_new_fvar()
360
 
                          end
361
 
                      end
362
 
                  end
363
 
              end, Defs),
364
 
 
 
366
  VarList = [case hipe_icode:is_var(Def) of
 
367
               true -> hipe_icode:mk_new_var();
 
368
               false ->
 
369
                 case hipe_icode:is_reg(Def) of
 
370
                   true -> hipe_icode:mk_new_reg();
 
371
                   false ->
 
372
                     true = hipe_icode:is_fvar(Def),
 
373
                     hipe_icode:mk_new_fvar()
 
374
                 end
 
375
             end || Def <- Defs],
365
376
  NewInserted = gb_trees:enter(ExprId, VarList, Inserted),
366
377
  {Update#update{inserted = NewInserted}, VarList}.
367
378
 
372
383
update_del_red_test_set(Update) -> 
373
384
  Update#update{del_red_test = true}.
374
385
 
375
 
 
376
386
%%-----------------------------------------------------------------------------
377
387
%% CODE AREA
378
388
 
443
453
  NewNodes = prune_nodes(Nodes, NonFailSet),
444
454
 
445
455
  %% fill in misc node tree info
446
 
  Postorder = lists:filter(fun(Label) -> gb_sets:is_member(Label, NonFailSet) 
447
 
                           end, hipe_icode_cfg:postorder(CFG)),
 
456
  Postorder = [Label || Label <- hipe_icode_cfg:postorder(CFG),
 
457
                        gb_sets:is_member(Label, NonFailSet)],
448
458
 
449
459
  %% check postorder is valid
450
460
  PostOrderTmp = hipe_icode_cfg:postorder(CFG),
463
473
  StartLabel = hipe_icode_cfg:start_label(CFG),
464
474
  NewTree = gb_trees:balance(nodes_tree(NewNodes)),
465
475
  
466
 
  NewNodes#nodes{
467
 
    postorder = Postorder, 
468
 
    rev_postorder = RevPostorder,
469
 
    start_label = StartLabel,
470
 
    tree = NewTree, 
471
 
    domtree = DomTree}.
472
 
 
 
476
  NewNodes#nodes{postorder = Postorder, 
 
477
                 rev_postorder = RevPostorder,
 
478
                 start_label = StartLabel,
 
479
                 tree = NewTree, 
 
480
                 domtree = DomTree}.
473
481
 
474
482
%%-----------------------------------------------------------------------------
475
 
%% Constucts a tree of nodes, one node for each basic block in CFG
 
483
%% Constructs a tree of nodes, one node for each basic block in CFG
476
484
 
477
485
nodes_from_cfg(CFG, DomTree) ->
478
486
  lists:foldl(fun(Label, {NodesAcc, NonFailAcc}) -> 
585
593
  lists:foldl(fun(Node, NodesAcc) -> 
586
594
   case gb_sets:is_member(node_label(Node), NonFailSet) of
587
595
      true ->
588
 
        NewSucc = lists:filter(fun(Label) ->
589
 
          gb_sets:is_member(Label, NonFailSet) end, node_succ(Node)),
590
 
 
591
 
        NewPred = lists:filter(fun(Label) ->
592
 
          gb_sets:is_member(Label, NonFailSet) end, node_pred(Node)),
593
 
 
 
596
        NewSucc = [L || L <- node_succ(Node), gb_sets:is_member(L, NonFailSet)],
 
597
        NewPred = [L || L <- node_pred(Node), gb_sets:is_member(L, NonFailSet)],
594
598
        enter_node(Node#node{succ = NewSucc, pred = NewPred}, NodesAcc);
595
 
 
596
599
      false ->
597
600
        remove_node(Node, NodesAcc)
598
601
    end
599
602
  end, Nodes, nodes_tree_values(Nodes)).
600
603
 
601
 
 
602
604
%%-----------------------------------------------------------------------------
603
605
%% Map calculations. 
604
606
 
610
612
    Node = get_node(Label, Nodes),
611
613
    NewMapsAcc = maps_from_node_struct_type(MapsAcc, Node),
612
614
    NewMapsAcc2 = maps_from_node_struct_elems(NewMapsAcc, Node),
613
 
    %NewMapsAcc3 = maps_from_node_atom_type(NewMapsAcc2, Node),
 
615
    %% NewMapsAcc3 = maps_from_node_atom_type(NewMapsAcc2, Node),
614
616
    maps_from_node_code(NewMapsAcc2, Node)
615
617
  end, #maps{}, nodes_rev_postorder(Nodes)),
616
618
  maps_balance(Maps).
617
619
 
 
620
%%-----------------------------------------------------------------------------
 
621
%% Add all elements in the struct_type list of Node to Maps as expressions
 
622
 
 
623
maps_from_node_struct_type(Maps, Node) ->
 
624
  %% debug_struct("Node Label: ", node_label(Node)),
 
625
  %% debug_struct("Node Tuple Type: ", node_struct_type(Node)),
 
626
  lists:foldl(fun({Type, Var, Size}, MapsAcc) ->
 
627
                  Key = create_elem_expr_key(Size, Var, []),
 
628
                  InstrKey = hipe_icode:mk_primop([], Type, Key),
 
629
                  NewExpr2 = expr_create(InstrKey, [Var]),
 
630
                  NewExpr3 = expr_direct_replace_set(NewExpr2, true),
 
631
                  maps_expr_key_enter(NewExpr3, MapsAcc)
 
632
              end, Maps, node_struct_type(Node)).
 
633
 
618
634
create_elem_expr_key(0, _, Key) -> Key;
619
635
create_elem_expr_key(N, Var, Key) -> 
620
636
  create_elem_expr_key(N - 1, Var, [{Var, N} | Key]).
621
637
 
622
 
 
623
 
%%-----------------------------------------------------------------------------
624
 
%% Add all elements in the struct_type list of Node to Maps as expressions
625
 
 
626
 
maps_from_node_struct_type(Maps, Node) ->
627
 
  %debug_struct("Node Label: ", node_label(Node)),
628
 
  %debug_struct("Node Tuple Type: ", node_struct_type(Node)),
629
 
 
630
 
  lists:foldl(fun({Type, Var, Size}, MapsAcc) ->
631
 
    Key = create_elem_expr_key(Size, Var, []),
632
 
    InstrKey = hipe_icode:mk_primop([], Type, Key),
633
 
 
634
 
    NewExpr2 = expr_create(InstrKey, [Var]),
635
 
    NewExpr3 = expr_direct_replace_set(NewExpr2, true),
636
 
    NewMapsAcc = maps_expr_key_enter(NewExpr3, MapsAcc),
637
 
    NewMapsAcc
638
 
 
639
 
  end, Maps, node_struct_type(Node)).
640
 
 
641
 
 
642
638
%%-----------------------------------------------------------------------------
643
639
%%maps_from_node_atom_type(Maps, Node) ->
644
640
%%  lists:foldl(fun({Var, Atom}, MapsAcc) ->
679
675
%% Also insert information about all affected variables into Maps.
680
676
 
681
677
maps_from_node_code(Maps, Node) ->
682
 
  %%debug_struct("Node Label: ", Label),
683
 
  %%debug_struct("Node Code: ", Code),
684
 
  %Label = node_label(Node),
685
 
 
 
678
  %% debug_struct("Node Label: ", Label),
 
679
  %% debug_struct("Node Code: ", Code),
 
680
  %% Label = node_label(Node),
686
681
  lists:foldl(fun(Instr, MapsAcc) ->
687
682
    %% create two keys that are used to reference this structure creation
688
683
    %% instruction, so that we can lookup its expression value number
747
742
 
748
743
maps_expr_varinfos_create(Instr, RefKey, Maps) ->
749
744
  Defines = hipe_icode:defines(Instr),
750
 
 
751
 
  case maps_instr_lookup(RefKey, Maps) of
752
 
    {value, ExprId} -> 
753
 
      Maps2 = Maps;
754
 
    none ->
755
 
      NewExpr = expr_create(RefKey, Defines),
756
 
      ExprId = expr_id(NewExpr),
757
 
      Maps2 = maps_expr_key_enter(NewExpr, Maps)
758
 
  end,
759
 
  
 
745
  {ExprId, Maps2} =
 
746
    case maps_instr_lookup(RefKey, Maps) of
 
747
      {value, EId} -> 
 
748
        {EId, Maps};
 
749
      none ->
 
750
        NewExpr = expr_create(RefKey, Defines),
 
751
        {expr_id(NewExpr), maps_expr_key_enter(NewExpr, Maps)}
 
752
    end,
760
753
  Maps3 = maps_varinfos_create(Defines, ExprId, none, Maps2),
761
754
  update_maps_var_use(Instr, ExprId, Maps3).
762
755
 
769
762
 
770
763
replace_call_vars_elems(Maps, Instr) ->
771
764
  VarMap = maps_var(Maps),
772
 
 
773
765
  {HasElems, Vars, Elems} = 
774
766
    lists:foldr(fun(Arg, {HasElems, Vars, Elems}) -> 
775
767
      case hipe_icode:is_const(Arg) of
789
781
        true ->
790
782
          {HasElems, [Arg | Vars], [Arg | Elems]}
791
783
      end end, {false, [], []}, hipe_icode:args(Instr)),
792
 
 
793
784
  {HasElems, hipe_icode:call_args_update(Instr, Vars), 
794
785
  hipe_icode:call_args_update(Instr, Elems)}.
795
786
 
801
792
 
802
793
update_maps_var_use(Instr, Id, Maps) ->
803
794
  lists:foldl(fun(Use, MapsAcc) ->
804
 
    VarInfo = get_varinfo(Use, MapsAcc),
805
 
 
806
 
    NewVarInfo = varinfo_use_add(VarInfo, Id),
807
 
    MapsAcc2 = maps_var_enter(Use, NewVarInfo, MapsAcc),
808
 
    
809
 
    case varinfo_exprid(VarInfo) of
810
 
      none ->
811
 
        MapsAcc2;
812
 
      VarExprId -> 
813
 
        Expr = maps_expr_get(VarExprId, MapsAcc2),
814
 
        NewExpr = expr_use_add(Expr, Id),
815
 
        maps_expr_enter(NewExpr, MapsAcc2)
816
 
    end
817
 
 
818
 
  end, Maps, hipe_icode:uses(Instr)).
 
795
                  VarInfo = get_varinfo(Use, MapsAcc),
 
796
                  NewVarInfo = varinfo_use_add(VarInfo, Id),
 
797
                  MapsAcc2 = maps_var_enter(Use, NewVarInfo, MapsAcc),
 
798
                  case varinfo_exprid(VarInfo) of
 
799
                    none ->
 
800
                      MapsAcc2;
 
801
                    VarExprId -> 
 
802
                      Expr = maps_expr_get(VarExprId, MapsAcc2),
 
803
                      NewExpr = expr_use_add(Expr, Id),
 
804
                      maps_expr_enter(NewExpr, MapsAcc2)
 
805
                  end
 
806
              end, Maps, hipe_icode:uses(Instr)).
819
807
 
820
808
%%-----------------------------------------------------------------------------
821
809
%% Looks up an old variable info or creates a new one if none is found.
834
822
%% the result.
835
823
 
836
824
replace_call_variables(Filter, Instr) ->
837
 
  NewArgs = lists:map(fun(Arg) -> 
838
 
                          case hipe_icode:is_const(Arg) of
839
 
                            false -> Filter(Arg);
840
 
                            true -> Arg
841
 
                          end
842
 
                      end, hipe_icode:args(Instr)),
 
825
  NewArgs = [case hipe_icode:is_const(Arg) of
 
826
               false -> Filter(Arg);
 
827
               true -> Arg
 
828
             end || Arg <- hipe_icode:args(Instr)],
843
829
  hipe_icode:call_args_update(Instr, NewArgs).
844
830
 
845
831
%%-----------------------------------------------------------------------------
847
833
 
848
834
init_nodes(Nodes, Maps) ->
849
835
  AllExpr = maps_expr_keys(Maps),
850
 
 
851
836
  lists:foldl(fun(Node, NodesAcc) -> 
852
837
    UEExpr = calc_up_exposed_expr(maps_var(Maps), Node),
853
838
    %% print_list("Up ExprSet: ", ?SETS:to_list(UEExpr)),
863
848
        _ ->
864
849
          AllExpr
865
850
      end,
866
 
 
867
 
    enter_node(Node#node{
868
 
      up_expr = UEExpr,
869
 
      killed_expr = KilledExpr,
870
 
      antic_out = AnticOut}, NodesAcc)
871
 
 
 
851
    enter_node(Node#node{up_expr = UEExpr,
 
852
                         killed_expr = KilledExpr,
 
853
                         antic_out = AnticOut}, NodesAcc)
872
854
  end, nodes_all_expr_set(AllExpr, Nodes), nodes_tree_values(Nodes)).
873
855
 
874
856
%%-----------------------------------------------------------------------------
906
888
 
907
889
calc_killed_expr_defs(Defs, UseSet, Maps) ->
908
890
  lists:foldl(fun(Def, Acc) -> 
909
 
    case maps_var_lookup(Def, Maps) of
910
 
      none ->
911
 
        Acc;
912
 
      {value, #varinfo{use = Use}} ->
913
 
        ?SETS:union(Acc, calc_killed_expr_use(Use, Maps))
914
 
    end
915
 
  end, UseSet, Defs).
 
891
                  case maps_var_lookup(Def, Maps) of
 
892
                    none ->
 
893
                      Acc;
 
894
                    {value, #varinfo{use = Use}} ->
 
895
                      ?SETS:union(Acc, calc_killed_expr_use(Use, Maps))
 
896
                  end
 
897
              end, UseSet, Defs).
916
898
 
917
899
calc_killed_expr_use(ExprIds, Maps) ->
918
900
  ?SETS:fold(fun(Id, Acc) -> 
919
 
    Expr = maps_expr_get(Id, Maps),
920
 
    ?SETS:union(Acc, calc_killed_expr_use(expr_use(Expr), Maps))
921
 
  end, ExprIds, ExprIds).
 
901
                 Expr = maps_expr_get(Id, Maps),
 
902
                 ?SETS:union(Acc, calc_killed_expr_use(expr_use(Expr), Maps))
 
903
             end, ExprIds, ExprIds).
922
904
 
923
905
%%-----------------------------------------------------------------------------
924
906
%% Calculate the anticipated in and anticipated out sets for each node
1071
1053
rewrite_cfg(CFG, Nodes, Maps) ->
1072
1054
  {NewCFG, _Visited} =
1073
1055
    rewrite_cfg(CFG, ?SETS:new(), #update{}, Nodes, Maps, [nodes_start_label(Nodes)]),
1074
 
 
1075
 
  %debug_struct("Visited: ", _Visited),
1076
 
 
 
1056
  %% debug_struct("Visited: ", _Visited),
1077
1057
  NewCFG.
1078
1058
 
1079
1059
%%-----------------------------------------------------------------------------
1086
1066
  lists:foldl(fun(Label, {CFGAcc, VisitedAcc}) -> 
1087
1067
    case ?SETS:is_element(Label, VisitedAcc) of
1088
1068
      false ->
1089
 
        %debug_struct("Visit: ", Label),
1090
 
 
 
1069
        %% debug_struct("Visit: ", Label),
1091
1070
        Node = get_node(Label, Nodes),
1092
1071
        NewVisitedAcc = ?SETS:add_element(Label, VisitedAcc),
1093
 
 
1094
1072
        {NewCFGAcc, NewUpdate} = rewrite_bb(CFGAcc, Update, Maps, Node),
1095
 
        %debug_struct("Update inserted: ", update_inserted_list(NewUpdate)),
1096
 
 
 
1073
        %% debug_struct("Update inserted: ", update_inserted_list(NewUpdate)),
1097
1074
        rewrite_cfg(NewCFGAcc, NewVisitedAcc, NewUpdate, Nodes, Maps, node_succ(Node));
1098
1075
      true ->
1099
1076
        {CFGAcc, VisitedAcc}
1100
1077
    end
1101
1078
  end, {CFG, Visited}, Labels).
1102
1079
 
1103
 
 
1104
1080
%%-----------------------------------------------------------------------------
1105
1081
%% rewrite one single basic block in the CFG as described by the properties
1106
1082
%% in the Node for that block. Uses the Maps and Update info to lookup
1209
1185
 
1210
1186
      %% check if there exists an identical expression, so that
1211
1187
      %% this expression can be replaced directly.
1212
 
      case expr_direct_replace(Expr) of
1213
 
        false ->
1214
 
          NewInstr = rewrite_expr(UpdateAcc2, ExprInstr, NewDefs),
1215
 
          CodeAcc2 = [NewInstr | CodeAcc];
1216
 
        true ->
1217
 
          CodeAcc2 = mk_defs_moves(CodeAcc, NewDefs, Defs)
1218
 
      end,
1219
 
 
 
1188
      CodeAcc2 = 
 
1189
        case expr_direct_replace(Expr) of
 
1190
          false ->
 
1191
            NewInstr = rewrite_expr(UpdateAcc2, ExprInstr, NewDefs),
 
1192
            [NewInstr | CodeAcc];
 
1193
          true ->
 
1194
            mk_defs_moves(CodeAcc, NewDefs, Defs)
 
1195
        end,
1220
1196
      {CodeAcc2, UpdateAcc2}
1221
1197
    end, {CodeRest, NewUpdate}, NewInserts),
1222
1198
 
1249
1225
          lists:nth(Num, DefList);
1250
1226
        _ -> Ref
1251
1227
      end end, Instr),
1252
 
 
1253
1228
  hipe_icode:call_dstlist_update(NewInstr, Defs).
1254
1229
 
1255
 
 
1256
1230
%%-----------------------------------------------------------------------------
1257
1231
%% Make move instructions from Defs list to all variables in
1258
1232
%% the Refs list and insert into Code.
1344
1318
      {tuple_arity, Var, Cases};
1345
1319
    _ -> other
1346
1320
  end.
1347
 
 
1348
1321
    
1349
1322
%%-----------------------------------------------------------------------------
1350
1323
%% Expression ID counter
1374
1347
  Cases = get(Type), 
1375
1348
  NewCases = 
1376
1349
    case gb_trees:lookup(Case, Cases) of
1377
 
      {value, Value} ->
1378
 
        gb_trees:enter(Case, Value + 1, Cases);
1379
 
      _ -> gb_trees:insert(Case, 1, Cases)
 
1350
      {value, Value} -> gb_trees:enter(Case, Value + 1, Cases);
 
1351
      none -> gb_trees:insert(Case, 1, Cases)
1380
1352
    end,
1381
1353
  put(Type, NewCases).
1382
1354
 
1383
 
debug_init_case_count(Type) ->
1384
 
  Cases = get(Type), 
1385
 
  case Cases of
1386
 
    undefined ->
1387
 
      put(Type, gb_trees:empty());
 
1355
debug_init_case_count(Type) -> 
 
1356
  case get(Type) of
 
1357
    undefined -> put(Type, gb_trees:empty());
1388
1358
    _ -> ok
1389
1359
  end.
1390
1360
 
1393
1363
  debug_struct("Case type: ", Type),
1394
1364
  debug_list("Cases: ", gb_trees:to_list(Cases)).
1395
1365
 
1396
 
 
1397
1366
set_debug_flag(Value) ->
1398
 
  put({struct_reuse,debug}, Value).
 
1367
  put({struct_reuse, debug}, Value).
1399
1368
 
1400
 
get_debug_flag() -> get({struct_reuse,debug}).
 
1369
get_debug_flag() -> get({struct_reuse, debug}).
1401
1370
 
1402
1371
debug_function(FuncName, CFG) ->
1403
1372
  Linear = hipe_icode_cfg:cfg_to_linear(CFG),
1404
1373
  Func = hipe_icode:icode_fun(Linear),
1405
 
 
1406
1374
  case Func =:= FuncName orelse FuncName =:= nil of
1407
1375
    true -> 
1408
1376
      set_debug_flag(true),
1409
 
      %debug_struct("Code: ", hipe_icode_cfg:bb(CFG, 15)),
 
1377
      %% debug_struct("Code: ", hipe_icode_cfg:bb(CFG, 15)),
1410
1378
      debug_struct("~nFunction name :", Func);
1411
1379
    false -> 
1412
1380
      set_debug_flag(undefined)
1414
1382
 
1415
1383
debug_cfg_pp(CFG) ->
1416
1384
  case get_debug_flag() of
1417
 
    true ->
1418
 
      hipe_icode_cfg:pp(CFG);
 
1385
    true -> hipe_icode_cfg:pp(CFG);
1419
1386
    _ -> none
1420
1387
  end.
1421
1388
 
1435
1402
 
1436
1403
debug_list(String, List) ->
1437
1404
  case get_debug_flag() of
1438
 
    true ->
1439
 
      print_list(String, List);
 
1405
    true -> print_list(String, List);
1440
1406
    _ -> none
1441
1407
  end.
1442
1408