Sfoglia il codice sorgente

bunch of work on pcode and overall arch

tags/v0.1
parent
commit
2b04384bfc
Non sono state trovate chiavi note per questa firma nel database
7 ha cambiato i file con 284 aggiunte e 83 eliminazioni
  1. +3
    -0
      data/languages/kh2ai.cspec
  2. +1
    -1
      data/languages/kh2ai.ldefs
  3. +3
    -0
      data/languages/kh2ai.pspec
  4. +195
    -8
      data/languages/kh2ai.sinc
  5. BIN
      data/manuals/.swp
  6. +78
    -74
      data/manuals/kh2ai.tex
  7. +4
    -0
      notes.txt

+ 3
- 0
data/languages/kh2ai.cspec Vedi File

@@ -26,6 +26,9 @@
<range space="ram"/>
</global>
<stackpointer register="sp" space="ram"/>
<returnaddress>
<register name="ra"/>
</returnaddress>
<default_proto>
<prototype name="__stdcall" extrapop="0" stackshift="0">
<input>

+ 1
- 1
data/languages/kh2ai.ldefs Vedi File

@@ -9,7 +9,7 @@
slafile="kh2ai.sla"
processorspec="kh2ai.pspec"
manualindexfile="../manuals/kh2ai.idx"
id="KH2_AI:LE:32:default">
id="kh2_ai:le:32:default">
<description>Kingdom Hearts 2 pseudo-processor 32-bit little-endian</description>
<compiler name="default" spec="kh2ai.cspec" id="default"/>
</language>

+ 3
- 0
data/languages/kh2ai.pspec Vedi File

@@ -2,4 +2,7 @@

<processor_spec>
<programcounter register="pc"/>
<properties>
<property key="assemblyRating:kh2_ai:le:32:default" value="GOLD"/>
</properties>
</processor_spec>

+ 195
- 8
data/languages/kh2ai.sinc Vedi File

@@ -1,4 +1,3 @@
# Main slaspec must define endianess and alignment

define space ram type=ram_space size=4 wordsize=1 default;
define space register type=register_space size=4;
@@ -7,7 +6,7 @@ define space register type=register_space size=4;
# internal regs are used besides stack
define register offset=0 size=4 [
r0 r1 r2 r3 r4 r5 r6
r7 r8 pc sp test broken
r7 r8 pc sp ra broken
];

define token instr(16)
@@ -39,8 +38,23 @@ attach values [ iarg ] [ 1 2 _ _ ];


define pcodeop system_call;
define pcodeop fmod;
define pcodeop exit;
define pcodeop cos;
define pcodeop sin;
define pcodeop radians_to_degrees;
define pcodeop degrees_to_radians;


macro push(v) {
*[ram]:4 sp = v;
sp = sp + 4;
}

macro pop(v) {
sp = sp - 4;
v = *[ram]:4 sp;
}

#
#
@@ -53,6 +67,7 @@ define pcodeop system_call;

# standard push
:push full_ext is opcode=0 & ( sub_opc=1 | sub_opc=0 ) ; full_ext {
push(full_ext:4);
}


@@ -68,6 +83,8 @@ define pcodeop system_call;
}

:push LABEL02 is opcode_ext=0 & sub_opc_ext=2 & opesub=3 & LABEL02 {
# this is wrong! it pushes the pointer, not the data
push(LABEL02:4);
}


@@ -94,14 +111,14 @@ define pcodeop system_call;
}


