anon/eaxhla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://codeberg.org/eaxcc/eaxcc

Browse Source
This commit is contained in:
anon 2024-07-12 16:51:25 +02:00
commit bdf303028b
18 changed files with 9806 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -26,7 +26,7 @@ OUT := eaxhla
SOURCE.d := source
OBJECT.d := object
SOURCE := main.c assembler.c eaxhla.c
SOURCE := main.c assembler.c eaxhla.c unix.c
OBJECT := $(addprefix ${OBJECT.d}/,${SOURCE})
OBJECT := ${OBJECT:.c=.o}

38
documentation/INSTRUCTIONS.md Normal file
View File

@ -0,0 +1,38 @@
# 2 argument instructions (t6)
## add, or, adc, sbb, and, sub, xor, cmp;
- REG REG // This means that arg1 can only be REG or MEM.
- REG MEM // And arg2 can only be REG, MEM or IMM, but:
- REG IMM // You can't use MEM as both arguments.
- MEM REG // This limitation stems from x64 encoding.
- MEM IMM // Hardware we use can't encode that.
- REG or MEM can use D8 ... D64, any size.
- IMM in this case must be maximum 32 bit.
- Examples:
```c
add rax 0x11223344 // ADD D64 REG R0 IMM 0x11223344
or ecx 0x11223344 // OR D32 REG R1 IMM 0x11223344
adc dx 0x1122 // ADC D16 REG R2 IMM 0x1122
sbb bl 0x11 // SBB D8 REG R3 IMM 0x11
```
# 1 argument instructions (t4)
## inc, dec, not, neg, mul, imul, div, idiv;
- REG
- MEM
- REG or MEM can use D8 ... D64, any size.
- IMM can't be used with these instructions.
- Examples:
```c
inc rsp // INC D64 REG R4
dec ebp // DEC D32 REG R5
not si // NOT D16 REG R6
neg dil // NEG D8 REG R7
```

163
source/assembler.c
View File

