ruberon/lib/Linux/LINAPI.ob07

(*
    BSD 2-Clause License

    Copyright (c) 2019-2021, Anton Krotov
    All rights reserved.
*)

MODULE LINAPI;

IMPORT SYSTEM, API, Libdl;


TYPE

    TP* = ARRAY 2 OF INTEGER;
    SOFINI* = PROCEDURE;


VAR

    libc*, librt*: INTEGER;

    stdout*,
    stdin*,
    stderr*        : INTEGER;

    malloc*        : PROCEDURE [linux] (size: INTEGER): INTEGER;
    free*          : PROCEDURE [linux] (ptr: INTEGER);
    exit*          : PROCEDURE [linux] (code: INTEGER);
    puts*          : PROCEDURE [linux] (pStr: INTEGER);
    fwrite*,
    fread*         : PROCEDURE [linux] (buffer, bytes, blocks, file: INTEGER): INTEGER;
    fopen*         : PROCEDURE [linux] (fname, fmode: INTEGER): INTEGER;
    fclose*        : PROCEDURE [linux] (file: INTEGER): INTEGER;
    time*          : PROCEDURE [linux] (ptr: INTEGER): INTEGER;

    clock_gettime* : PROCEDURE [linux] (clock_id: INTEGER; VAR tp: TP): INTEGER;


PROCEDURE SetFini* (ProcFini: SOFINI);
BEGIN
    API.SetFini(ProcFini)
END SetFini;


PROCEDURE GetSym (lib: INTEGER; name: ARRAY OF CHAR; VarAdr: INTEGER);
VAR
    sym: INTEGER;

BEGIN
    sym := Libdl.sym(lib, name);
    ASSERT(sym # 0);
    SYSTEM.PUT(VarAdr, sym)
END GetSym;


PROCEDURE init;
BEGIN
    libc := API.libc;

    GetSym(libc, "exit",   SYSTEM.ADR(exit));
    GetSym(libc, "puts",   SYSTEM.ADR(puts));
    GetSym(libc, "malloc", SYSTEM.ADR(malloc));
    GetSym(libc, "free",   SYSTEM.ADR(free));
    GetSym(libc, "fread",  SYSTEM.ADR(fread));
    GetSym(libc, "fwrite", SYSTEM.ADR(fwrite));
    GetSym(libc, "fopen",  SYSTEM.ADR(fopen));
    GetSym(libc, "fclose", SYSTEM.ADR(fclose));
    GetSym(libc, "time",   SYSTEM.ADR(time));

    GetSym(libc, "stdout", SYSTEM.ADR(stdout)); SYSTEM.GET(stdout, stdout);
    GetSym(libc, "stdin",  SYSTEM.ADR(stdin));  SYSTEM.GET(stdin,  stdin);
    GetSym(libc, "stderr", SYSTEM.ADR(stderr)); SYSTEM.GET(stderr, stderr);

    librt := Libdl.open("librt.so.1", Libdl.LAZY);

    GetSym(librt, "clock_gettime", SYSTEM.ADR(clock_gettime))
END init;


$IF (CPU_X86)
PROCEDURE [oberon-] syscall* (eax, ebx, ecx, edx, esi, edi: INTEGER): INTEGER;
BEGIN
    SYSTEM.CODE(
    053H,               (*  push    ebx                    *)
    056H,               (*  push    esi                    *)
    057H,               (*  push    edi                    *)
    08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
    08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
    08BH, 04DH, 010H,   (*  mov     ecx, dword [ebp + 16]  *)
    08BH, 055H, 014H,   (*  mov     edx, dword [ebp + 20]  *)
    08BH, 075H, 018H,   (*  mov     esi, dword [ebp + 24]  *)
    08BH, 07DH, 01CH,   (*  mov     edi, dword [ebp + 28]  *)
    0CDH, 080H,         (*  int     128                    *)
    05FH,               (*  pop     edi                    *)
    05EH,               (*  pop     esi                    *)
    05BH,               (*  pop     ebx                    *)
    05DH,               (*  pop     ebp                    *)
    0C2H, 018H, 000H    (*  ret     24                     *)
    )
    RETURN 0
END syscall;


$ELSIF (CPU_X8664)
PROCEDURE [oberon-] syscall* (rax, rdi, rsi, rdx, r10, r8, r9: INTEGER): INTEGER;
BEGIN
    SYSTEM.CODE(
    048H, 08BH, 045H, 010H,  (*  mov rax, qword [rbp + 16]  *)
    048H, 08BH, 07DH, 018H,  (*  mov rdi, qword [rbp + 24]  *)
    048H, 08BH, 075H, 020H,  (*  mov rsi, qword [rbp + 32]  *)
    048H, 08BH, 055H, 028H,  (*  mov rdx, qword [rbp + 40]  *)
    04CH, 08BH, 055H, 030H,  (*  mov r10, qword [rbp + 48]  *)
    04CH, 08BH, 045H, 038H,  (*  mov r8,  qword [rbp + 56]  *)
    04CH, 08BH, 04DH, 040H,  (*  mov r9,  qword [rbp + 64]  *)
    00FH, 005H,              (*  syscall                    *)
    05DH,                    (*  pop rbp                    *)
    0C2H, 038H, 000H         (*  ret 56                     *)
    )
    RETURN 0
END syscall;
$END


BEGIN
    init
END LINAPI.