:unk2 is opcode_ext=2 {
:unk2 is opcode_ext=2 {
}

# pops relative address from the stack and convert it to absolute
:rela is opcode_ext=3 {
}

:unk4 is opcode=4 {
:unk4 is opcode=4 {
}

# 0x5 =========
@@ -111,48 +128,94 @@ define pcodeop system_call;

# convert float to int
:cfti is opcode=5 & sub_opc=0 & ssub_opc=0{
local tmp:4 = sp;
pop(tmp);
tmp = round(tmp);
push(tmp);
}

# convert to negative
:neg is opcode=5 & sub_opc=0 & ssub_opc=2{
local tmp:4 = sp;
pop(tmp);
tmp = tmp;
tmp=-tmp;
push(tmp);
}

# invert
:inv is opcode=5 & sub_opc=0 & ssub_opc=3{
local tmp:4 = sp;
pop(tmp);
tmp = ~tmp;
push(tmp);
}

# is equal zero
:eqz is opcode=5 & sub_opc=0 & ( ssub_opc=4 | ssub_opc=8 ){
local tmp:4 = sp;
pop(tmp);
local ret = (tmp == 0);
push(ret);
}

# absolute
:abs is opcode=5 & sub_opc=0 & ssub_opc=5{
local tmp:4 = sp;
pop(tmp);
if(tmp<=0) goto <min>;
goto <done>;
<min>
tmp=-tmp;
<done>
push(tmp);
}

# most significant bit
:msb is opcode=5 & sub_opc=0 & ssub_opc=6{
local tmp:4 = sp;
pop(tmp);
tmp = tmp >> 0x1F;
push(tmp);
}

# inferior to one
:info is opcode=5 & sub_opc=0 & ssub_opc=7{
local tmp:4 = sp;
pop(tmp);
push((tmp < 1));
}

# not equal to zero
:neqz is opcode=5 & sub_opc=0 & ssub_opc=9{
local tmp:4 = sp;
pop(tmp);
push((tmp != 0));
}

# most significant bit inverted
:msbi is opcode=5 & sub_opc=0 & ssub_opc=0xA{
local tmp:4 = sp;
pop(tmp);
tmp = tmp >> 0x1F;
push(~tmp);
}

# is positive
:ipos is opcode=5 & sub_opc=0 & ssub_opc=0xb{
local tmp:4 = sp;
pop(tmp);
push((tmp > 0));
}

# 0x5 --- floats

# convert int to float
:citf is opcode=5 & sub_opc=1 & ssub_opc=0{
local tmp:4 = sp;
pop(tmp);
tmp=int2float(tmp);
push(tmp);
}

# convert to negative (float)
@@ -161,6 +224,10 @@ define pcodeop system_call;

# ABS (float)
:absf is opcode=5 & sub_opc=1 & ssub_opc=5{
local tmp:4 = sp;
pop(tmp);
tmp=abs(tmp);
push(tmp);
}

# inferior to zero (float)
@@ -195,69 +262,171 @@ define pcodeop system_call;

# addition
:add is opcode=6 & sub_opc=0 & ssub_opc=0{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2+tmp);
}

# substraction
:sub is opcode=6 & sub_opc=0 & ssub_opc=1{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2-tmp);
}

# multiplication
:mul is opcode=6 & sub_opc=0 & ssub_opc=2{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2 * tmp);
}

# division
:div is opcode=6 & sub_opc=0 & ssub_opc=3{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2 s/ tmp);
}

# modulo
:mod is opcode=6 & sub_opc=0 & ssub_opc=4{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2 s% tmp);
}

# logical and
:and is opcode=6 & sub_opc=0 & ssub_opc=5{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2&tmp);
}

# logical or
:or is opcode=6 & sub_opc=0 & ssub_opc=6{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2|tmp);
}

# logical exclusive or
:xor is opcode=6 & sub_opc=0 & ssub_opc=7{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2^tmp);
}

# shift logical left
:sll is opcode=6 & sub_opc=0 & ssub_opc=8{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2<<(tmp&0x1F));
}

# shift right arithmetic
:sra is opcode=6 & sub_opc=0 & ssub_opc=9{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2>>(tmp&0x1F));
}

