1 files changed, 104 insertions, 85 deletions

diff --git a/lib/hipe/llvm/hipe_llvm_main.erl b/lib/hipe/llvm/hipe_llvm_main.erl
index 3c24425828..476d6fb49c 100644
--- a/lib/hipe/llvm/hipe_llvm_main.erl
+++ b/lib/hipe/llvm/hipe_llvm_main.erl
@@ -13,7 +13,7 @@
 %%      chain is invoked in order to produce an object file.
 rtl_to_native(MFA, RTL, Roots, Options) ->
   %% Compile to LLVM and get Instruction List (along with infos)
-  {LLVMCode, RelocsDict, ConstTab} =
+  {LLVMCode, RelocsDict0, ConstTab0} =
     hipe_rtl_to_llvm:translate(RTL, Roots),
   %% Fix function name to an acceptable LLVM identifier (needed for closures)
   {_Module, Fun, Arity} = hipe_rtl_to_llvm:fix_mfa_name(MFA),
@@ -24,34 +24,33 @@ rtl_to_native(MFA, RTL, Roots, Options) ->
   %% Extract information from object file
   %%
   ObjBin = open_object_file(ObjectFile),
-  %% Read and set the ELF class
-  elf_format:set_architecture_flag(ObjBin),
+  Obj = elf_format:read(ObjBin),
   %% Get labels info (for switches and jump tables)
-  Labels = elf_format:get_rodata_relocs(ObjBin),
-  {Switches, Closures} = get_tables(ObjBin),
+  Labels = elf_format:extract_rela(Obj, ?RODATA),
+  Tables = get_tables(Obj),
   %% Associate Labels with Switches and Closures with stack args
-  {SwitchInfos, ExposedClosures} =
-    correlate_labels(Switches ++ Closures, Labels),
+  {SwitchInfos, ExposedClosures} = correlate_labels(Tables, Labels),
   %% SwitchInfos:     [{"table_50", [Labels]}]
   %% ExposedClosures: [{"table_closures", [Labels]}]
-  
+
   %% Labelmap contains the offsets of the labels in the code that are
   %% used for switch's jump tables
-  LabelMap = create_labelmap(MFA, SwitchInfos, RelocsDict),
+  LabelMap = create_labelmap(MFA, SwitchInfos, RelocsDict0),
+  {RelocsDict, ConstTab} = extract_constants(RelocsDict0, ConstTab0, Obj),
   %% Get relocation info
-  TextRelocs = elf_format:get_text_relocs(ObjBin),
+  TextRelocs = elf_format:extract_rela(Obj, ?TEXT),
   %% AccRefs contains the offsets of all references to relocatable symbols in
   %% the code:
   AccRefs = fix_relocations(TextRelocs, RelocsDict, MFA),
   %% Get stack descriptors
-  SDescs = get_sdescs(ObjBin),
+  SDescs = get_sdescs(Obj),
   %% FixedSDescs are the stack descriptors after correcting calls that have
   %% arguments in the stack
   FixedSDescs =
     fix_stack_descriptors(RelocsDict, AccRefs, SDescs, ExposedClosures),
   Refs = AccRefs ++ FixedSDescs,
   %% Get binary code from object file
-  BinCode = elf_format:extract_text(ObjBin),
+  BinCode = elf_format:extract_text(Obj),
   %% Remove temp files (if needed)
   ok = remove_temp_folder(Dir, Options),
   %% Return the code together with information that will be used in the
@@ -78,7 +77,8 @@ compile_with_llvm(FunName, Arity, LLVMCode, Options, UseBuffer) ->
       false -> []
     end,
   {ok, File_llvm} = file:open(Dir ++ Filename ++ ".ll", OpenOpts),
-  hipe_llvm:pp_ins_list(File_llvm, LLVMCode),
+  Ver = hipe:get_llvm_version(), %% Should probably cache this
+  hipe_llvm:pp_ins_list(File_llvm, Ver, LLVMCode),
   %% delayed_write can cause file:close not to do a close, hence the two calls
   ok = file:close(File_llvm),
   __ = file:close(File_llvm),
@@ -158,12 +158,10 @@ trans_optlev_flag(Tool, Options) ->
 %%------------------------------------------------------------------------------
 
 %% @doc Get switch table and closure table.
+-spec get_tables(elf_format:elf()) -> [elf_sym()].
 get_tables(Elf) ->
