The R13B03 release.OTP_R13B03

1 files changed, 288 insertions, 0 deletions

diff --git a/lib/hipe/amd64/hipe_amd64_registers.erl b/lib/hipe/amd64/hipe_amd64_registers.erl
new file mode 100644
index 0000000000..4c49eeb00a
--- /dev/null
+++ b/lib/hipe/amd64/hipe_amd64_registers.erl
@@ -0,0 +1,288 @@
+%% -*- erlang-indent-level: 2 -*-
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2004-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_amd64_registers).
+
+-export([
+ 	 all_precoloured/0,
+ 	 allocatable/0,
+	 allocatable_sse2/0,
+	 allocatable_x87/0,
+ 	 arg/1,
+         args/1,
+         call_clobbered/0,
+	 fcalls/0,
+	 float_size/0,
+	 first_virtual/0,
+ 	 heap_limit/0,
+ 	 is_arg/1,
+ 	 is_fixed/1,
+ 	 is_precoloured/1,
+ 	 is_precoloured_sse2/1,
+	 is_precoloured_x87/1,
+ 	 live_at_return/0,
+	 nr_args/0,
+ 	 proc_offset/1,
+ 	 proc_pointer/0,
+ 	 rax/0,
+         rcx/0,
+	 ret/1,
+         sp/0,
+         sp_limit_offset/0,
+	 reg_name/1,
+         alignment/0,
+ 	 tailcall_clobbered/0,
+ 	 temp0/0,
+	 temp1/0,
+	 %% fixed/0,
+	 wordsize/0
+	]).
+
+-include("../rtl/hipe_literals.hrl").
+
+-ifdef(AMD64_HP_IN_REGISTER).
+-export([heap_pointer/0]).
+-endif.
+
+-ifdef(AMD64_FCALLS_IN_REGISTER).
+fcalls_offset() -> false.
+-else.
+fcalls_offset() -> ?P_FCALLS.
+-define(AMD64_FCALLS_REGISTER,16).
+-endif.
+
+-ifdef(AMD64_HEAP_LIMIT_IN_REGISTER).
+heap_limit_offset() -> false.
+-else.
+-define(AMD64_HEAP_LIMIT_REGISTER, 17).
+heap_limit_offset() -> ?P_HP_LIMIT.
+-endif.
+
+
+-define(RAX,  0).
+-define(RCX,  1).
+-define(RDX,  2).
+-define(RBX,  3).
+-define(RSP,  4).
+-define(RBP,  5).
+-define(RSI,  6).
+-define(RDI,  7).
+-define(R8 ,  8).
+-define(R9 ,  9).
+-define(R10, 10).
+-define(R11, 11).
+-define(R12, 12).
+-define(R13, 13).
+-define(R14, 14).
+-define(R15, 15).
+-define(FCALLS,           ?AMD64_FCALLS_REGISTER).
+-define(HEAP_LIMIT,       ?AMD64_HEAP_LIMIT_REGISTER).
+-define(LAST_PRECOLOURED, 17).
+
+-define(ARG0, ?RSI).
+-define(ARG1, ?RDX).
+-define(ARG2, ?RCX).
+-define(ARG3, ?R8).
+-define(ARG4, ?R9).
+-define(ARG5, ?RDI).
+
+-define(TEMP0, ?R14).
+-define(TEMP1, ?R13).
+
+-define(PROC_POINTER, ?RBP).
+
+reg_name(R) ->
+  case R of
+    ?RAX -> "%rax";
+    ?RCX -> "%rcx";
+    ?RDX -> "%rdx";
+    ?RBX -> "%rbx";
+    ?RSP -> "%rsp";
+    ?RBP -> "%rbp";
+    ?RSI -> "%rsi";
+    ?RDI -> "%rdi";
+    ?FCALLS -> "%fcalls";
+    ?HEAP_LIMIT -> "%hplim";
+    Other -> "%r" ++ integer_to_list(Other)
+  end.
+
+alignment() -> 8.  
+
+float_size() -> 8.  
+
+first_virtual() -> ?LAST_PRECOLOURED + 1.
+
+is_precoloured(X) -> X =< ?LAST_PRECOLOURED.
+
+is_precoloured_sse2(X) -> X =< 15.
+
+is_precoloured_x87(X) -> X =< 6.
+
+all_precoloured() ->
+  [?RAX,
+   ?RCX,
+   ?RDX,
+   ?RBX,
+   ?RSP,
+   ?RBP,
+   ?RSI,
+   ?RDI,
+   ?R8 ,
+   ?R9 ,
+   ?R10,
+   ?R11,
+   ?R12,
+   ?R13,
+   ?R14,
+   ?R15,
+   ?FCALLS,
+   ?HEAP_LIMIT].
+
+rax() -> ?RAX.
+rcx() -> ?RCX.
+temp0() -> ?TEMP0.
+temp1() -> ?TEMP1.
+sp() -> ?RSP.
+proc_pointer() -> ?PROC_POINTER.
+fcalls() -> ?FCALLS.
+heap_limit() -> ?HEAP_LIMIT.
+
+
+-ifdef(AMD64_HP_IN_REGISTER).
+-define(HEAP_POINTER, ?AMD64_HEAP_POINTER).
+heap_pointer() -> ?HEAP_POINTER.
+-define(LIST_HP_LIVE_AT_RETURN,[{?HEAP_POINTER,untagged}]).
+is_heap_pointer(?HEAP_POINTER) -> true;
+is_heap_pointer(_) -> false.
+%% -define(LIST_HP_FIXED,[?HEAP_POINTER]).
+
+-else.
+-define(HEAP_POINTER, -1).
+is_heap_pointer(_) -> false.
+%% -define(LIST_HP_FIXED,[]).
+-define(LIST_HP_LIVE_AT_RETURN,[]).
+-endif.
+
+proc_offset(?FCALLS) -> fcalls_offset();
+proc_offset(?HEAP_LIMIT) -> heap_limit_offset();
+proc_offset(_) -> false.
+
+sp_limit_offset() -> ?P_NSP_LIMIT.
+
+is_fixed(?RSP) -> true;
+is_fixed(?PROC_POINTER) -> true;
+is_fixed(?FCALLS) -> true;
+is_fixed(?HEAP_LIMIT) -> true;
+is_fixed(R) -> is_heap_pointer(R).
+
+%% fixed() ->
+%%     [?ESP, ?PROC_POINTER, ?FCALLS, ?HEAP_LIMIT | ?LIST_HP_FIXED].
+
+allocatable() ->
+  [?RDX, ?RCX, ?RBX, ?RAX, ?RSI, ?RDI,
+   ?R8 , ?R9 , ?R10, ?R11, ?R12, ?R13, ?R14, ?R15]
+    -- [?FCALLS, ?HEAP_POINTER, ?HEAP_LIMIT].
+
+allocatable_sse2() ->
+  [00,01,02,03,04,05,06,07,08,09,10,11,12,13,14,15]. %% xmm0 - xmm15
+
+allocatable_x87() ->
+  [0,1,2,3,4,5,6].
+
+nr_args() -> ?AMD64_NR_ARG_REGS.
+
+arg(N) ->
+  if N < ?AMD64_NR_ARG_REGS ->
+      case N of
+	0 -> ?ARG0;
+	1 -> ?ARG1;
+	2 -> ?ARG2;
+	3 -> ?ARG3;
+	4 -> ?ARG4;
+	5 -> ?ARG5;
+	_ -> exit({?MODULE, arg, N})
+      end;
+     true ->
+      exit({?MODULE, arg, N})
+  end.
+
+is_arg(R) ->
+  case R of
+    ?ARG0 -> ?AMD64_NR_ARG_REGS > 0;
+    ?ARG1 -> ?AMD64_NR_ARG_REGS > 1;
+    ?ARG2 -> ?AMD64_NR_ARG_REGS > 2;
+    ?ARG3 -> ?AMD64_NR_ARG_REGS > 3;
+    ?ARG4 -> ?AMD64_NR_ARG_REGS > 4;
+    ?ARG5 -> ?AMD64_NR_ARG_REGS > 5;
+    _ -> false
+  end.
+
+args(Arity) when is_integer(Arity), Arity >= 0 ->
+  N = erlang:min(Arity, ?AMD64_NR_ARG_REGS),
+  args(N-1, []).
+
+args(I, Rest) when I < 0 -> Rest;
+args(I, Rest) -> args(I-1, [arg(I) | Rest]).
+
+ret(N) ->
+  case N of
+    0 -> ?RAX;
+    _ -> exit({?MODULE, ret, N})
+  end.
+
+call_clobbered() ->
+  [{?RAX,tagged},{?RAX,untagged},	% does the RA strip the type or not?
+   {?RDX,tagged},{?RDX,untagged},
+   {?RCX,tagged},{?RCX,untagged},
+   {?RBX,tagged},{?RBX,untagged},
+   {?RDI,tagged},{?RDI,untagged},
+   {?RSI,tagged},{?RSI,untagged},
+   {?R8 ,tagged},{?R8 ,untagged},
+   {?R9 ,tagged},{?R9 ,untagged},
+   {?R10,tagged},{?R10,untagged},
+   {?R11,tagged},{?R11,untagged},
+   {?R12,tagged},{?R12,untagged},
+   {?R13,tagged},{?R13,untagged},
+   {?R14,tagged},{?R14,untagged},
+   {?R15,tagged},{?R15,untagged}
+   | fp_call_clobbered()]
+    --
+    [{?FCALLS,tagged},{?FCALLS,untagged},
+     {?HEAP_POINTER,tagged},{?HEAP_POINTER,untagged},
+     {?HEAP_LIMIT,tagged},{?HEAP_LIMIT,untagged}
+    ].
+
+fp_call_clobbered() -> %% sse2 since it has more registers than x87
+  [{Reg,double} || Reg <- allocatable_sse2()].
+
+tailcall_clobbered() ->		% tailcall crapola needs two temps
+  [{?TEMP0,tagged},{?TEMP0,untagged},
+   {?TEMP1,tagged},{?TEMP1,untagged}
+  | fp_call_clobbered()].
+
+live_at_return() ->
+    [{?RSP,untagged}
+     ,{?PROC_POINTER,untagged}
+     ,{?FCALLS,untagged}
+     ,{?HEAP_LIMIT,untagged}
+     | ?LIST_HP_LIVE_AT_RETURN
+    ].
+
+wordsize() -> 8.