# not equal to zero (2 variable stack edition)
:neqzv is opcode=6 & sub_opc=0 & ssub_opc=0xA{
:eqzv is opcode=6 & sub_opc=0 & ssub_opc=0xA{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
local ret:4 = 1;
if(tmp!=0) goto <next>;
goto <end>;
<next>
if(tmp2==0) goto <end>;
ret=0;
<end>
push(ret);
}

# equal to zero (2 variable stack edition)
:eqzv is opcode=6 & sub_opc=0 & ssub_opc=0xB{
:neqzv is opcode=6 & sub_opc=0 & ssub_opc=0xB{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
local ret:4 = 1;
if(tmp==0) goto <next>;
goto <end>;
<next>
if(tmp2!=0) goto <end>;
ret=0;
<end>
push(ret);
}


# addition (float)
:addf is opcode=6 & sub_opc=1 & ssub_opc=0{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2 f+ tmp);
}
# substraction (float)
:subf is opcode=6 & sub_opc=1 & ssub_opc=1{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2 f- tmp);
}

# multiplication (float)
:mulf is opcode=6 & sub_opc=1 & ssub_opc=2{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2 f* tmp);
}

# division (float)
:divf is opcode=6 & sub_opc=1 & ssub_opc=3{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
push(tmp2 f/ tmp);
}

# modulo (float)
:modf is opcode=6 & sub_opc=1 & ssub_opc=4{
local tmp:4 = sp;
local tmp2:4 = sp;
pop(tmp);
pop(tmp2);
# primitive doesn't exist, so we do with what we can
local ret:4 = fmod(tmp2, tmp);
push(ret);
}

# 0x6 =========
@@ -278,17 +447,19 @@ define pcodeop system_call;
# jump
# TODO: verify first arg!
:jmp ope3, LABEL8 is opcode_ext=8 & LABEL8 & ope3 {
call LABEL8;
call LABEL8;
}


# 0x9 =========

:exit iarg is opcode=9 & ( ssub_opc=0 | ssub_opc=1 ) & iarg{
exit(iarg:1);
}

# return
:ret is opcode=9 & ssub_opc=2{
return[ra];
}

# push cached -> push last cached pushed element to stack
@@ -302,19 +473,35 @@ define pcodeop system_call;

# sinus; arg in radians
:sin is opcode=9 & ssub_opc=6{
local tmp:4 = sp;
pop(tmp);
local ret:4 = sin(tmp);
push(ret);
}

# cosinus; arg in radians
:cos is opcode=9 & ssub_opc=7{
local tmp:4 = sp;
pop(tmp);
local ret:4 = cos(tmp);
push(ret);
}

# degrees to radians
# /!\ radians are [0-2pi] in this engine
:degr is opcode=9 & ssub_opc=8{
local tmp:4 = sp;
pop(tmp);
local ret:4 = degrees_to_radians(tmp);
push(ret);
}

# radians to degree
:radd is opcode=9 & ssub_opc=9{
local tmp:4 = sp;
pop(tmp);
local ret:4 = radians_to_degrees(tmp);
push(ret);
}


@@ -324,7 +511,7 @@ define pcodeop system_call;

#syscall
:syscall opesub,ope2 is opcode_ext=0xA & opesub & ope2 {
r0=system_call(opesub:4,ope2:4);
system_call(opesub:4,ope2:4);
}

:unkB is opcode=0xB {

BIN
data/manuals/.swp Vedi File


+ 78
- 74
data/manuals/kh2ai.tex Vedi File

@@ -54,11 +54,11 @@
\newpage
}