-  %% Search Symbol Table for an entry with name prefixed with "table_":
-  Triples = elf_format:get_tab_entries(Elf),
-  Switches = [T || T={"table_" ++ _, _, _} <- Triples],
-  Closures = [T || T={"table_closures" ++ _, _, _} <- Switches],
-  {Switches, Closures}.
+  %% Search Symbol Table for entries where name is prefixed with "table_":
+  [S || S=#elf_sym{name="table_" ++ _} <- elf_format:elf_symbols(Elf)].
 
 %% @doc This function associates symbols who point to some table of labels with
 %%      the corresponding offsets of the labels in the code. These tables can
@@ -171,14 +169,12 @@ get_tables(Elf) ->
 %%      of blocks that contain closure calls with more than ?NR_ARG_REGS.
 correlate_labels([], _L) -> {[], []};
 correlate_labels(Tables, Labels) ->
-  %% Sort "Tables" based on "ValueOffsets"
-  OffsetSortedTb = lists:ukeysort(2, Tables),
-  %% Unzip offset-sorted list of "Switches"
-  {Names, _Offsets, TablesSizeList} = lists:unzip3(OffsetSortedTb),
-  %% Associate switch names with labels
-  L = split_list(Labels, TablesSizeList),
-  %% Zip back! (to [{SwitchName, Values}])
-  NamesValues = lists:zip(Names, L),
+  %% Assumes that the relocations are sorted
+  RelocTree = gb_trees:from_orddict(
+		[{Rel#elf_rel.offset, Rel#elf_rel.addend} || Rel <- Labels]),
+  %% Lookup all relocations pertaining to each symbol
+  NamesValues = [{Name, lookup_range(Value, Value+Size, RelocTree)}
+		 || #elf_sym{name=Name, value=Value, size=Size} <- Tables],
   case lists:keytake("table_closures", 1, NamesValues) of
     false ->  %% No closures in the code, no closure table
       {NamesValues, []};
@@ -186,6 +182,17 @@ correlate_labels(Tables, Labels) ->
       {SwitchesNV, ClosureTableNV}
   end.
 
+%% Fetches all values with a key in [Low, Hi)
+-spec lookup_range(_::K, _::K, gb_trees:tree(K,V)) -> [_::V].
+lookup_range(Low, Hi, Tree) ->
+  lookup_range_1(Hi, gb_trees:iterator_from(Low, Tree)).
+
+lookup_range_1(Hi, Iter0) ->
+  case gb_trees:next(Iter0) of
+    {Key, Value, Iter} when Key < Hi -> [Value | lookup_range_1(Hi, Iter)];
+    _ -> []
+  end.
+
 %% @doc Create a gb_tree which contains information about the labels that used
 %%      for switch's jump tables. The keys of the gb_tree are of the form
 %%      {MFA, Label} and the values are the actual Offsets.
@@ -213,40 +220,80 @@ insert_to_labelmap([{Key, Value}|Rest], LabelMap) ->
       insert_to_labelmap(Rest, LabelMap)
   end.
 
+%% Find any LLVM-generated constants and add them to the constant table
+extract_constants(RelocsDict0, ConstTab0, Obj) ->
+  TextRelocs = elf_format:extract_rela(Obj, ?TEXT),
+  AnonConstSections =
+    lists:usort([{Sec, Offset}
+		 || #elf_rel{symbol=#elf_sym{type=section, section=Sec},
+			     addend=Offset} <- TextRelocs]),
+  lists:foldl(
+    fun({#elf_shdr{name=Name, type=progbits, addralign=Align, entsize=EntSize,
+		   size=Size} = Section, Offset}, {RelocsDict1, ConstTab1})
+	when EntSize > 0, 0 =:= Size rem EntSize, 0 =:= Offset rem EntSize ->
+	SectionBin = elf_format:section_contents(Section, Obj),
+	Constant = binary:part(SectionBin, Offset, EntSize),
+	{ConstTab, ConstLbl} =
+	  hipe_consttab:insert_binary_const(ConstTab1, Align, Constant),
+	{dict:store({anon, Name, Offset}, {constant, ConstLbl}, RelocsDict1),
+	 ConstTab}
+    end, {RelocsDict0, ConstTab0}, AnonConstSections).
+
 %% @doc Correlate object file relocation symbols with info from translation to
 %%      llvm code.
 fix_relocations(Relocs, RelocsDict, MFA) ->
-  fix_relocs(Relocs, RelocsDict, MFA, []).
-
-fix_relocs([], _, _, RelocAcc) -> RelocAcc;
-fix_relocs([{Name, Offset}|Rs], RelocsDict, {ModName,_,_}=MFA,  RelocAcc) ->
+  lists:map(fun(Reloc) -> fix_reloc(Reloc, RelocsDict, MFA) end, Relocs).
+
+%% Relocation types and expected addends for x86 and amd64
+-define(PCREL_T, 'pc32').
+-define(PCREL_A, -4). %% Hard-coded in hipe_x86.c and hipe_amd64.c
+-ifdef(BIT32).
+-define(ABS_T, '32').
+-define(ABS_A, _). %% We support any addend
+-else.
+-define(ABS_T, '64').
+-define(ABS_A, 0).
+-endif.
+
+fix_reloc(#elf_rel{symbol=#elf_sym{name=Name, section=undefined, type=notype},
+		   offset=Offset, type=?PCREL_T, addend=?PCREL_A},
+	  RelocsDict, {ModName,_,_}) when Name =/= "" ->
   case dict:fetch(Name, RelocsDict) of
-    {atom, AtomName} ->
-      fix_relocs(Rs, RelocsDict, MFA,
-                 [{?LOAD_ATOM, Offset, AtomName}|RelocAcc]);
-    {constant, Label} ->
-      fix_relocs(Rs, RelocsDict, MFA,
-		 [{?LOAD_ADDRESS, Offset, {constant, Label}}|RelocAcc]);
-    {switch, _, JTabLab} -> %% Treat switch exactly as constant
-      fix_relocs(Rs, RelocsDict, MFA,
-                 [{?LOAD_ADDRESS, Offset, {constant, JTabLab}}|RelocAcc]);
-    {closure, _}=Closure ->
-      fix_relocs(Rs, RelocsDict, MFA,
-                 [{?LOAD_ADDRESS, Offset, Closure}|RelocAcc]);
-    {call, {bif, BifName, _}} ->
-      fix_relocs(Rs, RelocsDict, MFA,
-                 [{?CALL_LOCAL, Offset, BifName}|RelocAcc]);
+    {call, {bif, BifName, _}} -> {?CALL_LOCAL, Offset, BifName};
     %% MFA calls to functions in the same module are of type 3, while all
     %% other MFA calls are of type 2.
-    {call, {ModName,_F,_A}=CallMFA} ->
-      fix_relocs(Rs, RelocsDict, MFA,
-                 [{?CALL_LOCAL, Offset, CallMFA}|RelocAcc]);
-    {call, CallMFA} ->
-      fix_relocs(Rs, RelocsDict, MFA,
-                 [{?CALL_REMOTE, Offset, CallMFA}|RelocAcc]);
-    Other ->
-      exit({?MODULE, fix_relocs,
-           {"Relocation not in relocation dictionary", Other}})
+    %% XXX: Does this code break hot code loading (by transforming external
+    %% calls into local calls?)
+    {call, {ModName,_F,_A}=CallMFA} -> {?CALL_LOCAL,  Offset, CallMFA};
+    {call,                 CallMFA} -> {?CALL_REMOTE, Offset, CallMFA}
+  end;
+fix_reloc(#elf_rel{symbol=#elf_sym{name=Name, section=undefined, type=notype},
+		   offset=Offset, type=?ABS_T, addend=?ABS_A},
+	  RelocsDict, _) when Name =/= "" ->
+  case dict:fetch(Name, RelocsDict) of
+    {atom, AtomName}     -> {?LOAD_ATOM,    Offset, AtomName};
+    {constant, Label}    -> {?LOAD_ADDRESS, Offset, {constant, Label}};
+    {closure, _}=Closure -> {?LOAD_ADDRESS, Offset, Closure}
+  end;
+fix_reloc(#elf_rel{symbol=#elf_sym{name=Name, section=#elf_shdr{name=?TEXT},
+				   type=func},
+		   offset=Offset, type=?PCREL_T, addend=?PCREL_A},
+	  RelocsDict, MFA) when Name =/= "" ->
+  case dict:fetch(Name, RelocsDict) of
+    {call, MFA} -> {?CALL_LOCAL, Offset, MFA}
+  end;
+fix_reloc(#elf_rel{symbol=#elf_sym{name=Name, section=#elf_shdr{name=?RODATA},
+				   type=object},
+		   offset=Offset, type=?ABS_T, addend=?ABS_A},
+	  RelocsDict, _) when Name =/= "" ->
+  case dict:fetch(Name, RelocsDict) of
+    {switch, _, JTabLab} -> %% Treat switch exactly as constant
+      {?LOAD_ADDRESS, Offset, {constant, JTabLab}}
+  end;
+fix_reloc(#elf_rel{symbol=#elf_sym{type=section, section=#elf_shdr{name=Name}},
+		   offset=Offset, type=?ABS_T, addend=Addend}, RelocsDict, _) ->
+  case dict:fetch({anon, Name, Addend}, RelocsDict) of
+    {constant, Label} -> {?LOAD_ADDRESS, Offset, {constant, Label}}
   end.
 
 %%------------------------------------------------------------------------------
