x86_init(3)

👑 x86_init — NAME

okay so bestie, we're in libdisasm land 💖 and this page is all about x86_init and x86_cleanup — the little ritual where you initialize libdisasm and then clean up after it, because we are nothing if not polite. periodt.

✨ SYNOPSIS ✨

#include <libdis.h>

typedef void (*DISASM_REPORTER)( enum x86_report_codes code,
        void * data, void * arg );

int x86_init( enum x86_options options, DISASM_REPORTER reporter,
        void * arg);

int x86_cleanup(void);

so DISASM_REPORTER is the whole function-pointer type — it takes an enum x86_report_codes code, a void * data, and a void * arg. that's the little callback shape you're signing up for 🫶

🌸 DESCRIPTION 🌸

here's the two enums, served fresh, no edits, exactly as they come:

enum x86_options {
     opt_none= 0,
     opt_ignore_nulls=1, /* ignore sequences of > 4 NULL bytes */
     opt_16_bit=2,       /* 16-bit/DOS disassembly */
     opt_unknown
};

so like — opt_none is 0, the "i want nothing extra" vibe. opt_ignore_nulls is 1, and its whole thing is ignoring sequences of more than 4 NULL bytes 💀. opt_16_bit is 2, which is your 16-bit/DOS disassembly era. and then there's opt_unknown, just chilling at the end. slay.

and the report codes:

enum x86_report_codes {
        report_disasm_bounds,
        report_insn_bounds,
        report_invalid_insn,
        report_unknown
};

those are the four flavours of "something went sideways" your reporter is gonna hear about 👑

🎀 EXAMPLES 🎀

okay bestie, here's the skeleton — a full little starter kit for initializing AND terminating libdisasm. it's giving template. it's giving copy-paste-and-thrive. 💅

void reporter( enum x86_report_codes code, void *data, void *arg ) {
        char * str = NULL;
        FILE *stream = (FILE *) arg;
        if (! stream ) stream = stderr;

        /* here would could examine the error and do something useful;
         * instead we just print that an error occurred */
        switch ( code ) {
                case report_disasm_bounds:
                        str = "Attempt to disassemble RVA "
                              "beyond end of buffer";
                        break;
                case report_insn_bounds:
                        str = "Instruction at RVA extends "
                              "beyond buffer";
                        break;
                case report_invalid_insn:
                        str = "Invalid opcode at RVA";
                        break;
                case report_unknown:
                        str = "Unknown Error";
                        break;
        }

        fprintf(stream, "ERROR ´%s:´ %p0, str, data);
}

quick tour: str starts as NULL, stream gets cast from arg to a FILE *, and if there's no stream at all it falls back to stderr — no stream left behind 🥺. then the switch walks through all four codes and sets str to a matching message. and the comment up top is literally saying you could do something useful with the error here, but instead we're just printing that an error happened. relatable tbh 🙈

and then the main character:

int main( int argc, char **argv ) {
        x86_init(opt_none, reporter, stderr);

        /* disassembler code goes here */

        x86_cleanup();
}

you call x86_init(opt_none, reporter, stderr), you drop your disassembler code in the middle (that's the /* disassembler code goes here */ slot, iconic), and then you call x86_cleanup(). open and close. in and out. the circle of life 🌈

🦋 SEE ALSO 🦋

go bother these next, they're all in the friend group:

• libdisasm(7)
• x86_disasm(3)
• x86_format_insn(3)
• x86dis(1)

and that's the page, bestie 💖 this one's from mammon_, version 0.21, and yeah it's literally titled x86_init(3) in section 3 of the libdisasm manual — go forth and initialize responsibly ✨🎀