Chubek/README.md

Following my last set of macros, PommeMacs, I now present: MangoMacs. There are four files in this Gist. They are:

1- registers.m -> These are all the register mappings of the C ABI in Linux and System Calls ABI likewise. They are quite similar, except in the C ABI, arg3 (counting from 0) is RCX whereas in the Syscall ABI, this argument is R10. This creates a bit of an issue in creating a wrapper, but since RCX is not used in System Calls ABI, we can safely discard it. As we do in the SYSCALL_implement macro which we use to implement all 330-odd syscalls.

2- syscall.m -> These are all the NRs for the syscalls. We use them to implement the wrapper. At the end of the file there's the aforementioned SYSCALL_implement macro. This is the macro we use to create our wrappers.

3- syscall.S -> These are the wrappers, implemented using the macro, besides we have the .global directive for all of them.

4- syscall.h -> These are all the signatures. Keep one thing in mind, these signatures have been scraped by this dude's AWK shell script, they do not have the typedefs. I will soon release a more comprehensive version with all the typedefs and not only that, all the constants and flags. We'll see.

I have not included the macros in any of the files, but both the .m files rely on each other, and so does the Assembly code. So ideally, if you wish to use these macros and wrappers, include both the macro files somewhere in your source files. If you wish to include them more than once, use an include guard. You can include the .S file just like any .c file, both with GCC and Clang. But remember, the extension must be .S, not .s, or anything else, otherwise CPP will not preprocess the file beforehand.

Here is how I usually use register macros:

#ifndef __INC_REGISTERS_M
#define __INC_REGISTERS_M
#include "registers.m"
#endif

lzcnt_long:
    #define LONG_NUM CABI_AGQ0
    #define RETR_REG CABI_RET
    
    REGISTER_zero_out(RETR_REG)
    lzcnt LONG_NUM, RETR_REG
    
    ret
    
    #undef LONG_NUM
    #undef RETR_REG

Remember to #undef the macros at the end of each subroutine. It's just less headache that way. As for the syscall wrappers:

#ifndef __INC_REGISTERS_M
#define __INC_REGISTERS_M
#include "registers.m"
#endif
#ifndef __INC_SYSCALL_M
#define __INC_SYSCALL_M
#include "syscall.m"
#endif
#ifndef __INC_SYSCALL_H
#define __INC_SYSCALL_H
#include "syscall.h"
#endif

#define O_CREAT 64

int main()
{
    const int fd = open("file.f", O_CREAT);
    close(fd);
}

I got the value for O_CREAT from Python's os module. It is a good place for getting these values. Otherwise you can just grep or awk it. To compile:

gcc myfile.c syscall.S -o sysctst

Anyways and anyhow.

For now I have realized that, maybe it is not such a fine thing to wrap your code in Assembly. So I won't be using these myself for my current project, which is a tunnel called tullenz. But alas I must say that this is oft necessary to go knee-deep in machine code. I have acclimated myself with Assembly over the past several months, and I have implemented some good code in it. You can view all my projects in my Github profile, this is where I host all my projects. There are indeed some interesting stuff there, there's a lot of stuff there, in fact, just dig in. My unfinished projects could still be a repository for good algorithms that I have implemented. Who knows?

Anyways, happy coding.

PS: to be quit frank, these are untested. Like, no test, zilch. Remain vigilant.