@@ -271,20 +318,14 @@ get_sdescs(Elf) ->
       T = SPCount * ?SP_ADDR_SIZE,
       %% Pattern match fields of ".note.gc":
       <<SPCount:(?bits(?SP_COUNT_SIZE))/integer-little, % Sanity check!
-        SPAddrs:T/binary, % NOTE: In 64bit they are relocs!
+	_SPAddrs:T/binary, % NOTE: In 64bit they are relocs!
         StkFrameSize:(?bits(?SP_STKFRAME_SIZE))/integer-little,
         StkArity:(?bits(?SP_STKARITY_SIZE))/integer-little,
         _LiveRootCount:(?bits(?SP_LIVEROOTCNT_SIZE))/integer-little, % Skip
         Roots/binary>> = NoteGC_bin,
       LiveRoots = get_liveroots(Roots, []),
-      %% Extract information about the safe point addresses:
-      SPOffs =
-        case elf_format:is64bit() of
-          true -> %% Find offsets in ".rela.note.gc":
-            elf_format:get_rela_addends(RelaNoteGC);
-          false -> %% Find offsets in SPAddrs (in ".note.gc"):
-            get_spoffs(SPAddrs, [])
-        end,
+      %% Extract the safe point offsets:
+      SPOffs = [A || #elf_rel{addend=A} <- RelaNoteGC],
       %% Extract Exception Handler labels:
       ExnHandlers = elf_format:get_exn_handlers(Elf),
       %% Combine ExnHandlers and Safe point addresses (return addresses):
@@ -300,13 +341,6 @@ get_liveroots(<<Root:?bits(?LR_STKINDEX_SIZE)/integer-little,
                 MoreRoots/binary>>, Acc) ->
   get_liveroots(MoreRoots, [Root | Acc]).
 
-%% @doc Extracts a bunch of integers (safepoint offsets) from a binary. Returns
-%%      a tuple as need for stack descriptors.
-get_spoffs(<<>>, Acc) ->
-  lists:reverse(Acc);
-get_spoffs(<<SPOff:?bits(?SP_ADDR_SIZE)/integer-little, More/binary>>, Acc) ->
-  get_spoffs(More, [SPOff | Acc]).
-
 combine_ras_and_exns(_, [], Acc) ->
   lists:reverse(Acc);
 combine_ras_and_exns(ExnHandlers, [RA | MoreRAs], Acc) ->
@@ -489,18 +523,3 @@ unique_folder(FunName, Arity, Options) ->
 dir_exists(Filename) ->
   {Flag, Info} = file:read_file_info(Filename),
   (Flag =:= ok) andalso (element(3, Info) =:= directory).
-
-%% @doc Function that takes as arguments a list of integers and a list with
-%%      numbers indicating how many items should each tuple have and splits
-%%      the original list to a list of lists of integers (with the specified
-%%      number of elements), i.e. [ [...], [...] ].
--spec split_list([integer()], [integer()]) -> [ [integer()] ].
-split_list(List, ElemsPerTuple) ->
-  split_list(List, ElemsPerTuple, []).
-
--spec split_list([integer()], [integer()], [ [integer()] ]) -> [ [integer()] ].
-split_list([], [], Acc) ->
-  lists:reverse(Acc);
-split_list(List, [NumOfElems | MoreNums], Acc) ->
-  {L1, L2} = lists:split(NumOfElems, List),
-  split_list(L2, MoreNums, [ L1 | Acc]).