Prolog "hack"
/**
* Warranty & Liability
* To the extent permitted by applicable law and unless explicitly
* otherwise agreed upon, XLOG Technologies AG makes no warranties
* regarding the provided information. XLOG Technologies AG assumes
* no liability that any problems might be solved with the information
* provided by XLOG Technologies AG.
*
* Rights & License
* All industrial property rights regarding the information - copyright
* and patent rights in particular - are the sole property of XLOG
* Technologies AG. If the company was not the originator of some
* excerpts, XLOG Technologies AG has at least obtained the right to
* reproduce, change and translate the information.
*
* Reproduction is restricted to the whole unaltered document. Reproduction
* of the information is only allowed for non-commercial uses. Selling,
* giving away or letting of the execution of the library is prohibited.
* The library can be distributed as part of your applications and libraries
* for execution provided this comment remains unchanged.
*
* Restrictions
* Only to be distributed with programs that add significant and primary
* functionality to the library. Not to be distributed with additional
* software intended to replace any components of the library.
*
* Trademarks
* Jekejeke is a registered trademark of XLOG Technologies AG.
*/
:- ensure_loaded(library(misc/brainfog)).
:- ensure_loaded(library(misc/intercom)).
/***************************************************************/
/* Emulator */
/***************************************************************/
/**
* emulate(G):
* emulate(G, O):
* The predicate succeeds. As a side effect it emulates G
* on an abstract π-WAM. The binary predicate allows
* specifying hack options O.
*/
% emulate(+Goal)
emulate(GOAL) :-
emulate(GOAL, []).
% emulate(+Goal, +List)
emulate(GOAL, OPTS) :-
sys_hack_opts(OPTS, v(1,[],[]), v(NUM,_,_)),
sys_trans_body(GOAL, nothing, MARK, 1, CONT, []),
(sys_comp_comp(MARK, CONT, NUM, CODE, OFFSETS, CHANS, STATE),
sys_hack_init(OFFSETS, 0, STATE, STATE2),
sys_hack_run(OFFSETS, CODE, CHANS, STATE2);
true).
% sys_hack_init(+List, +Integer, +List, -List)
sys_hack_init([], _, STATE, STATE).
sys_hack_init([OFFSET|MORE], ID, STATE, STATE3) :-
IDX is OFFSET-3,
nth0(IDX, STATE, _, TEMP),
nth0(IDX, STATE2, ID, TEMP),
ID2 is ID+1,
sys_hack_init(MORE, ID2, STATE2, STATE3).
% sys_hack_run(+List, +List, +List, +List)
sys_hack_run([], _, _, _) :- !, fail.
sys_hack_run(OFFSETS, CODE, CHANS, STATE) :-
sys_hack_robin(OFFSETS, CODE, CHANS, STATE, OFFSETS2, STATE2),
sys_hack_run(OFFSETS2, CODE, CHANS, STATE2).
% sys_hack_robin(+List, +List, +List, +List, -List)
sys_hack_robin([OFFSET|MORE], CODE, CHANS, STATE, [OFFSET|REST], STATE3) :-
sys_hack_step(CODE, OFFSET, CHANS, STATE, STATE2), !,
sys_hack_robin(MORE, CODE, CHANS, STATE2, REST, STATE3).
sys_hack_robin([_|MORE], CODE, CHANS, STATE, REST, STATE2) :-
sys_hack_robin(MORE, CODE, CHANS, STATE, REST, STATE2).
sys_hack_robin([], _, _, STATE, [], STATE).
% sys_hack_step(+List, +Integer, +List, +List, -List)
sys_hack_step(CODE, OFFSET, CHANS, STATE, STATE5) :-
IDX is OFFSET-2,
nth0(IDX, STATE, PC),
IDX2 is OFFSET-1,
nth0(IDX2, STATE, ACCU),
nth0(PC, CODE, (MODE, FUN, OBJ)),
sys_hack_get(MODE, OBJ, CHANS, OFFSET, CODE, STATE, PC, STATE2, VALUE),
sys_hack_set(MODE, OBJ, ACCU, OFFSET, STATE2, PC, STATE3, PC2),
sys_hack_fun(FUN, ACCU, VALUE, ACCU2),
nth0(IDX, STATE3, _, TEMP),
nth0(IDX, STATE4, PC2, TEMP),
nth0(IDX2, STATE4, _, TEMP2),
nth0(IDX2, STATE5, ACCU2, TEMP2).
/***************************************************************/
/* Instructions */
/***************************************************************/
% sys_hack_get(+Atom, +Integer, +List, +Integer, +List, +List, +Integer, -List, -Integer)
sys_hack_get(cst, VALUE, _, _, _, STATE, _, STATE, VALUE).
sys_hack_get(get, OBJ, _, OFFSET, _, STATE, _, STATE, VALUE) :-
IDX is OFFSET+OBJ,
nth0(IDX, STATE, VALUE).
sys_hack_get(ext, _, _, _, CODE, STATE, PC, STATE, VALUE) :-
IDX is PC+1,
nth0(IDX, CODE, VALUE).
sys_hack_get(out, OBJ, CHANS, OFFSET, _, STATE, _, STATE, VALUE) :-
nth0(OFFSET, STATE, MAX),
AT is OFFSET+1,
(sys_extra_output(OBJ, CHANS, MAX, STATE, AT) ->
VALUE = 1; VALUE = 0).
sys_hack_get(in, OBJ, CHANS, OFFSET, _, STATE, _, STATE2, VALUE) :-
nth0(OFFSET, STATE, MAX),
AT is OFFSET+1,
(sys_extra_input(OBJ, CHANS, MAX, STATE, AT, STATE2) ->
VALUE = 1; STATE2 = STATE, VALUE = 0).
sys_hack_get(set, _, _, _, _, STATE, _, STATE, 0).
sys_hack_get(bra, _, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+1.
sys_hack_get(brz, _, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+1.
sys_hack_get(jma, _, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+1.
sys_hack_get(jmz, _, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+1.
% sys_hack_set(+Atom, +Integer, +Integer, +Integer, +List, +Integer, -List, -Integer)
sys_hack_set(cst, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+1.
sys_hack_set(get, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+1.
sys_hack_set(ext, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+2.
sys_hack_set(out, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+1.
sys_hack_set(in, _, _, _, STATE, PC, STATE, PC2) :-
PC2 is PC+1.
sys_hack_set(set, OBJ, ACCU, OFFSET, STATE, PC, STATE2, PC2) :-
IDX is OFFSET+OBJ,
nth0(IDX, STATE, _, TEMP),
nth0(IDX, STATE2, ACCU, TEMP),
PC2 is PC+1.
sys_hack_set(bra, PC2, _, _, STATE, _, STATE, PC2).
sys_hack_set(brz, OBJ, ACCU, _, STATE, PC, STATE, PC2) :-
(ACCU =:= 0 ->
PC2 = OBJ; PC2 is PC+1).
sys_hack_set(jma, OBJ, _, OFFSET, STATE, _, STATE, PC2) :-
IDX is OFFSET+OBJ,
nth0(IDX, STATE, PC2).
sys_hack_set(jmz, OBJ, ACCU, OFFSET, STATE, PC, STATE, PC2) :-
(ACCU =:= 0 ->
IDX is OFFSET+OBJ,
nth0(IDX, STATE, PC2); PC2 is PC+1).
% sys_hack_fun(+Atom, +Integer, +Integer, -Integer)
sys_hack_fun(mov, _, VALUE, VALUE).
sys_hack_fun(neg, _, VALUE, VALUE2) :-
TEMP is -VALUE,
sys_int32(TEMP, VALUE2).
sys_hack_fun(add, ACCU, VALUE, VALUE2) :-
TEMP is ACCU+VALUE,
sys_int32(TEMP, VALUE2).
sys_hack_fun(sub, ACCU, VALUE, VALUE2) :-
TEMP is ACCU-VALUE,
sys_int32(TEMP, VALUE2).
sys_hack_fun(mul, ACCU, VALUE, VALUE2) :-
TEMP is ACCU*VALUE,
sys_int32(TEMP, VALUE2).
sys_hack_fun(zdiv, ACCU, VALUE, VALUE2) :-
TEMP is ACCU//VALUE,
sys_int32(TEMP, VALUE2).
sys_hack_fun(rem, ACCU, VALUE, VALUE2) :-
TEMP is ACCU rem VALUE,
sys_int32(TEMP, VALUE2).
sys_hack_fun(min, ACCU, VALUE, VALUE2) :-
VALUE2 is min(ACCU,VALUE).
sys_hack_fun(max, ACCU, VALUE, VALUE2) :-
VALUE2 is max(ACCU,VALUE).
sys_hack_fun(eq, ACCU, VALUE, VALUE2) :-
(ACCU =:= VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(nq, ACCU, VALUE, VALUE2) :-
(ACCU =\= VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(ls, ACCU, VALUE, VALUE2) :-
(ACCU < VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(gr, ACCU, VALUE, VALUE2) :-
(ACCU > VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(lq, ACCU, VALUE, VALUE2) :-
(ACCU =< VALUE -> VALUE2 = 1; VALUE2 = 0).
sys_hack_fun(gq, ACCU, VALUE, VALUE2) :-
(ACCU >= VALUE -> VALUE2 = 1; VALUE2 = 0).
% sys_int32(+Integer, -Integer)
sys_int32(ALPHA, RESULT) :-
MASKED is ALPHA /\ 0xFFFFFFFF,
(MASKED >= 0x80000000 ->
RESULT is MASKED - 0x100000000;
RESULT = MASKED).
/***************************************************************/
/* Hack Output/Input */
/***************************************************************/
% sys_extra_output(+Integer, +List, +Integer, +List, +Integer)
sys_extra_output(OBJ, CHANS, MAX, STATE, AT) :-
nth0(OBJ, CHANS, CHAN),
sys_load_ints(LIST, MAX, STATE, AT),
cpu_buf_new(LIST, BUF),
cpu_xbar_offer(CHAN, BUF).
% sys_extra_input(+Integer, +List, +Integer, +List, +Integer, -List)
sys_extra_input(OBJ, CHANS, MAX, STATE, AT, STATE2) :-
nth0(OBJ, CHANS, CHAN),
os_obj_new(MAP),
os_obj_set(MAP, 'len', MAX),
cpu_xbar_poll(CHAN, MAP),
os_obj_current(MAP, 'len', LEN),
(LEN = MAX ->
os_obj_current(MAP, 'data', BUF),
cpu_buf_current(BUF, LIST),
sys_store_ints(LIST, STATE, AT, STATE2);
sys_store_miss(LEN, STATE, AT, STATE2)).
/***************************************************************/
/* Hack Load/Store */
/***************************************************************/
% sys_load_ints(-List, +Integer, +List, +Integer)
sys_load_ints([VALUE|LIST], MAX, STATE, AT) :- MAX > 0, !,
nth0(AT, STATE, VALUE),
AT2 is AT+1, MAX2 is MAX-1,
sys_load_ints(LIST, MAX2, STATE, AT2).
sys_load_ints([], _, _, _).
% sys_store_ints(+List, +List, +Integer, -List)
sys_store_ints([VALUE|LIST], STATE, AT, STATE2) :-
nth0(AT, STATE, _, TEMP),
nth0(AT, STATE3, VALUE, TEMP),
AT2 is AT+1,
sys_store_ints(LIST, STATE3, AT2, STATE2).
sys_store_ints([], STATE, _, STATE).
% sys_store_miss(+Integer, +List, +Integer, -List)
sys_store_miss(VALUE, STATE, AT, STATE2) :-
AT2 is AT-1,
nth0(AT2, STATE, _, TEMP),
nth0(AT2, STATE2, VALUE, TEMP).
/****************************************************************/
/* Disassembler */
/****************************************************************/
% instructions(+Goal)
instructions(GOAL) :-
sys_trans_body(GOAL, nothing, MARK, 1, CONT, []),
(sys_comp_prog(MARK, CONT, CODE, _, _),
sys_disasm_code(0-CODE, _-[]),
fail;
true).
% sys_disasm_code(+Pair, -Pair)
sys_disasm_code --> sys_label(STEP), sys_instr((MODE, FUN, OBJ)), !,
sys_disasm_instr(MODE, FUN, OBJ, LIST),
{format('~t~d~5|: ~w ~p, ~p', [STEP|LIST]), nl},
sys_disasm_code.
sys_disasm_code --> [].
% sys_disasm_instr(+Atom, +Atom, +Integer, -List, +Pair, -Pair)
sys_disasm_instr(cst, FUN, OBJ, [FUN, 'A', OBJ]) --> [].
sys_disasm_instr(get, FUN, OBJ, [FUN, 'A', [OBJ]]) --> [].
sys_disasm_instr(ext, FUN, _, [FUN, 'A', OBJ]) -->
sys_instr(OBJ).
sys_disasm_instr(out, FUN, OBJ, [FUN, 'A', out(OBJ)]) --> [].
sys_disasm_instr(in, FUN, OBJ, [FUN, 'A', in(OBJ)]) --> [].
sys_disasm_instr(set, mov, OBJ, [mov, [OBJ], 'A']) --> [].
sys_disasm_instr(bra, mov, OBJ, [jmz, 0, OBJ]) --> [].
sys_disasm_instr(brz, mov, OBJ, [jmz, 'A', OBJ]) --> [].
sys_disasm_instr(jma, mov, OBJ, [jmz, 0, [OBJ]]) --> [].
sys_disasm_instr(jmz, mov, OBJ, [jmz, 'A', [OBJ]]) --> [].