Merge pull request #24 from aeternity/PT-164597852-move-aesophia-heap
PT-164597852 Move aesophia heap handling into aebytecode
This commit is contained in:
Robert Virding
GitHub
commit
2d599df0ea
3
.gitignore
vendored
3
.gitignore
vendored
@ -17,3 +17,6 @@ include/aeb_fate_opcodes.hrl
|
||||
src/aeb_fate_code.erl
|
||||
src/aeb_fate_opcodes.erl
|
||||
src/aeb_fate_pp.erl
|
||||
*.erl~
|
||||
*.hrl~
|
||||
*.aes~
|
||||
|
||||
15
include/aeb_heap.hrl
Normal file
15
include/aeb_heap.hrl
Normal file
@ -0,0 +1,15 @@
|
||||
|
||||
-record(pmap, {key_t :: aeb_aevm_data:type(),
|
||||
val_t :: aeb_aevm_data:type(),
|
||||
parent :: none | non_neg_integer(),
|
||||
size = 0 :: non_neg_integer(),
|
||||
data :: #{aeb_heap:binary_value() => aeb_heap:binary_value() | tombstone}
|
||||
| stored}).
|
||||
|
||||
-record(maps, { maps = #{} :: #{ non_neg_integer() => #pmap{} }
|
||||
, next_id = 0 :: non_neg_integer() }).
|
||||
|
||||
-record(heap, { maps :: #maps{},
|
||||
offset :: aeb_heap:offset(),
|
||||
heap :: binary() | #{non_neg_integer() => non_neg_integer()} }).
|
||||
|
||||
11
include/aeb_typerep_def.hrl
Normal file
11
include/aeb_typerep_def.hrl
Normal file
@ -0,0 +1,11 @@
|
||||
|
||||
-define(Type(), aeb_aevm_data:type()).
|
||||
|
||||
-define(TYPEREP_WORD_TAG, 0).
|
||||
-define(TYPEREP_STRING_TAG, 1).
|
||||
-define(TYPEREP_LIST_TAG, 2).
|
||||
-define(TYPEREP_TUPLE_TAG, 3).
|
||||
-define(TYPEREP_VARIANT_TAG, 4).
|
||||
-define(TYPEREP_TYPEREP_TAG, 5).
|
||||
-define(TYPEREP_MAP_TAG, 6).
|
||||
-define(TYPEREP_FUN_TAG, 7).
|
||||
@ -1,3 +1,5 @@
|
||||
%% -*- mode: erlang; indent-tabs-mode: nil -*-
|
||||
|
||||
{minimum_otp_vsn, "20.1"}.
|
||||
|
||||
{erl_opts, [debug_info]}.
|
||||
|
||||
150
src/aeb_abi.erl
Normal file
150
src/aeb_abi.erl
Normal file
@ -0,0 +1,150 @@
|
||||
%%%-------------------------------------------------------------------
|
||||
%%% @copyright (C) 2017, Aeternity Anstalt
|
||||
%%% @doc
|
||||
%%% Encode and decode data and function calls according to
|
||||
%%% Sophia-AEVM-ABI.
|
||||
%%% @end
|
||||
%%% Created : 25 Jan 2018
|
||||
%%%
|
||||
%%%-------------------------------------------------------------------
|
||||
-module(aeb_abi).
|
||||
-define(HASH_SIZE, 32).
|
||||
|
||||
-export([ create_calldata/4
|
||||
, check_calldata/2
|
||||
, function_type_info/3
|
||||
, function_type_hash/3
|
||||
, arg_typerep_from_function/2
|
||||
, type_hash_from_function_name/2
|
||||
, typereps_from_type_hash/2
|
||||
, function_name_from_type_hash/2
|
||||
, get_function_hash_from_calldata/1
|
||||
]).
|
||||
|
||||
-type hash() :: <<_:256>>. %% 256 = ?HASH_SIZE * 8.
|
||||
-type function_name() :: binary(). %% String
|
||||
-type typerep() :: aeb_aevm_data:type().
|
||||
-type function_type_info() :: { FunctionHash :: hash()
|
||||
, FunctionName :: function_name()
|
||||
, ArgType :: binary() %% binary typerep
|
||||
, OutType :: binary() %% binary typerep
|
||||
}.
|
||||
-type type_info() :: [function_type_info()].
|
||||
|
||||
%%%===================================================================
|
||||
%%% API
|
||||
%%%===================================================================
|
||||
|
||||
%%%===================================================================
|
||||
%%% Handle calldata
|
||||
|
||||
create_calldata(FunName, Args, ArgTypes0, RetType) ->
|
||||
ArgTypes = {tuple, ArgTypes0},
|
||||
<<TypeHashInt:?HASH_SIZE/unit:8>> =
|
||||
function_type_hash(list_to_binary(FunName), ArgTypes, RetType),
|
||||
Data = aeb_heap:to_binary({TypeHashInt, list_to_tuple(Args)}),
|
||||
{ok, Data, {tuple, [word, ArgTypes]}, RetType}.
|
||||
|
||||
-spec check_calldata(binary(), type_info()) ->
|
||||
{'ok', typerep(), typerep()} | {'error', atom()}.
|
||||
check_calldata(CallData, TypeInfo) ->
|
||||
%% The first element of the CallData should be the function name
|
||||
case get_function_hash_from_calldata(CallData) of
|
||||
{ok, Hash} ->
|
||||
case typereps_from_type_hash(Hash, TypeInfo) of
|
||||
{ok, ArgType, OutType} ->
|
||||
try aeb_heap:from_binary({tuple, [word, ArgType]}, CallData) of
|
||||
{ok, _Something} ->
|
||||
{ok, {tuple, [word, ArgType]}, OutType};
|
||||
{error, _} ->
|
||||
{error, bad_call_data}
|
||||
catch
|
||||
_T:_E ->
|
||||
{error, bad_call_data}
|
||||
end;
|
||||
{error, _} ->
|
||||
{error, unknown_function}
|
||||
end;
|
||||
{error, _What} ->
|
||||
{error, bad_call_data}
|
||||
end.
|
||||
|
||||
-spec get_function_hash_from_calldata(CallData::binary()) ->
|
||||
{ok, binary()} | {error, term()}.
|
||||
get_function_hash_from_calldata(CallData) ->
|
||||
case aeb_heap:from_binary({tuple, [word]}, CallData) of
|
||||
{ok, {HashInt}} -> {ok, <<HashInt:?HASH_SIZE/unit:8>>};
|
||||
{error, _} = Error -> Error
|
||||
end.
|
||||
|
||||
%%%===================================================================
|
||||
%%% Handle type info from contract meta data
|
||||
|
||||
-spec function_type_info(function_name(), [typerep()], typerep()) ->
|
||||
function_type_info().
|
||||
function_type_info(Name, ArgTypes, OutType) ->
|
||||
ArgType = {tuple, ArgTypes},
|
||||
{ function_type_hash(Name, ArgType, OutType)
|
||||
, Name
|
||||
, aeb_heap:to_binary(ArgType)
|
||||
, aeb_heap:to_binary(OutType)
|
||||
}.
|
||||
|
||||
-spec function_type_hash(function_name(), typerep(), typerep()) -> hash().
|
||||
function_type_hash(Name, ArgType, OutType) when is_binary(Name) ->
|
||||
Bin = iolist_to_binary([ Name
|
||||
, aeb_heap:to_binary(ArgType)
|
||||
, aeb_heap:to_binary(OutType)
|
||||
]),
|
||||
%% Calculate a 256 bit digest BLAKE2b hash value of a binary
|
||||
{ok, Hash} = eblake2:blake2b(?HASH_SIZE, Bin),
|
||||
Hash.
|
||||
|
||||
-spec arg_typerep_from_function(function_name(), type_info()) ->
|
||||
{'ok', typerep()} | {'error', 'bad_type_data' | 'unknown_function'}.
|
||||
arg_typerep_from_function(Function, TypeInfo) ->
|
||||
case lists:keyfind(Function, 2, TypeInfo) of
|
||||
{_TypeHash, Function, ArgTypeBin,_OutTypeBin} ->
|
||||
case aeb_heap:from_binary(typerep, ArgTypeBin) of
|
||||
{ok, ArgType} -> {ok, ArgType};
|
||||
{error,_} -> {error, bad_type_data}
|
||||
end;
|
||||
false ->
|
||||
{error, unknown_function}
|
||||
end.
|
||||
|
||||
-spec typereps_from_type_hash(hash(), type_info()) ->
|
||||
{'ok', typerep(), typerep()} | {'error', 'bad_type_data' | 'unknown_function'}.
|
||||
typereps_from_type_hash(TypeHash, TypeInfo) ->
|
||||
case lists:keyfind(TypeHash, 1, TypeInfo) of
|
||||
{TypeHash,_Function, ArgTypeBin, OutTypeBin} ->
|
||||
case {aeb_heap:from_binary(typerep, ArgTypeBin),
|
||||
aeb_heap:from_binary(typerep, OutTypeBin)} of
|
||||
{{ok, ArgType}, {ok, OutType}} -> {ok, ArgType, OutType};
|
||||
{_, _} -> {error, bad_type_data}
|
||||
end;
|
||||
false ->
|
||||
{error, unknown_function}
|
||||
end.
|
||||
|
||||
-spec function_name_from_type_hash(hash(), type_info()) ->
|
||||
{'ok', function_name()}
|
||||
| {'error', 'unknown_function'}.
|
||||
function_name_from_type_hash(TypeHash, TypeInfo) ->
|
||||
case lists:keyfind(TypeHash, 1, TypeInfo) of
|
||||
{TypeHash, Function,_ArgTypeBin,_OutTypeBin} ->
|
||||
{ok, Function};
|
||||
false ->
|
||||
{error, unknown_function}
|
||||
end.
|
||||
|
||||
-spec type_hash_from_function_name(function_name(), type_info()) ->
|
||||
{'ok', hash()}
|
||||
| {'error', 'unknown_function'}.
|
||||
type_hash_from_function_name(Name, TypeInfo) ->
|
||||
case lists:keyfind(Name, 2, TypeInfo) of
|
||||
{TypeHash, Name,_ArgTypeBin,_OutTypeBin} ->
|
||||
{ok, TypeHash};
|
||||
false ->
|
||||
{error, unknown_function}
|
||||
end.
|
||||
30
src/aeb_aevm_data.erl
Normal file
30
src/aeb_aevm_data.erl
Normal file
@ -0,0 +1,30 @@
|
||||
-module(aeb_aevm_data).
|
||||
|
||||
-export_type([data/0,
|
||||
type/0,
|
||||
heap/0]).
|
||||
|
||||
-type type() :: word | signed_word | string | typerep | function
|
||||
| {list, type()}
|
||||
| {option, type()}
|
||||
| {tuple, [type()]}
|
||||
| {variant, [[type()]]}.
|
||||
|
||||
|
||||
-type data() :: none
|
||||
| {some, data()}
|
||||
| {option, data()}
|
||||
| word
|
||||
| string
|
||||
| {list, data()}
|
||||
| {tuple, [data()]}
|
||||
| {variant, integer(), [data()]}
|
||||
| integer()
|
||||
| binary()
|
||||
| [data()]
|
||||
| {}
|
||||
| {data()}
|
||||
| {data(), data()}.
|
||||
|
||||
-type heap() :: binary().
|
||||
|
||||
301
src/aeb_heap.erl
Normal file
301
src/aeb_heap.erl
Normal file
@ -0,0 +1,301 @@
|
||||
-module(aeb_heap).
|
||||
|
||||
-export([ to_binary/1
|
||||
, to_binary/2
|
||||
, from_heap/3
|
||||
, from_binary/2
|
||||
, from_binary/3
|
||||
, maps_with_next_id/1
|
||||
, set_next_id/2
|
||||
, heap_fragment/3
|
||||
, heap_value/3
|
||||
, heap_value/4
|
||||
, heap_value_pointer/1
|
||||
, heap_value_maps/1
|
||||
, heap_value_offset/1
|
||||
, heap_value_heap/1
|
||||
, heap_fragment_maps/1
|
||||
, heap_fragment_offset/1
|
||||
, heap_fragment_heap/1
|
||||
]).
|
||||
|
||||
-export_type([binary_value/0, heap_value/0, offset/0, heap_fragment/0]).
|
||||
|
||||
-include_lib("aebytecode/include/aeb_typerep_def.hrl").
|
||||
-include_lib("aebytecode/include/aeb_heap.hrl").
|
||||
|
||||
-type word() :: non_neg_integer().
|
||||
-type pointer() :: word().
|
||||
-opaque heap_fragment() :: #heap{}.
|
||||
-type offset() :: non_neg_integer().
|
||||
-type binary_value() :: binary().
|
||||
-type heap_value() :: {pointer(), heap_fragment()}.
|
||||
|
||||
|
||||
-spec maps_with_next_id(heap_fragment()) -> #maps{}.
|
||||
%% Create just a maps value, don't keep rest of Heap
|
||||
maps_with_next_id(#heap{maps = #maps{next_id = N}}) ->
|
||||
#maps{ next_id = N }.
|
||||
|
||||
-spec set_next_id(heap_fragment(), non_neg_integer()) -> heap_fragment().
|
||||
set_next_id(Heap, N) ->
|
||||
Heap#heap{ maps = Heap#heap.maps#maps{ next_id = N } }.
|
||||
|
||||
%% -- data type heap_fragment
|
||||
|
||||
-spec heap_fragment(binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_fragment().
|
||||
heap_fragment(Heap) ->
|
||||
heap_fragment(#maps{ next_id = 0 }, 0, Heap).
|
||||
|
||||
-spec heap_fragment(#maps{}, offset(),
|
||||
binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_fragment().
|
||||
heap_fragment(Maps, Offset, Heap) ->
|
||||
#heap{maps = Maps, offset = Offset, heap = Heap}.
|
||||
|
||||
-spec heap_fragment_maps(heap_fragment()) -> #maps{}.
|
||||
heap_fragment_maps(#heap{maps = Maps}) ->
|
||||
Maps.
|
||||
|
||||
-spec heap_fragment_offset(heap_fragment()) -> offset().
|
||||
heap_fragment_offset(#heap{offset = Offs}) ->
|
||||
Offs.
|
||||
|
||||
-spec heap_fragment_heap(heap_fragment()) -> binary() | #{non_neg_integer() => non_neg_integer()}.
|
||||
heap_fragment_heap(#heap{heap = Heap}) ->
|
||||
Heap.
|
||||
|
||||
|
||||
%% -- data type heap_value
|
||||
|
||||
-spec heap_value(#maps{}, pointer(),
|
||||
binary() | #{non_neg_integer() => non_neg_integer()}) -> heap_value().
|
||||
heap_value(Maps, Ptr, Heap) ->
|
||||
heap_value(Maps, Ptr, Heap, 0).
|
||||
|
||||
-spec heap_value(#maps{}, pointer(),
|
||||
binary() | #{non_neg_integer() => non_neg_integer()}, offset()) -> heap_value().
|
||||
heap_value(Maps, Ptr, Heap, Offs) ->
|
||||
{Ptr, heap_fragment(Maps, Offs, Heap)}.
|
||||
|
||||
-spec heap_value_pointer(heap_value()) -> pointer().
|
||||
heap_value_pointer({Ptr, _}) -> Ptr.
|
||||
|
||||
-spec heap_value_maps(heap_value()) -> #maps{}.
|
||||
heap_value_maps({_, Heap}) -> Heap#heap.maps.
|
||||
|
||||
-spec heap_value_offset(heap_value()) -> offset().
|
||||
heap_value_offset({_, Heap}) -> Heap#heap.offset.
|
||||
|
||||
-spec heap_value_heap(heap_value()) ->
|
||||
binary() | #{non_neg_integer() => non_neg_integer()}.
|
||||
heap_value_heap({_, Heap}) -> Heap#heap.heap.
|
||||
|
||||
%% -- Value to binary --------------------------------------------------------
|
||||
|
||||
-spec to_binary(aeb_aevm_data:data()) -> aeb_aevm_data:heap().
|
||||
%% Encode the data as a heap where the first word is the value (for unboxed
|
||||
%% types) or a pointer to the value (for boxed types).
|
||||
to_binary(Data) ->
|
||||
to_binary(Data, 0).
|
||||
|
||||
to_binary(Data, BaseAddress) ->
|
||||
{Address, Memory} = to_binary1(Data, BaseAddress + 32),
|
||||
R = <<Address:256, Memory/binary>>,
|
||||
R.
|
||||
|
||||
|
||||
%% Allocate the data in memory, from the given address. Return a pair
|
||||
%% of memory contents from that address and the value representing the
|
||||
%% data.
|
||||
to_binary1(Data,_Address) when is_integer(Data) ->
|
||||
{Data,<<>>};
|
||||
to_binary1(Data, Address) when is_binary(Data) ->
|
||||
%% a string
|
||||
Words = aeb_memory:binary_to_words(Data),
|
||||
{Address,<<(size(Data)):256, << <<W:256>> || W <- Words>>/binary>>};
|
||||
to_binary1(none, Address) -> to_binary1({variant, 0, []}, Address);
|
||||
to_binary1({some, Value}, Address) -> to_binary1({variant, 1, [Value]}, Address);
|
||||
to_binary1(word, Address) -> to_binary1({?TYPEREP_WORD_TAG}, Address);
|
||||
to_binary1(string, Address) -> to_binary1({?TYPEREP_STRING_TAG}, Address);
|
||||
to_binary1(typerep, Address) -> to_binary1({?TYPEREP_TYPEREP_TAG}, Address);
|
||||
to_binary1(function, Address) -> to_binary1({?TYPEREP_FUN_TAG}, Address);
|
||||
to_binary1({list, T}, Address) -> to_binary1({?TYPEREP_LIST_TAG, T}, Address);
|
||||
to_binary1({option, T}, Address) -> to_binary1({variant, [[], [T]]}, Address);
|
||||
to_binary1({tuple, Ts}, Address) -> to_binary1({?TYPEREP_TUPLE_TAG, Ts}, Address);
|
||||
to_binary1({variant, Cons}, Address) -> to_binary1({?TYPEREP_VARIANT_TAG, Cons}, Address);
|
||||
to_binary1({map, K, V}, Address) -> to_binary1({?TYPEREP_MAP_TAG, K, V}, Address);
|
||||
to_binary1({variant, Tag, Args}, Address) ->
|
||||
to_binary1(list_to_tuple([Tag | Args]), Address);
|
||||
to_binary1(Map, Address) when is_map(Map) ->
|
||||
Size = maps:size(Map),
|
||||
%% Sort according to binary ordering
|
||||
KVs = lists:sort([ {to_binary(K), to_binary(V)} || {K, V} <- maps:to_list(Map) ]),
|
||||
{Address, <<Size:256, << <<(byte_size(K)):256, K/binary,
|
||||
(byte_size(V)):256, V/binary>> || {K, V} <- KVs >>/binary >>};
|
||||
to_binary1({}, _Address) ->
|
||||
{0, <<>>};
|
||||
to_binary1(Data, Address) when is_tuple(Data) ->
|
||||
{Elems,Memory} = to_binaries(tuple_to_list(Data),Address+32*size(Data)),
|
||||
ElemsBin = << <<W:256>> || W <- Elems>>,
|
||||
{Address,<< ElemsBin/binary, Memory/binary >>};
|
||||
to_binary1([],_Address) ->
|
||||
<<Nil:256>> = <<(-1):256>>,
|
||||
{Nil,<<>>};
|
||||
to_binary1([H|T],Address) ->
|
||||
to_binary1({H,T},Address).
|
||||
|
||||
|
||||
to_binaries([],_Address) ->
|
||||
{[],<<>>};
|
||||
to_binaries([H|T],Address) ->
|
||||
{HRep,HMem} = to_binary1(H,Address),
|
||||
{TRep,TMem} = to_binaries(T,Address+size(HMem)),
|
||||
{[HRep|TRep],<<HMem/binary, TMem/binary>>}.
|
||||
|
||||
%% Interpret a return value (a binary) using a type rep.
|
||||
|
||||
-spec from_heap(Type :: ?Type(), Heap :: binary(), Ptr :: integer()) ->
|
||||
{ok, term()} | {error, term()}.
|
||||
from_heap(Type, Heap, Ptr) ->
|
||||
try {ok, from_binary(#{}, Type, Heap, Ptr)}
|
||||
catch _:Err ->
|
||||
%% io:format("** Error: from_heap failed with ~p\n ~p\n", [Err, erlang:get_stacktrace()]),
|
||||
{error, Err}
|
||||
end.
|
||||
|
||||
%% Base address is the address of the first word of the given heap.
|
||||
-spec from_binary(T :: ?Type(),
|
||||
Heap :: binary(),
|
||||
BaseAddr :: non_neg_integer()) ->
|
||||
{ok, term()} | {error, term()}.
|
||||
from_binary(T, Heap = <<V:256, _/binary>>, BaseAddr) ->
|
||||
from_heap(T, <<0:BaseAddr/unit:8, Heap/binary>>, V);
|
||||
from_binary(_, Bin, _BaseAddr) ->
|
||||
{error, {binary_too_short, Bin}}.
|
||||
|
||||
-spec from_binary(?Type(), binary()) -> {ok, term()} | {error, term()}.
|
||||
from_binary(T, Heap) ->
|
||||
from_binary(T, Heap, 0).
|
||||
|
||||
from_binary(_, word, _, V) ->
|
||||
V;
|
||||
from_binary(_, signed_word, _, V) ->
|
||||
<<N:256/signed>> = <<V:256>>,
|
||||
N;
|
||||
from_binary(_, bool, _, V) ->
|
||||
case V of
|
||||
0 -> false;
|
||||
1 -> true
|
||||
end;
|
||||
from_binary(_, string, Heap, V) ->
|
||||
StringSize = heap_word(Heap,V),
|
||||
BitAddr = 8*(V+32),
|
||||
<<_:BitAddr,Bytes:StringSize/binary,_/binary>> = Heap,
|
||||
Bytes;
|
||||
from_binary(_, {tuple, []}, _, _) ->
|
||||
{};
|
||||
from_binary(Visited, {tuple,Cpts}, Heap, V) ->
|
||||
check_circular_refs(Visited, V),
|
||||
NewVisited = Visited#{V => true},
|
||||
ElementNums = lists:seq(0, length(Cpts)-1),
|
||||
TypesAndPointers = lists:zip(Cpts, ElementNums),
|
||||
ElementAddress = fun(Index) -> V + 32 * Index end,
|
||||
Element = fun(Index) ->
|
||||
heap_word(Heap, ElementAddress(Index))
|
||||
end,
|
||||
Convert = fun(Type, Index) ->
|
||||
from_binary(NewVisited, Type, Heap, Element(Index))
|
||||
end,
|
||||
Elements = [Convert(T, I) || {T,I} <- TypesAndPointers],
|
||||
list_to_tuple(Elements);
|
||||
from_binary(Visited, {list, Elem}, Heap, V) ->
|
||||
<<Nil:256>> = <<(-1):256>>,
|
||||
if V==Nil ->
|
||||
[];
|
||||
true ->
|
||||
{H,T} = from_binary(Visited, {tuple,[Elem,{list,Elem}]},Heap,V),
|
||||
[H|T]
|
||||
end;
|
||||
from_binary(Visited, {option, A}, Heap, V) ->
|
||||
from_binary(Visited, {variant_t, [{none, []}, {some, [A]}]}, Heap, V);
|
||||
from_binary(Visited, {variant, Cons}, Heap, V) ->
|
||||
Tag = heap_word(Heap, V),
|
||||
Args = lists:nth(Tag + 1, Cons),
|
||||
Visited1 = Visited#{V => true},
|
||||
{variant, Tag, tuple_to_list(from_binary(Visited1, {tuple, Args}, Heap, V + 32))};
|
||||
from_binary(Visited, {variant_t, TCons}, Heap, V) -> %% Tagged variants
|
||||
{Tags, Cons} = lists:unzip(TCons),
|
||||
{variant, I, Args} = from_binary(Visited, {variant, Cons}, Heap, V),
|
||||
Tag = lists:nth(I + 1, Tags),
|
||||
case Args of
|
||||
[] -> Tag;
|
||||
_ -> list_to_tuple([Tag | Args])
|
||||
end;
|
||||
from_binary(_Visited, {map, A, B}, Heap, Ptr) ->
|
||||
%% FORMAT: [Size] [KeySize] Key [ValSize] Val .. [KeySize] Key [ValSize] Val
|
||||
Size = heap_word(Heap, Ptr),
|
||||
map_binary_to_value(A, B, Size, Heap, Ptr + 32);
|
||||
from_binary(Visited, typerep, Heap, V) ->
|
||||
check_circular_refs(Visited, V),
|
||||
Tag = heap_word(Heap, V),
|
||||
Arg1 = fun(T, I) -> from_binary(Visited#{V => true}, T, Heap, heap_word(Heap, V + 32 * I)) end,
|
||||
Arg = fun(T) -> Arg1(T, 1) end,
|
||||
case Tag of
|
||||
?TYPEREP_WORD_TAG -> word;
|
||||
?TYPEREP_STRING_TAG -> string;
|
||||
?TYPEREP_TYPEREP_TAG -> typerep;
|
||||
?TYPEREP_LIST_TAG -> {list, Arg(typerep)};
|
||||
?TYPEREP_TUPLE_TAG -> {tuple, Arg({list, typerep})};
|
||||
?TYPEREP_VARIANT_TAG -> {variant, Arg({list, {list, typerep}})};
|
||||
?TYPEREP_MAP_TAG -> {map, Arg(typerep), Arg1(typerep, 2)};
|
||||
?TYPEREP_FUN_TAG -> function
|
||||
end.
|
||||
|
||||
map_binary_to_value(KeyType, ValType, N, Bin, Ptr) ->
|
||||
%% Avoid looping on bogus sizes
|
||||
MaxN = byte_size(Bin) div 64,
|
||||
Heap = heap_fragment(Bin),
|
||||
map_from_binary({value, KeyType, ValType}, min(N, MaxN), Heap, Ptr, #{}).
|
||||
|
||||
map_from_binary(_, 0, _, _, Map) -> Map;
|
||||
map_from_binary({value, KeyType, ValType} = Output, I, Heap, Ptr, Map) ->
|
||||
KeySize = get_word(Heap, Ptr),
|
||||
KeyPtr = Ptr + 32,
|
||||
KeyBin = get_chunk(Heap, KeyPtr, KeySize),
|
||||
ValSize = get_word(Heap, KeyPtr + KeySize),
|
||||
ValPtr = KeyPtr + KeySize + 32,
|
||||
ValBin = get_chunk(Heap, ValPtr, ValSize),
|
||||
%% Keys and values are self contained binaries
|
||||
{ok, Key} = from_binary(KeyType, KeyBin),
|
||||
{ok, Val} = from_binary(ValType, ValBin),
|
||||
map_from_binary(Output, I - 1, Heap, ValPtr + ValSize, Map#{Key => Val}).
|
||||
|
||||
check_circular_refs(Visited, V) ->
|
||||
case maps:is_key(V, Visited) of
|
||||
true -> exit(circular_references);
|
||||
false -> ok
|
||||
end.
|
||||
|
||||
heap_word(Heap, Addr) when is_binary(Heap) ->
|
||||
BitSize = 8*Addr,
|
||||
<<_:BitSize,W:256,_/binary>> = Heap,
|
||||
W;
|
||||
heap_word(Heap, Addr) when is_map(Heap) ->
|
||||
0 = Addr rem 32, %% Check that it's word aligned.
|
||||
maps:get(Addr, Heap, 0).
|
||||
|
||||
get_word(#heap{offset = Offs, heap = Mem}, Addr) when Addr >= Offs ->
|
||||
get_word(Mem, Addr - Offs);
|
||||
get_word(Mem, Addr) when is_binary(Mem) ->
|
||||
<<_:Addr/unit:8, Word:256, _/binary>> = Mem,
|
||||
Word.
|
||||
|
||||
get_chunk(#heap{offset = Offs, heap = Mem}, Addr, Bytes) when Addr >= Offs ->
|
||||
get_chunk(Mem, Addr - Offs, Bytes);
|
||||
get_chunk(Mem, Addr, Bytes) when is_binary(Mem) ->
|
||||
<<_:Addr/unit:8, Chunk:Bytes/binary, _/binary>> = Mem,
|
||||
Chunk.
|
||||
|
||||
|
||||
|
||||
|
||||
19
src/aeb_memory.erl
Normal file
19
src/aeb_memory.erl
Normal file
@ -0,0 +1,19 @@
|
||||
%%%-------------------------------------------------------------------
|
||||
%%% @copyright (C) 2018, Aeternity Anstalt
|
||||
%%% @doc
|
||||
%%% Memory speifics that compiler and VM need to agree upon
|
||||
%%% @end
|
||||
%%% Created : 19 Dec 2018
|
||||
%%%-------------------------------------------------------------------
|
||||
|
||||
-module(aeb_memory).
|
||||
|
||||
-export([binary_to_words/1]).
|
||||
|
||||
binary_to_words(<<>>) ->
|
||||
[];
|
||||
binary_to_words(<<N:256,Bin/binary>>) ->
|
||||
[N|binary_to_words(Bin)];
|
||||
binary_to_words(Bin) ->
|
||||
binary_to_words(<<Bin/binary,0>>).
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user