\newcommand{\ISA}[6]{
\newcommand{\ISA}[7]{
\section{\huge #1}
\Lineless \\
\textbf{Operation Code} \\ \\
\bitpicture {0}{10000000}{10010010000111111010000} \\ \\
\bitpicture {#7} \\ \\
\textbf{Format} \\
\hspace*{0.5cm} #2 \\ \\
\textbf{Description} \\
@@ -72,39 +72,31 @@
\newpage
}

\newcommand\bitpicture [3]{%
\newcommand\bitpicture [1]{%
\setlength{\unitlength}{0.9mm}
\setlength{\fboxsep}{0mm}
\begin{picture}(130,16)
% sign bit
\put(2,4){\framebox(4,8){#1}}
% exponent
\setcounter{bitindex}{1}%
\xintFor* ##1 in {#2}
\xintFor* ##1 in {#1}
\do
{\put(\numexpr 2+4*\value{bitindex},4){\framebox(4,8){##1}}%
\stepcounter{bitindex}}%
% fraction
\setcounter{bitindex}{1}%
\xintFor* ##1 in {#3}
\do
{\put(\numexpr 34+4*\value{bitindex},4){\framebox(4,8){##1}}%
{\put(\numexpr 1+4*\value{bitindex},4){\framebox(4,8){##1}}%
\stepcounter{bitindex}}%
% upper labels
\put(0,14){\scriptsize{MSB}}
\put(126,14){\scriptsize{LSB}}
%lower labels
\put(3,0){\scriptsize{S}}
\put(7,0){\line(0,1){2}}
\put(7,1){\vector(1,0){8}}
\put(16,0){\scriptsize{Exponent}}
\put(37,1){\vector(-1,0){8}}
\put(37,0){\line(0,1){2}}
\put(39,0){\line(0,1){2}}
\put(39,1){\vector(1,0){38}}
\put(79,0){\scriptsize{Fraction}}
\put(130,1){\vector(-1,0){38}}
\put(130,0){\line(0,1){2}}
% \put(3,0){\scriptsize{S}}
% \put(7,0){\line(0,1){2}}
% \put(7,1){\vector(1,0){8}}
% \put(16,0){\scriptsize{Exponent}}
% \put(37,1){\vector(-1,0){8}}
% \put(37,0){\line(0,1){2}}
% \put(39,0){\line(0,1){2}}
% \put(39,1){\vector(1,0){38}}
% \put(79,0){\scriptsize{Fraction}}
% \put(130,1){\vector(-1,0){38}}
% \put(130,0){\line(0,1){2}}
\end{picture}%
}

@@ -128,104 +120,116 @@

\Chapter{Instruction Set}

\ISA{PUSH: Push}{b}{c}{d}{e}{f}
\ISA{PUSH: Push}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{PUSHA: Push and Add}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{PUSHAP: Push and Add to Pointer}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{POP: pop}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{PUSHA: Push and Add}{b}{c}{d}{e}{f}
\ISA{CFTI: Convert Float To Int}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{PUSHAP: Push and Add to Pointer}{b}{c}{d}{e}{f}
\ISA{NEG: convert to NEGative signed number}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{POP: pop}{b}{c}{d}{e}{f}
\ISA{INV: INVert an unsigned value}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{CFTI: Convert Float To Int}{b}{c}{d}{e}{f}
\ISA{EQZ: conditional is EQual Zero}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{NEG: convert to NEGative signed number}{b}{c}{d}{e}{f}
\ISA{ABS: convert to ABSolute value}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{INV: INVert an unsigned value}{b}{c}{d}{e}{f}
\ISA{MSB: return Most Significant Bit}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{EQZ: conditional is EQual Zero}{b}{c}{d}{e}{f}
\ISA{INFO: conditional INFerior to One}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{ABS: convert to ABSolute value}{b}{c}{d}{e}{f}
\ISA{NEQZ: conditional Not Equal to Zero}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{MSB: return Most Significant Bit}{b}{c}{d}{e}{f}
\ISA{MSB: return Most Significant Bit Inverted}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{INFO: conditional INFerior to One}{b}{c}{d}{e}{f}
\ISA{IPOS: Conditional Is POSitive}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{NEQZ: conditional Not Equal to Zero}{b}{c}{d}{e}{f}
\ISA{CITF: Convert Int To Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{MSB: return Most Significant Bit Inverted}{b}{c}{d}{e}{f}
\ISA{NEGF: convert to NEGative Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{IPOS: Conditional Is POSitive}{b}{c}{d}{e}{f}
\ISA{ABS: convert to ABSolute Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{CITF: Convert Int To Float}{b}{c}{d}{e}{f}
\ISA{INFZF: Conditional INFerior to Zero Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{NEGF: convert to NEGative Float}{b}{c}{d}{e}{f}
\ISA{INFOEZF: Conditional INFerior Or Equal to Zero Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{ABS: convert to ABSolute Float}{b}{c}{d}{e}{f}
\ISA{EQZF: conditional is EQual Zero Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{INFZF: Conditional INFerior to Zero Float}{b}{c}{d}{e}{f}
\ISA{NEQZF: conditional Not Equal to Zero Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{INFOEZF: Conditional INFerior Or Equal to Zero Float}{b}{c}{d}{e}{f}
\ISA{SUPOEZF: conditional SUPerior Or Equal to Zero Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{EQZF: conditional is EQual Zero Float}{b}{c}{d}{e}{f}
\ISA{SUPZF: conditional SUPerior to Zero Float}{b}{c}{d}{e}{f}{01000000010010010000111111010000}

\ISA{NEQZF: conditional Not Equal to Zero Float}{b}{c}{d}{e}{f}
\ISA{ADD: ADDition}{b}{c}{d}{e}{f}{11000010000000001}

\ISA{SUPOEZF: conditional SUPerior Or Equal to Zero Float}{b}{c}{d}{e}{f}
\ISA{SUB: SUBstraction}{b}{c}{d}{e}{f}{11000010000000001}

\ISA{SUPZF: conditional SUPerior to Zero Float}{b}{c}{d}{e}{f}
\ISA{MUL: MULtiplication}{b}{c}{d}{e}{f}{11000010000000010}

\ISA{ADD: ADDition}{b}{c}{d}{e}{f}
\ISA{DIV: DIVision}{b}{c}{d}{e}{f}{11000010000000011}

\ISA{SUB: SUBstraction}{b}{c}{d}{e}{f}
\ISA{MOD: MODulo}{b}{c}{d}{e}{f}{11000010000000100}

\ISA{MUL: MULtiplication}{b}{c}{d}{e}{f}
\ISA{AND: logical AND}{b}{c}{d}{e}{f}{11000010000000101}

\ISA{DIV: DIVision}{b}{c}{d}{e}{f}
\ISA{OR: logical OR}{b}{c}{d}{e}{f}{11000010000000110}

\ISA{MOD: MODulo}{b}{c}{d}{e}{f}
\ISA{XOR: logical eXclusive OR}{b}{c}{d}{e}{f}{11000010000000111}

\ISA{AND: logical AND}{b}{c}{d}{e}{f}
\ISA{SLL: Shift Logical Left}{b}{c}{d}{e}{f}{11000010000001000}

\ISA{OR: logical OR}{b}{c}{d}{e}{f}
\ISA{SRA: Shift Right Arithmetic}{b}{c}{d}{e}{f}{11000010000001001}

\ISA{XOR: logical eXclusive OR}{b}{c}{d}{e}{f}
\ISA{NEQZV: conditional Not EQual to Zero with stack Values}{b}{c}{d}{e}{f}{1100001000001010}

\ISA{SLL: Shift Logical Left}{b}{c}{d}{e}{f}
\ISA{EQZV: conditional EQual to Zero with stack Values}{b}{c}{d}{e}{f}{11000010000001011}

\ISA{SRA: Shift Right Arithmetic}{b}{c}{d}{e}{f}
\ISA{ADDF: ADDition with Float values}{b}{c}{d}{e}{f}{11000010000000000}

\ISA{NEQZV: conditional Not EQual to Zero with stack Values}{b}{c}{d}{e}{f}
\ISA{SUBF: SUBstraction with Float values}{b}{c}{d}{e}{f}{11000010000000001}

\ISA{EQZV: conditional EQual to Zero with stack Values}{b}{c}{d}{e}{f}
\ISA{MULF: MULtiplication with Float values}{b}{c}{d}{e}{f}{11000010000000010}

\ISA{ADDF: ADDition with Float values}{b}{c}{d}{e}{f}
\ISA{DIVF: DIVision with Float values}{b}{c}{d}{e}{f}{11000010000000011}

\ISA{SUBF: SUBstraction with Float values}{b}{c}{d}{e}{f}
\ISA{MODF: MODulo with Float values}{b}{c}{d}{e}{f}{11000010000000100}

\ISA{MULF: MULtiplication with Float values}{b}{c}{d}{e}{f}
\ISA{JMP: JuMP}{b}{c}{d}{e}{f}{TODO}

\ISA{DIVF: DIVision with Float values}{b}{c}{d}{e}{f}
\ISA{EXIT: EXIT}{r=exit value}{c}{d}{e}{f}{100100000000000r}

\ISA{MODF: MODulo with Float values}{b}{c}{d}{e}{f}
\ISA{RET: RETurn}{b}{c}{d}{e}{f}{1001000000000010}

\ISA{JMP: JuMP}{b}{c}{d}{e}{f}
\ISA{PUSHCA: PUSH CAched value}{b}{c}{d}{e}{f}{1001000000000011}

\ISA{EXIT: EXIT}{b}{c}{d}{e}{f}
\ISA{PUSHC: PUSH Copy}{b}{c}{d}{e}{f}{1001000000000101}

\ISA{RET: RETurn}{b}{c}{d}{e}{f}
\ISA{SIN: SINus}{b}{c}{d}{e}{f}{1001000000000110}

\ISA{PUSHCA: PUSH CAched value}{b}{c}{d}{e}{f}
\ISA{COS: COSinus}{Retrieves the latest value pushed to the stack and apply a
cosinus onto it, pushing it to the stack}{None}{d}{e}{Radians are used as input. Radians used are modulo pi-2pi}{1001000000000111}

\ISA{PUSHC: PUSH Copy}{b}{c}{d}{e}{f}
\ISA{DEGR: DEGrees to Radians}{Retrieves the last element pushed to the stack
and converts it to radians, pushing it to the stack}{None}{d}{e}{Radians used are modulo pi-2pi}{1001000000001000}

\ISA{SIN: SINus}{b}{c}{d}{e}{f}
\ISA{RADD: RADians to Degrees}{RADD}{Retrieves the last element pushed to the
stack and converts it to degrees, pushing it to the stack}{None}{e}{Radians used are modulo pi-2pi}{1001000000001001}

\ISA{COS: COSinus}{b}{c}{d}{e}{f}
\ISA{SYSCALL: SYStem CALL}{b}{c}{d}{e}{f}{TODO}

\ISA{DEGR: DEGrees to Radians}{b}{c}{d}{e}{f}

\ISA{RADD: RADians to Degrees}{b}{c}{d}{e}{f}
\Chapter{System Calls}

\ISA{SYSCALL: SYStem CALL}{b}{c}{d}{e}{f}
\section{Introduction}
What is a system call blabla.
None of them are currently documented, they are available at address 0x0034dd00
of SLPM\_666.75, and there is 738 elements if I'm not mistaken. Either try to
guess their arguments

\end{document}

+ 4
- 0
notes.txt Vedi File

@@ -78,3 +78,7 @@ TODO:
-----
0x8: figure out first arg of jmp, offset?
0x7: figure out args and diff between 3 jmp

==============
SOMETHING IS UNALIGNED IN ONE OF THOSE OPCODES!!!!:
push3_unk0,push2_unk0,push(not label), unk2,unk4,rela,jmp7_unk{1_2}

Loading…
Annulla
Salva