The R13B03 release.OTP_R13B03

1 files changed, 285 insertions, 0 deletions

diff --git a/lib/hipe/arm/hipe_arm_ra_finalise.erl b/lib/hipe/arm/hipe_arm_ra_finalise.erl
new file mode 100644
index 0000000000..9edc362e90
--- /dev/null
+++ b/lib/hipe/arm/hipe_arm_ra_finalise.erl
@@ -0,0 +1,285 @@
+%% -*- erlang-indent-level: 2 -*-
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2005-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%
+%%
+
+-module(hipe_arm_ra_finalise).
+-export([finalise/3]).
+-include("hipe_arm.hrl").
+
+finalise(Defun, TempMap, _FPMap0=[]) ->
+  Code = hipe_arm:defun_code(Defun),
+  {_, SpillLimit} = hipe_arm:defun_var_range(Defun),
+  Map = mk_ra_map(TempMap, SpillLimit),
+  NewCode = ra_code(Code, Map, []),
+  Defun#defun{code=NewCode}.
+
+ra_code([I|Insns], Map, Accum) ->
+  ra_code(Insns, Map, [ra_insn(I, Map) | Accum]);
+ra_code([], _Map, Accum) ->
+  lists:reverse(Accum).
+
+ra_insn(I, Map) ->
+  case I of
+    #alu{} -> ra_alu(I, Map);
+    #cmp{} -> ra_cmp(I, Map);
+    #load{} -> ra_load(I, Map);
+    #ldrsb{} -> ra_ldrsb(I, Map);
+    #move{} -> ra_move(I, Map);
+    #pseudo_call{} -> ra_pseudo_call(I, Map);
+    #pseudo_li{} -> ra_pseudo_li(I, Map);
+    #pseudo_move{} -> ra_pseudo_move(I, Map);
+    #pseudo_switch{} -> ra_pseudo_switch(I, Map);
+    #pseudo_tailcall{} -> ra_pseudo_tailcall(I, Map);
+    #smull{} -> ra_smull(I, Map);
+    #store{} -> ra_store(I, Map);
+    _ -> I
+  end.
+
+ra_alu(I=#alu{dst=Dst,src=Src,am1=Am1}, Map) ->
+  NewDst = ra_temp(Dst, Map),
+  NewSrc = ra_temp(Src, Map),
+  NewAm1 = ra_am1(Am1, Map),
+  I#alu{dst=NewDst,src=NewSrc,am1=NewAm1}.
+
+ra_cmp(I=#cmp{src=Src,am1=Am1}, Map) ->
+  NewSrc = ra_temp(Src, Map),
+  NewAm1 = ra_am1(Am1, Map),
+  I#cmp{src=NewSrc,am1=NewAm1}.
+
+ra_load(I=#load{dst=Dst,am2=Am2}, Map) ->
+  NewDst = ra_temp(Dst, Map),
+  NewAm2 = ra_am2(Am2, Map),
+  I#load{dst=NewDst,am2=NewAm2}.
+
+ra_ldrsb(I=#ldrsb{dst=Dst,am3=Am3}, Map) ->
+  NewDst = ra_temp(Dst, Map),
+  NewAm3 = ra_am3(Am3, Map),
+  I#ldrsb{dst=NewDst,am3=NewAm3}.
+
+ra_move(I=#move{dst=Dst,am1=Am1}, Map) ->
+  NewDst = ra_temp(Dst, Map),
+  NewAm1 = ra_am1(Am1, Map),
+  I#move{dst=NewDst,am1=NewAm1}.
+
+ra_pseudo_call(I=#pseudo_call{funv=FunV}, Map) ->
+  NewFunV = ra_funv(FunV, Map),
+  I#pseudo_call{funv=NewFunV}.
+
+ra_pseudo_li(I=#pseudo_li{dst=Dst}, Map) ->
+  NewDst = ra_temp(Dst, Map),
+  I#pseudo_li{dst=NewDst}.
+
+ra_pseudo_move(I=#pseudo_move{dst=Dst,src=Src}, Map) ->
+  NewDst = ra_temp(Dst, Map),
+  NewSrc = ra_temp(Src, Map),
+  I#pseudo_move{dst=NewDst,src=NewSrc}.
+
+ra_pseudo_switch(I=#pseudo_switch{jtab=JTab,index=Index}, Map) ->
+  NewJTab = ra_temp(JTab, Map),
+  NewIndex = ra_temp(Index, Map),
+  I#pseudo_switch{jtab=NewJTab,index=NewIndex}.
+
+ra_pseudo_tailcall(I=#pseudo_tailcall{funv=FunV,stkargs=StkArgs}, Map) ->
+  NewFunV = ra_funv(FunV, Map),
+  NewStkArgs = ra_args(StkArgs, Map),
+  I#pseudo_tailcall{funv=NewFunV,stkargs=NewStkArgs}.
+
+ra_smull(I=#smull{dstlo=DstLo,dsthi=DstHi,src1=Src1,src2=Src2}, Map) ->
+  NewDstLo = ra_temp(DstLo, Map),
+  NewDstHi = ra_temp(DstHi, Map),
+  NewSrc1 = ra_temp(Src1, Map),
+  NewSrc2 = ra_temp(Src2, Map),
+  I#smull{dstlo=NewDstLo,dsthi=NewDstHi,src1=NewSrc1,src2=NewSrc2}.
+
+ra_store(I=#store{src=Src,am2=Am2}, Map) ->
+  NewSrc = ra_temp(Src, Map),
+  NewAm2 = ra_am2(Am2, Map),
+  I#store{src=NewSrc,am2=NewAm2}.
+
+%%% Tailcall stack arguments.
+
+ra_args([Arg|Args], Map) ->
+  [ra_temp_or_imm(Arg, Map) | ra_args(Args, Map)];
+ra_args([], _) ->
+  [].
+
+ra_temp_or_imm(Arg, Map) ->
+  case hipe_arm:is_temp(Arg) of
+    true ->
+      ra_temp(Arg, Map);
+    false ->
+      Arg
+  end.
+
+%%% FunV, Am, and Temp operands.
+
+ra_funv(FunV, Map) ->
+  case FunV of
+    #arm_temp{} -> ra_temp(FunV, Map);
+    _ -> FunV
+  end.
+
+ra_am1(Am1, Map) ->
+  case Am1 of
+    #arm_temp{} ->
+      ra_temp(Am1, Map);
+    {Src2,rrx} ->
+      NewSrc2 = ra_temp(Src2, Map),
+      {NewSrc2,rrx};
+    {Src2,ShiftOp,ShiftArg} ->
+      NewSrc2 = ra_temp(Src2, Map),
+      NewArg =
+	case ShiftArg of
+	  #arm_temp{} -> ra_temp(ShiftArg, Map);
+	  _ -> ShiftArg
+	end,
+      {NewSrc2,ShiftOp,NewArg};
+    _ ->
+      Am1
+  end.
+
+ra_am2(Am2=#am2{src=Src2,offset=Offset}, Map) ->
+  NewSrc2 = ra_temp(Src2, Map),
+  NewOffset = ra_am2offset(Offset, Map),
+  Am2#am2{src=NewSrc2,offset=NewOffset}.
+
+ra_am2offset(Offset, Map) ->
+  case Offset of
+    #arm_temp{} ->
+      ra_temp(Offset, Map);
+    {Src3,rrx} ->
+      NewSrc3 = ra_temp(Src3, Map),
+      {NewSrc3,rrx};
+    {Src3,ShiftOp,Imm5} ->
+      NewSrc3 = ra_temp(Src3, Map),
+      {NewSrc3,ShiftOp,Imm5};
+    _ ->
+      Offset
+  end.
+
+ra_am3(Am3=#am3{src=Src2,offset=Offset}, Map) ->
+  NewSrc2 = ra_temp(Src2, Map),
+  NewOffset = ra_am3offset(Offset, Map),
+  Am3#am3{src=NewSrc2,offset=NewOffset}.
+
+ra_am3offset(Offset, Map) ->
+  case Offset of
+    #arm_temp{} -> ra_temp(Offset, Map);
+    _ -> Offset
+  end.
+
+-ifdef(notdef). % for FP regalloc
+ra_temp_fp(Temp, FPMap) ->
+  Reg = hipe_arm:temp_reg(Temp),
+  case hipe_arm:temp_type(Temp) of
+    'double' ->
+      case hipe_arm_registers:is_precoloured_fpr(Reg) of
+	true -> Temp;
+	_ -> ra_temp_common(Reg, Temp, FPMap)
+      end
+  end.
+-endif.
+
+ra_temp(Temp, Map) ->
+  Reg = hipe_arm:temp_reg(Temp),
+  case hipe_arm:temp_type(Temp) of
+    'double' ->
+      exit({?MODULE,ra_temp,Temp});
+    _ ->
+      case hipe_arm_registers:is_precoloured_gpr(Reg) of
+	true -> Temp;
+	_ -> ra_temp_common(Reg, Temp, Map)
+      end
+  end.
+
+ra_temp_common(Reg, Temp, Map) ->
+  case gb_trees:lookup(Reg, Map) of
+    {value,NewReg} -> Temp#arm_temp{reg=NewReg};
+    _ -> Temp
+  end.
+
+mk_ra_map(TempMap, SpillLimit) ->
+  %% Build a partial map from pseudo to reg or spill.
+  %% Spills are represented as pseudos with indices above SpillLimit.
+  %% (I'd prefer to use negative indices, but that breaks
+  %% hipe_arm_registers:is_precoloured/1.)
+  %% The frame mapping proper is unchanged, since spills look just like
+  %% ordinary (un-allocated) pseudos.
+  lists:foldl(fun(MapLet, Map) ->
+		  {Key,Val} = conv_ra_maplet(MapLet, SpillLimit, is_precoloured_gpr),
+		  gb_trees:insert(Key, Val, Map)
+	      end,
+	      gb_trees:empty(),
+	      TempMap).
+
+conv_ra_maplet(MapLet = {From,To}, SpillLimit, IsPrecoloured) ->
+  %% From should be a pseudo, or a hard reg mapped to itself.
+  if is_integer(From), From =< SpillLimit ->
+      case hipe_arm_registers:IsPrecoloured(From) of
+	false -> [];
+	_ ->
+	  case To of
+	    {reg, From} -> [];
+	    _ -> exit({?MODULE,conv_ra_maplet,MapLet})
+	  end
+      end;
+     true -> exit({?MODULE,conv_ra_maplet,MapLet})
+  end,
+  %% end of From check
+  case To of
+    {reg, NewReg} ->
+      %% NewReg should be a hard reg, or a pseudo mapped
+      %% to itself (formals are handled this way).
+      if is_integer(NewReg) ->
+	  case hipe_arm_registers:IsPrecoloured(NewReg) of
+	    true -> [];
+	    _ -> if From =:= NewReg -> [];
+		    true ->
+		     exit({?MODULE,conv_ra_maplet,MapLet})
+		 end
+	  end;
+	 true -> exit({?MODULE,conv_ra_maplet,MapLet})
+      end,
+      %% end of NewReg check
+      {From, NewReg};
+    {spill, SpillIndex} ->
+      %% SpillIndex should be >= 0.
+      if is_integer(SpillIndex), SpillIndex >= 0 -> [];
+	 true -> exit({?MODULE,conv_ra_maplet,MapLet})
+      end,
+      %% end of SpillIndex check
+      ToTempNum = SpillLimit+SpillIndex+1,
+      MaxTempNum = hipe_gensym:get_var(arm),
+      if MaxTempNum >= ToTempNum -> ok;
+	 true -> hipe_gensym:set_var(arm, ToTempNum)
+      end,
+      {From, ToTempNum};
+    _ -> exit({?MODULE,conv_ra_maplet,MapLet})
+  end.
+
+-ifdef(notdef). % for FP regalloc
+mk_ra_map_fp(FPMap, SpillLimit) ->
+  lists:foldl(fun(MapLet, Map) ->
+		  {Key,Val} = conv_ra_maplet(MapLet, SpillLimit,
+					     is_precoloured_fpr),
+		  gb_trees:insert(Key, Val, Map)
+	      end,
+	      gb_trees:empty(),
+	      FPMap).
+-endif.