@ -2,23 +2,6 @@
#include <stdlib.h>
/*
gcc -c -ansi -Wall -Wextra -Wpedantic -Werror:
-- warns about trailing comma in enumerations.
-- kept because of chad coding standard.
-- unused functions for now, obviously...
clang -c -ansi -Weverything -Werror:
-- exactly same warnings as with gcc above.
splint -fcnuse +boolint +charint assembler.c:
-- we obviously ignore unused functions for now.
-- we assume bool is int, which is true.
-- we assume char is int, which is true.
-- assembler.c:167:13: Function fabs shadows outer declaration
-- ^ function from <math.h>, which we don't even use.
splint assembler.h:
-- no warnings at all.
*/
#define REGULAR_BEGIN (ADD)
#define REGULAR_END (CMP)
#define IRREGULAR_BEGIN (INC)
@ -40,41 +23,40 @@ splint assembler.h:
#define MOVE_IF_COUNT (MOVE_IF_END - MOVE_IF_BEGIN + 1)
// Regulates displacement, immediate, label, variable, constant, string data.
static next * empty_from;
/*static next * empty_from;
static next * empty_to;
static next * imbue_with;
static next * imbue_size;
static next * imbue_size;*/
// Main function.
static void place (form when,
byte data) {
/* */
token_array [token_count] = data;
text_sector_byte [text_sector_size] = data;
token_count += (next) when;
text_sector_size += (next) when;
}
static void print (form when,
size_index size,
next data) {
/* */
place ((when != 0) && (size >= D8), (byte) ((data >> 0) & 0XFF));
place ((when != 0) && (size >= D16), (byte) ((data >> 8) & 0XFF));
place ((when != 0) && (size >= D32), (byte) ((data >> 16) & 0XFF));
place ((when != 0) && (size >= D32), (byte) ((data >> 24) & 0XFF));
place ((when != 0) && (size >= D8), (byte) ((data >> 0) & 0xff));
place ((when != 0) && (size >= D16), (byte) ((data >> 8) & 0xff));
place ((when != 0) && (size >= D32), (byte) ((data >> 16) & 0xff));
place ((when != 0) && (size >= D32), (byte) ((data >> 24) & 0xff));
}
static form front (form data) { return ((data >= 4) && (data <= 7)); }
static form valid (form data) { return ((data >= 0) && (data <= 15)); }
static form lower (form data) { return ((data >= 0) && (data <= 7)); }
static form upper (form data) { return ((data >= 8) && (data <= 15)); }
// Important stuff that I need to handle later, it saves bytes!
static form far (next label) { return (1); /* DO NOT CHANGE YET! */ }
static form near (next label) { return (0); /* DO NOT CHANGE YET! */ }
static form far (next label) { return (label && 1); }
static form near (next label) { return (label && 0); }
static void build_short_prefix (form when) {
place (when, 0X66);
place (when, 0x66);
}
// 40-4D!0X02
@ -83,10 +65,10 @@ static void build_long_prefix (form use_big_registers,
form use_new_source) {
/* */
place (use_big_registers || use_new_destination || use_new_source,
(byte) (0X40
+ 0X01 * use_new_destination
+ 0X04 * use_new_source
+ 0X08 * use_big_registers));
(byte) (0x40
+ 0x01 * use_new_destination
+ 0x04 * use_new_source
+ 0x08 * use_big_registers));
}
// C0-FF
@ -94,25 +76,25 @@ static void build_register_direction (form when,
next destination,
next source) {
/* */
place (when, (byte) (0XC0
+ 0X01 * (destination & 0X07)
+ 0X08 * (source & 0X07)));
place (when, (byte) (0xc0
+ 0x01 * (destination & 0x07)
+ 0x08 * (source & 0x07)));
}
// 05-3D
static void build_register_redirection (form when,
next direction) {
/* */
place (when, (byte) (0X05
+ 0X08 * (direction & 0X07)));
place (when, (byte) (0x05
+ 0x08 * (direction & 0x07)));
}
// 80/81
static void build_constant (form when,
size_index size) {
/* */
place (when, (byte) (0X80
+ 0X01 * (size != D8)));
place (when, (byte) (0x80
+ 0x01 * (size != D8)));
}
// REGULAR_BEGIN-REGULAR_END D8-D64 REG/MEM R0-R15/MEM -||-/IMM -||-/IMM
@ -130,20 +112,28 @@ static void build_regular (operation_index operation,
(from == REG) && (upper ((form) source)));
// 40>front
place ((size == D8) && (to == REG) && (from == REG)
&& ((front (destination) && lower (source))
|| (lower (destination) && front (source))), (byte) 0X40);
place ((size == D8) && (to == REG) && ((from == REG) || (from == IMM))
&& (((front (destination) && lower (source))
|| (lower (destination) && front (source))) ||
((to == REG) && (from == IMM) && front (destination))),
(byte) 0x40);
build_constant (from == IMM, size);
place ((from == IMM) && (to == REG) && (destination == 0),
(byte) (0x05
+ 0x08 * (operation & 0x07))
- 0x01 * (size == D8));
place (1, (byte) (0X08 * (operation - REGULAR_BEGIN)
+ (destination & 0X07) * ((to == REG) && (from == IMM))
+ 0X01 * ((to == MEM) && (from == IMM) && (size == D8)) //
- 0X01 * ((to == REG) && (from == IMM)) //
+ 0X01 * (size != D8)
+ 0X02 * ((to == REG) && (from == MEM))
+ 0X04 * ((to == MEM) && (from == IMM))
+ 0XC0 * ((to == REG) && (from == IMM))));
build_constant ((from == IMM) && ! ((to == REG) && (destination == 0)), size);
place (! ((from == IMM) && (to == REG) && (destination == 0)),
(byte) (0x08 * (operation - REGULAR_BEGIN)
+ (destination & 0x07) * ((to == REG) && (from == IMM))
+ 0x01 * ((to == MEM) && (from == IMM) && (size == D8)) //
- 0x01 * ((to == REG) && (from == IMM) && (size != D8)) //
+ 0x01 * (size != D8)
+ 0x02 * ((to == REG) && (from == MEM))
+ 0x04 * ((to == MEM) && (from == IMM))
+ 0xc0 * ((to == REG) && (from == IMM))));
build_register_direction ((to == REG) && (from == REG),
destination, source);
@ -169,22 +159,25 @@ static void build_irregular (operation_index operation,
build_long_prefix (size == D64,
(to == REG) && (upper ((form) destination)), 0);
place (1, (byte) (0XF6
+ 0X08 * ((operation == INC) || (operation == DEC))
+ 0X01 * (size != D8)));
// 40>front
place ((size == D8) && (to == REG) && front (destination), (byte) 0x40);
place (to == REG, (byte) (0XC0
+ 0X08 * (operation - IRREGULAR_BEGIN))
+ 0X01 * (destination & 0X07));
place (1, (byte) (0xf7
+ 0x08 * ((operation == INC) || (operation == DEC))
- 0x01 * (size == D8)));
place (to == MEM, (byte) (0X05
+ 0X08 * (operation - IRREGULAR_BEGIN)));
place (to == REG, (byte) (0xc0
+ 0x08 * (operation - IRREGULAR_BEGIN))
+ 0x01 * (destination & 0x07));
place (to == MEM, (byte) (0x05
+ 0x08 * (operation - IRREGULAR_BEGIN)));
}
// SPECIAL_1_BEGIN-SPECIAL_1_END
static void build_special_1 (operation_index operation) {
const byte data [1 * SPECIAL_1_COUNT] = {
0X90, 0XC3, 0XCB, 0XC9, 0XF0, 0XF4
0x90, 0xc3, 0xcb, 0xc9, 0xf0, 0xf4
};
place (1, data [operation - SPECIAL_1_BEGIN]);
@ -193,8 +186,8 @@ static void build_special_1 (operation_index operation) {
// SPECIAL_2_BEGIN-SPECIAL_2_END
static void build_special_2 (operation_index operation) {
const byte data [2 * SPECIAL_2_COUNT] = {
0X0F, 0X0F, 0X0F, 0X0F, 0XF3, 0X0F,
0X34, 0X35, 0X05, 0X07, 0X90, 0XA2
0x0f, 0x0f, 0x0f, 0x0f, 0xf3, 0x0f,
0x34, 0x35, 0x05, 0x07, 0x90, 0xa2
};
place (1, data [operation - SPECIAL_2_BEGIN]);
@ -208,9 +201,9 @@ static void build_jump_if (operation_index operation,
/* */
(void) size; /* HIGHLY DEPENDS FOR FAR AND NEAR JUMPS! */
place (far (location), 0X0F); /* EVERYTHING IS FAR JUMP! */
place (far (location), (byte) (0X80 + operation - JUMP_IF_BEGIN));
place (near (location), (byte) (0X70 + operation - JUMP_IF_BEGIN));
place (far (location), 0x0f); /* EVERYTHING IS FAR JUMP! */
place (far (location), (byte) (0x80 + operation - JUMP_IF_BEGIN));
place (near (location), (byte) (0x70 + operation - JUMP_IF_BEGIN));
//~displacement (4, 0X12345678);
}
@ -229,8 +222,8 @@ static void build_move_if (operation_index operation,
(to == REG) && (upper ((form) destination)),
(from == REG) && (upper ((form) source)));
place (1, 0X0F);
place (1, (byte) (0X40 + operation - MOVE_IF_BEGIN));
place (1, 0x0f);
place (1, (byte) (0x40 + operation - MOVE_IF_BEGIN));
build_register_direction ((to == REG) && (from == REG),
destination, source);
@ -247,13 +240,13 @@ static void build_jump (size_index size,
/* */
place ((to == REG) && upper ((form) destination), (byte) 0X41);
place (to == REL, (byte) (0XE9 + 0X02 * (size == D8)));
place (to == REG, (byte) 0XFF);
place (to == REG, (byte) (0XE0 + 0X01 * (destination & 0X07)));
place (to == MEM, (byte) 0XFF);
place (to == MEM, (byte) 0X25);
place (to == REL, (byte) (0xe9 + 0x02 * (size == D8)));
place (to == REG, (byte) 0xff);
place (to == REG, (byte) (0xe0 + 0x01 * (destination & 0x07)));
place (to == MEM, (byte) 0xff);
place (to == MEM, (byte) 0x25);
//~displacement (to == MEM, 4, 0X12345678); // Keep when in mind!
//~displacement (to == MEM, 4, 0x12345678); // Keep when in mind!
}
// VERY FUCKING SPECIAL!
@ -269,29 +262,29 @@ static void build_move (size_index size,
(to == REG) && (upper ((form) destination)),
(from == REG) && (upper ((form) source)));
place ((to == REG) && (from == REG), (byte) (0X88 + (size != D8)));
place ((to == REG) && (from == MEM), (byte) (0X8A + (size != D8)));
place ((to == MEM) && (from == REG), (byte) (0X88 + (size != D8)));
place ((to == REG) && (from == REG), (byte) (0x88 + (size != D8)));
place ((to == REG) && (from == MEM), (byte) (0x8a + (size != D8)));
place ((to == MEM) && (from == REG), (byte) (0x88 + (size != D8)));
build_register_redirection ((to == REG) && (from == MEM), destination);
build_register_redirection ((to == MEM) && (from == REG), source);
place ((to == REG) && (from == IMM), (byte) (0XB0
+ 0X08 * (size != D8)
+ 0X01 * (destination & 0X07)));
place ((to == REG) && (from == IMM), (byte) (0xb8
+ 0x08 * (size != D8)
+ 0x01 * (destination & 0x07)));
place ((to == MEM) && (from == IMM), (byte) (0XC6 + (size != D8)));
place ((to == MEM) && (from == IMM), (byte) (0X05));
place ((to == MEM) && (from == IMM), (byte) (0xc6 + (size != D8)));
place ((to == MEM) && (from == IMM), (byte) (0x05));
print ((to == REG) && (from == MEM), D32, (next) ~0);
print ((to == REG) && (from == IMM), size, source);
print ((to == REG) && (from == IMM), D32, source);
print ((to == MEM) && (from == REG), D32, (next) ~0);
print ((to == MEM) && (from == IMM), D32, (next) ~0);
print ((to == MEM) && (from == IMM), size, source);
}
next token_count = 0;
byte * token_array = NULL;
next text_sector_size = 0;
byte * text_sector_byte = NULL;
int was_instruction_array_empty = 0;

6
source/assembler.h
View File

@ -16,6 +16,8 @@ typedef enum {
} type_index;
typedef enum {
XDCL, XLBL, XRPT, XLCT,
/* HIGHLY EXPERIMENTAL CODE ABOVE... */
ADD, OR, ADC, SBB,
AND, SUB, XOR, CMP,
/* */
@ -62,8 +64,8 @@ typedef enum {
R12, R13, R14, R15,
} operand_index;
extern next token_count;
extern byte * token_array;
extern next text_sector_size;
extern byte * text_sector_byte;
extern int was_instruction_array_empty;

43
source/main.c
View File

@ -10,6 +10,7 @@ static void dump (const char * file_name);
#include "eaxhla.yy.h"
#include "eaxhla.tab.h"
#include "assembler.h"
#include "unix.h"
extern void yyfree_leftovers(void);
@ -21,7 +22,7 @@ signed main(int argc, char * argv[]) {
return 1;
}
token_array = calloc (1440UL, sizeof (* token_array));
text_sector_byte = calloc (1440UL, sizeof (* text_sector_byte));
t_array = calloc (1440UL, sizeof (* t_array));
#if DEBUG == 1
@ -52,43 +53,29 @@ signed main(int argc, char * argv[]) {
eaxhla_destroy();
free (token_array);
free (text_sector_byte);
free (t_array);
return has_encountered_error;
}
void dump (const char * file_name) {
/* DO NOT TRY THIS AT HOME! */
#define hackery \
"\x7F\x45\x4C\x46\x02\x01\x01\x03"\
"\x00\x00\x00\x00\x00\x00\x00\x00"\
"\x02\x00\x3E\x00\x01\x00\x00\x00"\
"\xB0\x00\x40\x00\x00\x00\x00\x00"\
"\x40\x00\x00\x00\x00\x00\x00\x00"\
"\x00\x00\x00\x00\x00\x00\x00\x00"\
"\x00\x00\x00\x00\x40\x00\x38\x00"\
"\x02\x00\x40\x00\x00\x00\x00\x00"\
"\x01\x00\x00\x00\x05\x00\x00\x00"\
"\x00\x00\x00\x00\x00\x00\x00\x00"\
"\x00\x00\x40\x00\x00\x00\x00\x00"\
"\x00\x00\x40\x00\x00\x00\x00\x00"\
"\xC5\x00\x00\x00\x00\x00\x00\x00"\
"\xC5\x00\x00\x00\x00\x00\x00\x00"\
"\x00\x10\x00\x00\x00\x00\x00\x00"\
"\x01\x00\x00\x00\x06\x00\x00\x00"\
"\xC5\x00\x00\x00\x00\x00\x00\x00"\
"\xC5\x10\x40\x00\x00\x00\x00\x00"\
"\xC5\x10\x40\x00\x00\x00\x00\x00"\
"\x0C\x00\x00\x00\x00\x00\x00\x00"\
"\x0C\x00\x00\x00\x00\x00\x00\x00"\
"\x00\x10\x00\x00\x00\x00\x00\x00"
elf_main_header (1, 1, 1, 0);
elf_text_sector (34);
elf_data_sector (34, 12);
char meme [1024] = "";
FILE * file = fopen (file_name, "w");
fwrite (hackery, 1UL, 64UL + 2UL * 56UL, file);
fwrite (token_array, sizeof (* token_array), (size_t) token_count, file);
fwrite (elf_main_header_byte, 1UL, ELF_MAIN_HEADER_SIZE, file);
fwrite (elf_text_sector_byte, 1UL, ELF_TEXT_SECTOR_SIZE, file);
fwrite (elf_data_sector_byte, 1UL, ELF_DATA_SECTOR_SIZE, file);
//text
fwrite (text_sector_byte, sizeof (* text_sector_byte),
(size_t) text_sector_size, file);
// data
fwrite ("heyo world!\n", 1UL, 12UL, file);
snprintf (meme, 1023UL, "chmod +x %s", file_name);

70
source/unix.c Normal file
View File

@ -0,0 +1,70 @@
#include "unix.h"
uint8_t elf_main_header_byte [ELF_MAIN_HEADER_SIZE] = {
0X7F, 0X45, 0X4C, 0X46, 0X02, 0X01, 0X01, 0X03,
0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
0X02, 0X00, 0X3E, 0X00, 0X01, 0X00, 0X00, 0X00,
0XB0, 0X00, 0X40, 0X00, 0X00, 0X00, 0X00, 0X00, // entry_point
0X40, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
0X00, 0X00, 0X00, 0X00, 0X40, 0X00, 0X38, 0X00,
0X02, 0X00, 0X40, 0X00, 0X00, 0X00, 0X00, 0X00,
};
uint8_t elf_text_sector_byte [ELF_TEXT_SECTOR_SIZE] = {
0X01, 0X00, 0X00, 0X00, 0X05, 0X00, 0X00, 0X00,
0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
0X00, 0X00, 0X40, 0X00, 0X00, 0X00, 0X00, 0X00,
0X00, 0X00, 0X40, 0X00, 0X00, 0X00, 0X00, 0X00,
0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, // HDR + TXT
0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, // HDR + TXT
0X00, 0X10, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
};
uint8_t elf_data_sector_byte [ELF_DATA_SECTOR_SIZE] = {
0X01, 0X00, 0X00, 0X00, 0X06, 0X00, 0X00, 0X00,
0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, // HDR + TXT
0X00, 0X10, 0X40, 0X00, 0X00, 0X00, 0X00, 0X00, // +++ ^
0X00, 0X10, 0X40, 0X00, 0X00, 0X00, 0X00, 0X00, // +++ ^
0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, // DAT
0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, // DAT
0X00, 0X10, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00,
};
void elf_main_header (uint8_t has_program,
uint8_t for_linux,
uint8_t for_x86_64,
uint64_t entry_point) {
/* */
uint64_t enter = entry_point; // TEST
elf_main_header_byte [16] = (has_program) ? 0x02 : 0x03; // library
elf_main_header_byte [ 7] = (for_linux) ? 0x03 : 0x00; // system v
elf_main_header_byte [18] = (for_x86_64) ? 0x3e : 0x00;
if (entry_point != 0) {
memcpy (& elf_main_header_byte [24], & enter, sizeof (enter));
}
}
void elf_text_sector (uint64_t text_size) {
/* */
uint64_t text = ELF_HEADER_SIZE + text_size; // TEST
memcpy (& elf_text_sector_byte [32], & text, sizeof (text));
memcpy (& elf_text_sector_byte [40], & text, sizeof (text));
}
void elf_data_sector (uint64_t text_size,
uint64_t data_size) {
/* */
uint64_t data = data_size; // TEST
uint64_t core = ELF_HEADER_SIZE + text_size;
uint64_t move = 0x401000 + core;
memcpy (& elf_data_sector_byte [ 8], & core, sizeof (core));
memcpy (& elf_data_sector_byte [16], & move, sizeof (move));
memcpy (& elf_data_sector_byte [24], & move, sizeof (move));
memcpy (& elf_data_sector_byte [32], & data, sizeof (data));
memcpy (& elf_data_sector_byte [40], & data, sizeof (data));
}

29
source/unix.h Normal file
View File

@ -0,0 +1,29 @@
#ifndef UNIX_H
#include <stdint.h>
#include <string.h>
#define ELF_MAIN_HEADER_SIZE (0x40)
#define ELF_TEXT_SECTOR_SIZE (0x38)
#define ELF_DATA_SECTOR_SIZE (0x38)
#define ELF_HEADER_SIZE (ELF_MAIN_HEADER_SIZE \
+ ELF_TEXT_SECTOR_SIZE \
+ ELF_DATA_SECTOR_SIZE)
extern uint8_t elf_main_header_byte [ELF_MAIN_HEADER_SIZE];
extern uint8_t elf_text_sector_byte [ELF_TEXT_SECTOR_SIZE];
extern uint8_t elf_data_sector_byte [ELF_DATA_SECTOR_SIZE];
extern void elf_main_header (uint8_t has_program,
uint8_t for_linux,
uint8_t for_x86_64,
uint64_t entry_point);
extern void elf_text_sector (uint64_t text_size);
extern void elf_data_sector (uint64_t text_size,
uint64_t data_size);
#define UNIX_H
#endif

19
test/heyo.asm Normal file
View File

@ -0,0 +1,19 @@
format ELF64 executable 3
segment readable executable
entry $
mov eax, 1
mov edi, 1
mov esi, heyo
mov edx, 12
syscall
mov eax, 60
mov edi, 0
syscall
segment readable writable
heyo: db "heyo world!", 10

47
test/heyo.eax Normal file
View File

@ -0,0 +1,47 @@
program heyo_world
begin
mov eax 1
mov edi 1
mov esi 4198610
mov edx 12
syscall
mov eax 60
mov edi 0
syscall
end program
/*
7F 45 4C 46 02 01 01 03
00 00 00 00 00 00 00 00
02 00 3E 00 01 00 00 00
B0 00 40 00 00 00 00 00
40 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 40 00 38 00
02 00 40 00 00 00 00 00
01 00 00 00 05 00 00 00
00 00 00 00 00 00 00 00
00 00 40 00 00 00 00 00
00 00 40 00 00 00 00 00
22 00 00 00 00 00 00 00
22 00 00 00 00 00 00 00
00 10 00 00 00 00 00 00
01 00 00 00 06 00 00 00
D2 00 00 00 00 00 00 00
D2 10 40 00 00 00 00 00
D2 10 40 00 00 00 00 00
0C 00 00 00 00 00 00 00
0C 00 00 00 00 00 00 00
00 10 00 00 00 00 00 00
B0 01 00 00 00 B7 01 00 00 00 B6 D2 10 40 00 B2 0C 00 00 00
0F 05 B0 3C 00 00 00 B7 00 00 00 00 0F 05
68 65 79 6F 20 77 6F 72 6C 64 21 0A
*/

22
test/heyo_world.eax
View File

@ -1,15 +1,13 @@
program heyo_world
s8 <12> message "Heyo world!\n" // AVAR D8 12 ...
begin // DECL 0XFFFFFFFFU
begin
mov eax 1 // MOV D32 REG R0 IMM 1
mov edi 1 // MOV D32 REG R7 IMM 1
mov esi message // MOV D32 REG R6 MEM 0 [message]
mov edx 12 // MOV D32 REG R2 IMM 12
syscall // SYSCALL
mov eax 1
mov edi 1
mov esi 4198610
mov edx 12
syscall
mov eax 60
mov edi 0
syscall
end program
end program // MOV D64 REG R0 IMM 0X3CU
// MOV D64 REG R7 IMM 0X0U
// SYSCALL

43
tool/flatten.c
View File

@ -4,15 +4,19 @@ static char * fa [] = {
"add", "or", "adc", "sbb", "and", "sub", "xor", "cmp"
};
static char * faa [] = {
"inc", "dec", "not", "neg", "mul", "imul", "div", "idiv"
};
static char * fr [] = {
"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
"r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d",
"al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
"r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b",
"ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
"r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w",
"al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
"r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
"r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d",
"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
};
static char * fm [] = {
@ -20,7 +24,7 @@ static char * fm [] = {
};
static char * fi [] = {
"11h", "1122h", "11223344h", "1122334455667788h",
"11h", "1122h", "11223344h", "11223344h"
};
int main (void) {
@ -33,6 +37,7 @@ int main (void) {
printf ("nop\n");
printf ("nop\n");
// INR REG REG
for (a = 0; a < (int) (sizeof (fa) / sizeof (* fa)); ++a) {
for (w = 0; w < 4; ++w) {
for (d = 0; d < 16; ++d) {
@ -44,15 +49,23 @@ int main (void) {
}
}
//~a = 0;
//~w = 3;
// INR REG IMM
for (a = 0; a < (int) (sizeof (fa) / sizeof (* fa)); ++a) {
for (d = 0; d < 64; ++d) {
printf ("nop\n");
printf ("%s %s, %s\n", fa [a], fr [d], fi [d / 16]);
}
}
//~for (d = 0; d < 16; ++d) {
//~for (s = 0; s < 16; ++s) {
//~printf ("nop\n");
//~printf ("%s %s, %s\n", fa [a], fr [d + 16 * w], fr [s + 16 * w]);
//~}
//~}
// INI REG
for (a = 0; a < (int) (sizeof (faa) / sizeof (* faa)); ++a) {
for (w = 0; w < 4; ++w) {
for (d = 0; d < 16; ++d) {
printf ("nop\n");
printf ("%s %s\n", faa [a], fr [d + 16 * w]);
}
}
}
printf ("nop\n");
printf ("nop\n");

166
tool/heyo.asm
View File

@ -4,16 +4,182 @@ segment readable executable
entry $
fff:
nop
mov eax, 1
nop
mov edi, 1
nop
mov esi, heyo
nop
mov edx, 12
nop
syscall
nop
nop
nop
mov eax, 1
nop
mov edi, 1
nop
mov esi, cyaa
nop
mov edx, 12
nop
syscall
nop
nop
nop
mov eax, 1
nop
mov edi, 1
nop
mov esi, neko
nop
mov edx, 12
nop
syscall
nop
nop
nop
mov rax, 1122334455667788h
nop
mov rcx, 1122334455667788h
nop
mov rdx, 1122334455667788h
nop
mov rbx, 1122334455667788h
nop
mov rsp, 1122334455667788h
nop
mov rbp, 1122334455667788h
nop
mov rsi, 1122334455667788h
nop
mov rdi, 1122334455667788h
nop
mov r8, 1122334455667788h
nop
mov r9, 1122334455667788h
nop
mov r10, 1122334455667788h
nop
mov r11, 1122334455667788h
nop
mov r12, 1122334455667788h
nop
mov r13, 1122334455667788h
nop
mov r14, 1122334455667788h
nop
mov r15, 1122334455667788h
nop
nop
nop
mov eax, 60
nop
mov edi, 0
nop
syscall
nop
jmp fff
nop
jmp nnn
nop
nop
nop
nnn:
segment readable writable
heyo: db "heyo world!", 10
cyaa: db "cyaa world!", 10
neko: db "neko world!", 10
;~176 / 00B0 ; header
;~504 / 01F8 ; executable
;~292 / 0124 ; readable
;~36 / 0024 ; writable
;~328 / 0148 ; executable - header
;~7F_45_4C_46_02_01_01_03_
;~00_00_00_00_00_00_00_00_ ; 0
;~02_00_3E_00_01_00_00_00_
;~B0_00_40_00_00_00_00_00_ ; header + hardcore
;~40_00_00_00_00_00_00_00_
;~00_00_00_00_00_00_00_00_ ; 0
;~00_00_00_00_40_00_38_00_
;~02_00_40_00_00_00_00_00_
;~01_00_00_00_05_00_00_00_ ; text
;~00_00_00_00_00_00_00_00_ ; 0
;~00_00_40_00_00_00_00_00_ ; hardcore
;~00_00_40_00_00_00_00_00_ ; hardcore
;~D4_01_00_00_00_00_00_00_ ; executable - writable
;~D4_01_00_00_00_00_00_00_ ; executable - writable
;~00_10_00_00_00_00_00_00_ ; softcore
;~01_00_00_00_06_00_00_00_ ; data
;~D4_01_00_00_00_00_00_00_ ; executable - writable
;~D4_11_40_00_00_00_00_00_ ; hardcore + softcore + executable - writable
;~D4_11_40_00_00_00_00_00_ ; hardcore + softcore + executable - writable
;~24_00_00_00_00_00_00_00_ ; writable
;~24_00_00_00_00_00_00_00_ ; writable
;~00_10_00_00_00_00_00_00_ ; softcore
;~90_B8_01_00_00_00_
;~90_BF_01_00_00_00_
;~90_BE_D4_11_40_00_
;~90_BA_0C_00_00_00_
;~90_0F_05_
;~90_
;~90_
;~90_B8_01_00_00_00_
;~90_BF_01_00_00_00_
;~90_BE_E0_11_40_00_
;~90_BA_0C_00_00_00_
;~90_0F_05_
;~90_
;~90_
;~90_B8_01_00_00_00_
;~90_BF_01_00_00_00_
;~90_BE_EC_11_40_00_
;~90_BA_0C_00_00_00_
;~90_0F_05_
;~90_
;~90_
;~90_48_B8_88_77_66_55_44_33_22_11_
;~90_48_B9_88_77_66_55_44_33_22_11_
;~90_48_BA_88_77_66_55_44_33_22_11_
;~90_48_BB_88_77_66_55_44_33_22_11_
;~90_48_BC_88_77_66_55_44_33_22_11_
;~90_48_BD_88_77_66_55_44_33_22_11_
;~90_48_BE_88_77_66_55_44_33_22_11_
;~90_48_BF_88_77_66_55_44_33_22_11_
;~90_49_B8_88_77_66_55_44_33_22_11_
;~90_49_B9_88_77_66_55_44_33_22_11_
;~90_49_BA_88_77_66_55_44_33_22_11_
;~90_49_BB_88_77_66_55_44_33_22_11_
;~90_49_BC_88_77_66_55_44_33_22_11_
;~90_49_BD_88_77_66_55_44_33_22_11_
;~90_49_BE_88_77_66_55_44_33_22_11_
;~90_49_BF_88_77_66_55_44_33_22_11_
;~90_
;~90_
;~90_B8_3C_00_00_00_
;~90_BF_00_00_00_00_
;~90_0F_05_
;~90_E9_E2_FE_FF_FF_
;~90_EB_03_
;~90_
;~90_
;~90_
;~68_65_79_6F_20_77_6F_72_6C_64_21_0A_
;~63_79_61_61_20_77_6F_72_6C_64_21_0A_
;~6E_65_6B_6F_20_77_6F_72_6C_64_21_0A_

51
tool/heyo_object.asm
View File

@ -6,15 +6,66 @@ section '.text' executable
_start:
fff:
nop
mov eax, 1
nop
mov edi, 1
nop
mov esi, heyo
nop
mov edx, 12
nop
syscall
nop
nop
nop
mov rax, 1122334455667788h
nop
mov rcx, 1122334455667788h
nop
mov rdx, 1122334455667788h
nop
mov rbx, 1122334455667788h
nop
mov rsp, 1122334455667788h
nop
mov rbp, 1122334455667788h
nop
mov rsi, 1122334455667788h
nop
mov rdi, 1122334455667788h
nop
mov r8, 1122334455667788h
nop
mov r9, 1122334455667788h
nop
mov r10, 1122334455667788h
nop
mov r11, 1122334455667788h
nop
mov r12, 1122334455667788h
nop
mov r13, 1122334455667788h
nop
mov r14, 1122334455667788h
nop
mov r15, 1122334455667788h
nop
nop
nop
mov eax, 60
nop
mov edi, 0
nop
syscall
nop
jmp fff
nop
nop
nop
section '.data' writable

9216
tool/include.txt Normal file
View File

File diff suppressed because it is too large Load Diff

8
tool/test.c
View File

@ -11,15 +11,15 @@ static unsigned int array [] = {
int main (void) {
unsigned int index;
token_array = malloc (1024UL * 1024UL * sizeof (* token_array));
text_sector_byte = malloc (1024UL * 1024UL * sizeof (* text_sector_byte));
assemble ((unsigned int) (sizeof (array) / sizeof (array [0])), array);
for (index = 0; index < token_count; ++index) {
printf ("%c%02X", (token_array [index] == 0x90) ? '\n' : ' ', token_array [index]);
for (index = 0; index < text_sector_size; ++index) {
printf ("%c%02X", (text_sector_byte [index] == 0x90) ? '\n' : ' ', text_sector_byte [index]);
}
free (token_array);
free (text_sector_byte);
return (0);
}

5
tool/test.sh
View File

@ -2,6 +2,9 @@
set -xe
diff -s -y -t --color=auto flatten.txt xlatten.txt
#~diff -y -W 40 --ignore-trailing-space --ignore-blank-lines --suppress-common-lines --color=always flatten.txt xlatten.txt
#~diff -y -W 40 --ignore-trailing-space --ignore-blank-lines --color=always flatten.txt xlatten.txt
#~diff -y flatten.txt xlatten.txt
diff flatten.txt xlatten.txt
exit

10
tool/xfat.c
View File

@ -13,11 +13,11 @@
"};\n" \
"int main (void) {\n" \
" unsigned int index;\n" \
" token_array = malloc (144UL * sizeof (* token_array));\n" \
" text_sector_byte = malloc (144UL * sizeof (* text_sector_byte));\n" \
" assemble ((unsigned int) (sizeof (array) / sizeof (array [0])), array);\n" \
" for (index = 0; index < token_count; ++index)\n" \
" printf (\"%02X \", token_array [index]);\n" \
" free (token_array);\n" \
" for (index = 0; index < text_sector_size; ++index)\n" \
" printf (\"%02X \", text_sector_byte [index]);\n" \
" free (text_sector_byte);\n" \
" return (0);\n" \
"}\n"
@ -37,7 +37,7 @@ int main (int argc, char * * argv) {
file = file_close (file);
execute ("cat x.c && gcc x.c && ./a.out && echo -- && rm a.out x.c");
execute ("gcc x.c && ./a.out && echo -- && rm a.out x.c");
return (log_success);
}

29
tool/xlatten.c
View File

@ -1,20 +1,24 @@
#include <stdio.h>
static char * fw [] = {
"D64", "D32", "D16", "D8"
"D8", "D16", "D32", "D64"
};
static char * fa [] = {
"ADD", "OR", "ADC", "SBB", "AND", "SUB", "XOR", "CMP"
};
static char * faa [] = {
"INC", "DEC", "NOT", "NEG", "UMUL", "IMUL", "UDIV", "IDIV"
};
static char * fr [] = {
"REG, R0", "REG, R1", "REG, R2", "REG, R3", "REG, R4", "REG, R5", "REG, R6", "REG, R7",
"REG, R8", "REG, R9", "REG, R10", "REG, R11", "REG, R12", "REG, R13", "REG, R14", "REG, R15"
};
static char * fi [] = {
"0x11", "0x1122", "0x11223344", "0x1122334455667788",
"IMM, 0x11", "IMM, 0x1122", "IMM, 0x11223344", "IMM, 0x11223344"
};
int main (void) {
@ -30,14 +34,21 @@ int main (void) {
}
}
//~a = 0;
//~w = 3;
for (a = 0; a < (int) (sizeof (fa) / sizeof (* fa)); ++a) {
for (w = 0; w < 4; ++w) {
for (d = 0; d < 16; ++d) {
printf ("NOP, %s, %s, %s, %s,\n", fa [a], fw [w], fr [d], fi [w]);
}
}
}
//~for (d = 0; d < 16; ++d) {
//~for (s = 0; s < 16; ++s) {
//~printf ("NOP, %s, %s, %s, %s,\n", fa [a], fw [w], fr [d], fr [s]);
//~}
//~}
for (a = 0; a < (int) (sizeof (faa) / sizeof (* faa)); ++a) {
for (w = 0; w < 4; ++w) {
for (d = 0; d < 16; ++d) {
printf ("NOP, %s, %s, %s,\n", faa [a], fw [w], fr [d]);
}
}
}
return (0);
}