├── LICENSE
├── README.md
├── aarch64
    ├── ELF-aarch64-debug.hex2
    ├── ELF-aarch64.hex2
    ├── aarch64_defs.M1
    ├── libc-core.M1
    ├── libc-full.M1
    └── linux
    │   ├── bootstrap.c
    │   ├── fcntl.c
    │   ├── sys
    │       └── stat.c
    │   └── unistd.c
├── amd64
    ├── ELF-amd64-debug.hex2
    ├── ELF-amd64.hex2
    ├── amd64_defs.M1
    ├── libc-core.M1
    ├── libc-full.M1
    ├── linux
    │   ├── bootstrap.c
    │   ├── fcntl.c
    │   ├── sys
    │   │   └── stat.c
    │   └── unistd.c
    └── uefi
    │   ├── PE32-amd64.hex2
    │   ├── bootstrap.c
    │   ├── libc-core.M1
    │   └── libc-full.M1
├── armv7l
    ├── ELF-armv7l-debug.hex2
    ├── ELF-armv7l.hex2
    ├── armv7l_defs.M1
    ├── libc-core.M1
    ├── libc-full.M1
    └── linux
    │   ├── bootstrap.c
    │   ├── fcntl.c
    │   ├── sys
    │       └── stat.c
    │   └── unistd.c
├── bootstrappable.c
├── bootstrappable.h
├── ctype.c
├── ctype.h
├── fcntl.c
├── fcntl.h
├── gcc_req.h
├── iso646.h
├── knight
    ├── ELF-knight.hex2
    ├── knight-native_defs.M1
    ├── knight_defs.M1
    ├── libc-core.M1
    ├── libc-full.M1
    ├── libc-native-file.M1
    ├── libc-native.M1
    ├── linux
    │   ├── bootstrap.c
    │   ├── fcntl.c
    │   ├── sys
    │   │   └── stat.c
    │   └── unistd.c
    └── native
    │   ├── bootstrap.c
    │   ├── fcntl.c
    │   ├── sys
    │       └── stat.c
    │   └── unistd.c
├── riscv32
    ├── ELF-riscv32-debug.hex2
    ├── ELF-riscv32.hex2
    ├── libc-core.M1
    ├── libc-full.M1
    ├── linux
    │   ├── bootstrap.c
    │   ├── fcntl.c
    │   ├── sys
    │   │   └── stat.c
    │   └── unistd.c
    └── riscv32_defs.M1
├── riscv64
    ├── ELF-riscv64-debug.hex2
    ├── ELF-riscv64.hex2
    ├── libc-core.M1
    ├── libc-full.M1
    ├── linux
    │   ├── bootstrap.c
    │   ├── fcntl.c
    │   ├── sys
    │   │   └── stat.c
    │   └── unistd.c
    └── riscv64_defs.M1
├── signal.h
├── stdarg.h
├── stdbool.h
├── stddef.h
├── stdint.h
├── stdio.c
├── stdio.h
├── stdlib.c
├── stdlib.h
├── stdnoreturn.h
├── string.c
├── string.h
├── sys
    ├── stat.h
    ├── types.h
    ├── utsname.h
    └── wait.h
├── uefi
    ├── fcntl.c
    ├── string_p.h
    ├── sys
    │   └── stat.c
    ├── uefi.c
    └── unistd.c
├── unistd.h
└── x86
    ├── ELF-x86-debug.hex2
    ├── ELF-x86.hex2
    ├── libc-core.M1
    ├── libc-full.M1
    ├── linux
        ├── bootstrap.c
        ├── fcntl.c
        ├── sys
        │   └── stat.c
        └── unistd.c
    └── x86_defs.M1


/README.md:
--------------------------------------------------------------------------------
1 | Inside is a standard C library for those who need to bootstrap from nothing.
2 | As all of the pieces inside will work with M2-Planet and mescc-tools


--------------------------------------------------------------------------------
/aarch64/ELF-aarch64-debug.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### Copyright (C) 2020 deesix <deesix@tuta.io>
 4 | ### This file is part of M2-Planet.
 5 | ###
 6 | ### M2-Planet is free software: you can redistribute it and/or modify
 7 | ### it under the terms of the GNU General Public License as published by
 8 | ### the Free Software Foundation, either version 3 of the License, or
 9 | ### (at your option) any later version.
10 | ###
11 | ### M2-Planet is distributed in the hope that it will be useful,
12 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | ### GNU General Public License for more details.
15 | ###
16 | ### You should have received a copy of the GNU General Public License
17 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
18 | 
19 | ### stage0's hex2 format
20 | ###    !<label>          1 byte relative
21 | ###    $<label>          2 byte address
22 | ###    @<label>          2 byte relative
23 | ###    &<label>          4 byte address
24 | ###    %<label>          4 byte relative
25 | 
26 | ### if you wish to use this header, you need to add :ELF_end to the end of your
27 | ### M1 or hex2 files.
28 | 
29 | ## ELF Header
30 | 
31 | :ELF_base
32 | 7F 45 4C 46                               # e_ident[EI_MAG0-3] ELF's magic number
33 | 
34 | 02                                        # e_ident[EI_CLASS] Indicating 64 bit
35 | 01                                        # e_ident[EI_DATA] Indicating little endianness
36 | 01                                        # e_ident[EI_VERSION] Indicating original elf
37 | 
38 | 03                                        # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
39 | 00                                        # e_ident[EI_ABIVERSION] See above
40 | 
41 | 00 00 00 00 00 00 00                      # e_ident[EI_PAD]
42 | 
43 | 02 00                                     # e_type Indicating Executable
44 | B7 00                                     # e_machine Indicating AArch64
45 | 01 00 00 00                               # e_version Indicating original elf
46 | 
47 | &_start 00 00 00 00                       # e_entry Address of the entry point
48 | %ELF_program_headers>ELF_base 00 00 00 00 # e_phoff Address of program header table
49 | %ELF_section_headers>ELF_base 00 00 00 00 # e_shoff Address of section header table
50 | 
51 | 00 00 00 00                               # e_flags
52 | 
53 | 40 00                                     # e_ehsize Indicating our 64 Byte header
54 | 
55 | 38 00                                     # e_phentsize size of a program header table
56 | 01 00                                     # e_phnum number of entries in program table
57 | 
58 | 40 00                                     # e_shentsize size of a section header table
59 | 05 00                                     # e_shnum number of entries in section table
60 | 
61 | 02 00                                     # e_shstrndx index of the section names
62 | 
63 | 
64 | :ELF_program_headers
65 | :ELF_program_header__text
66 | 01 00 00 00                               # ph_type: PT-LOAD = 1
67 | 07 00 00 00                               # ph_flags: PF-X|PF-W|PF-R = 7
68 | 00 00 00 00 00 00 00 00                   # ph_offset
69 | &ELF_base 00 00 00 00                     # ph_vaddr
70 | &ELF_base 00 00 00 00                     # ph_physaddr
71 | %ELF_end>ELF_base 00 00 00 00             # ph_filesz
72 | %ELF_end>ELF_base 00 00 00 00             # ph_memsz
73 | 01 00 00 00 00 00 00 00                   # ph_align
74 | 
75 | :ELF_text
76 | 


--------------------------------------------------------------------------------
/aarch64/ELF-aarch64.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### Copyright (C) 2020 deesix <deesix@tuta.io>
 4 | ### This file is part of M2-Planet.
 5 | ###
 6 | ### M2-Planet is free software: you can redistribute it and/or modify
 7 | ### it under the terms of the GNU General Public License as published by
 8 | ### the Free Software Foundation, either version 3 of the License, or
 9 | ### (at your option) any later version.
10 | ###
11 | ### M2-Planet is distributed in the hope that it will be useful,
12 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
13 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 | ### GNU General Public License for more details.
15 | ###
16 | ### You should have received a copy of the GNU General Public License
17 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
18 | 
19 | ### stage0's hex2 format
20 | ###    !<label>          1 byte relative
21 | ###    $<label>          2 byte address
22 | ###    @<label>          2 byte relative
23 | ###    &<label>          4 byte address
24 | ###    %<label>          4 byte relative
25 | 
26 | ### if you wish to use this header, you need to add :ELF_end to the end of your
27 | ### M1 or hex2 files.
28 | 
29 | ## ELF Header
30 | 
31 | :ELF_base
32 | 7F 45 4C 46                               # e_ident[EI_MAG0-3] ELF's magic number
33 | 
34 | 02                                        # e_ident[EI_CLASS] Indicating 64 bit
35 | 01                                        # e_ident[EI_DATA] Indicating little endianness
36 | 01                                        # e_ident[EI_VERSION] Indicating original elf
37 | 
38 | 03                                        # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
39 | 00                                        # e_ident[EI_ABIVERSION] See above
40 | 
41 | 00 00 00 00 00 00 00                      # e_ident[EI_PAD]
42 | 
43 | 02 00                                     # e_type Indicating Executable
44 | B7 00                                     # e_machine Indicating AArch64
45 | 01 00 00 00                               # e_version Indicating original elf
46 | 
47 | &_start 00 00 00 00                       # e_entry Address of the entry point
48 | %ELF_program_headers>ELF_base 00 00 00 00 # e_phoff Address of program header table
49 | 00 00 00 00 00 00 00 00                   # e_shoff Address of section header table
50 | 
51 | 00 00 00 00                               # e_flags
52 | 
53 | 40 00                                     # e_ehsize Indicating our 64 Byte header
54 | 
55 | 38 00                                     # e_phentsize size of a program header table
56 | 01 00                                     # e_phnum number of entries in program table
57 | 
58 | 00 00                                     # e_shentsize size of a section header table
59 | 00 00                                     # e_shnum number of entries in section table
60 | 
61 | 00 00                                     # e_shstrndx index of the section names
62 | 
63 | 
64 | :ELF_program_headers
65 | :ELF_program_header__text
66 | 01 00 00 00                               # ph_type: PT-LOAD = 1
67 | 07 00 00 00                               # ph_flags: PF-X|PF-W|PF-R = 7
68 | 00 00 00 00 00 00 00 00                   # ph_offset
69 | &ELF_base 00 00 00 00                     # ph_vaddr
70 | &ELF_base 00 00 00 00                     # ph_physaddr
71 | %ELF_end>ELF_base 00 00 00 00             # ph_filesz
72 | %ELF_end>ELF_base 00 00 00 00             # ph_memsz
73 | 01 00 00 00 00 00 00 00                   # ph_align
74 | 
75 | :ELF_text
76 | 


--------------------------------------------------------------------------------
/aarch64/libc-core.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2020 deesix <deesix@tuta.io>
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 	INIT_SP
19 | 	LDR_X0_[SP]
20 | 	ADD_X1_SP_8
21 | 	SET_BP_FROM_SP
22 | 	PUSH_X0
23 | 	PUSH_X1
24 | 	SET_X1_TO_2
25 | 	ADD_X0_X1_X0
26 | 	SET_X1_TO_8
27 | 	MUL_X0_X1_X0
28 | 	ADD_X0_BP_X0
29 | 	PUSH_X0
30 | 
31 | 	LOAD_W16_AHEAD
32 | 	SKIP_32_DATA
33 | 	&FUNCTION_main
34 | 	BLR_X16
35 | 
36 | 	POP_X1
37 | 	POP_X1
38 | 	POP_X1
39 | 	PUSH_X0                     ; Put return on the stack
40 | 	PUSH_X0                     ; So that _exit has it
41 | 	PUSH_X0                     ; So that _exit has it
42 | 
43 | :FUNCTION_exit
44 | :FUNCTION__exit
45 | 	SET_X0_FROM_BP
46 | 	SUB_X0_8
47 | 	DEREF_X0
48 | 	SET_X8_TO_SYS_EXIT
49 | 	SYSCALL
50 | 


--------------------------------------------------------------------------------
/aarch64/libc-full.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2020 deesix <deesix@tuta.io>
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 	INIT_SP
19 | 	LDR_X0_[SP]
20 | 	ADD_X1_SP_8
21 | 	SET_BP_FROM_SP
22 | 	PUSH_X0
23 | 	PUSH_X1
24 | 	SET_X1_TO_2
25 | 	ADD_X0_X1_X0
26 | 	SET_X1_TO_8
27 | 	MUL_X0_X1_X0
28 | 	ADD_X0_BP_X0
29 | 	PUSH_X0
30 | 
31 | 	;; Setup for _envp
32 | 	LOAD_W1_AHEAD
33 | 	SKIP_32_DATA
34 | 	&GLOBAL__envp
35 | 	STR_X0_[X1]
36 | 
37 | 	;; Setup for malloc
38 | 	LOAD_W16_AHEAD
39 | 	SKIP_32_DATA
40 | 	&FUNCTION___init_malloc
41 | 	BLR_X16
42 | 
43 | 	;; Setup for FILE*
44 | 	LOAD_W16_AHEAD
45 | 	SKIP_32_DATA
46 | 	&FUNCTION___init_io
47 | 	BLR_X16
48 | 
49 | 	;; Call main
50 | 	LOAD_W16_AHEAD
51 | 	SKIP_32_DATA
52 | 	&FUNCTION_main
53 | 	BLR_X16
54 | 
55 | 	POP_X1
56 | 	POP_X1
57 | 	POP_X1
58 | 	PUSH_X0                     ; Put return on the stack
59 | 	PUSH_X0                     ; So that _exit has it
60 | 	PUSH_X0                     ; So that _exit has it
61 | 
62 | :FUNCTION_exit
63 | 	LOAD_W16_AHEAD
64 | 	SKIP_32_DATA
65 | 	&FUNCTION___kill_io
66 | 	BLR_X16
67 | 
68 | :FUNCTION__exit
69 | 	SET_X0_FROM_BP
70 | 	SUB_X0_8
71 | 	DEREF_X0
72 | 	SET_X8_TO_SYS_EXIT
73 | 	SYSCALL
74 | 
75 | :GLOBAL__envp
76 | 	NULL
77 | 


--------------------------------------------------------------------------------
/aarch64/linux/bootstrap.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * Copyright (C) 2020 deesix <deesix@tuta.io>
  3 |  * This file is part of M2-Planet.
  4 |  *
  5 |  * M2-Planet is free software: you can redistribute it and/or modify
  6 |  * it under the terms of the GNU General Public License as published by
  7 |  * the Free Software Foundation, either version 3 of the License, or
  8 |  * (at your option) any later version.
  9 |  *
 10 |  * M2-Planet is distributed in the hope that it will be useful,
 11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |  * GNU General Public License for more details.
 14 |  *
 15 |  * You should have received a copy of the GNU General Public License
 16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 17 |  */
 18 | 
 19 | enum
 20 | {
 21 | 	stdin = 0,
 22 | 	stdout = 1,
 23 | 	stderr = 2,
 24 | };
 25 | 
 26 | enum
 27 | {
 28 | 	EOF = 0xFFFFFFFF,
 29 | 	NULL = 0,
 30 | };
 31 | 
 32 | enum
 33 | {
 34 | 	EXIT_FAILURE = 1,
 35 | 	EXIT_SUCCESS = 0,
 36 | };
 37 | 
 38 | enum
 39 | {
 40 | 	TRUE = 1,
 41 | 	FALSE = 0,
 42 | };
 43 | 
 44 | 
 45 | int fgetc(FILE* f)
 46 | {
 47 | 	asm("SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
 48 | 	    "PUSH_X0"
 49 | 	    "SET_X1_FROM_SP"
 50 | 	    "SET_X2_TO_1"
 51 | 	    "SET_X8_TO_SYS_READ"
 52 | 	    "SYSCALL"
 53 | 	    "SET_X1_TO_0"
 54 | 	    "CMP_X1_X0"
 55 | 	    "POP_X0"
 56 | 	    "SKIP_INST_NE"
 57 | 	    "SET_X0_TO_MINUS_1");
 58 | }
 59 | 
 60 | void fputc(char s, FILE* f)
 61 | {
 62 | 	asm("SET_X0_FROM_BP" "SUB_X0_8"
 63 | 	    "SET_X1_FROM_X0"
 64 | 	    "SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
 65 | 	    "SET_X2_TO_1"
 66 | 	    "SET_X8_TO_SYS_WRITE"
 67 | 	    "SYSCALL");
 68 | }
 69 | 
 70 | void fputs(char* s, FILE* f)
 71 | {
 72 | 	while(0 != s[0])
 73 | 	{
 74 | 		fputc(s[0], f);
 75 | 		s = s + 1;
 76 | 	}
 77 | }
 78 | 
 79 | FILE* open(char* name, int flag, int mode)
 80 | {
 81 | 	asm("SET_X0_FROM_BP" "SUB_X0_24" "DEREF_X0"
 82 | 	    "SET_X3_FROM_X0"
 83 | 	    "SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
 84 | 	    "SET_X2_FROM_X0"
 85 | 	    "SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
 86 | 	    "SET_X1_FROM_X0"
 87 | 	    "SET_X0_TO_FCNTL_H_AT_FDCWD"
 88 | 	    "SET_X8_TO_SYS_OPENAT"
 89 | 	    "SYSCALL");
 90 | }
 91 | 
 92 | FILE* fopen(char* filename, char* mode)
 93 | {
 94 | 	FILE* f;
 95 | 	if('w' == mode[0])
 96 | 	{ /* 577 is O_WRONLY|O_CREAT|O_TRUNC, 384 is 600 in octal */
 97 | 		f = open(filename, 577 , 384);
 98 | 	}
 99 | 	else
100 | 	{ /* Everything else is a read */
101 | 		f = open(filename, 0, 0);
102 | 	}
103 | 
104 | 	/* Negative numbers are error codes */
105 | 	if(0 > f)
106 | 	{
107 | 		return 0;
108 | 	}
109 | 	return f;
110 | }
111 | 
112 | int close(int fd)
113 | {
114 | 	asm("SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
115 | 	    "SET_X8_TO_SYS_CLOSE"
116 | 	    "SYSCALL");
117 | }
118 | 
119 | int fclose(FILE* stream)
120 | {
121 | 	int error = close(stream);
122 | 	return error;
123 | }
124 | 
125 | int brk(void *addr)
126 | {
127 | 	asm("SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
128 | 	    "SET_X8_TO_SYS_BRK"
129 | 	    "SYSCALL");
130 | }
131 | 
132 | long _malloc_ptr;
133 | long _brk_ptr;
134 | 
135 | void* malloc(int size)
136 | {
137 | 	if(NULL == _brk_ptr)
138 | 	{
139 | 		_brk_ptr = brk(0);
140 | 		_malloc_ptr = _brk_ptr;
141 | 	}
142 | 
143 | 	if(_brk_ptr < _malloc_ptr + size)
144 | 	{
145 | 		_brk_ptr = brk(_malloc_ptr + size);
146 | 		if(-1 == _brk_ptr) return 0;
147 | 	}
148 | 
149 | 	long old_malloc = _malloc_ptr;
150 | 	_malloc_ptr = _malloc_ptr + size;
151 | 	return old_malloc;
152 | }
153 | 
154 | int strlen(char* str )
155 | {
156 | 	int i = 0;
157 | 	while(0 != str[i]) i = i + 1;
158 | 	return i;
159 | }
160 | 
161 | void* memset(void* ptr, int value, int num)
162 | {
163 | 	char* s;
164 | 	for(s = ptr; 0 < num; num = num - 1)
165 | 	{
166 | 		s[0] = value;
167 | 		s = s + 1;
168 | 	}
169 | }
170 | 
171 | void* calloc(int count, int size)
172 | {
173 | 	void* ret = malloc(count * size);
174 | 	if(NULL == ret) return NULL;
175 | 	memset(ret, 0, (count * size));
176 | 	return ret;
177 | }
178 | 
179 | void free(void* l)
180 | {
181 | 	return;
182 | }
183 | 
184 | void exit(int value)
185 | {
186 | 	asm("SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
187 | 	    "SET_X8_TO_SYS_EXIT"
188 | 	    "SYSCALL");
189 | }
190 | 


--------------------------------------------------------------------------------
/aarch64/linux/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * Copyright (C) 2020 deesix <deesix@tuta.io>
 3 |  * This file is part of M2-Planet.
 4 |  *
 5 |  * M2-Planet is free software: you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation, either version 3 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * M2-Planet is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 |  */
18 | 
19 | #ifndef __FCNTL_C
20 | #define __FCNTL_C
21 | 
22 | #define O_RDONLY 0
23 | #define O_WRONLY 1
24 | #define O_RDWR 2
25 | #define O_CREAT 00100
26 | #define O_EXCL 00200
27 | #define O_TRUNC 001000
28 | #define O_APPEND 002000
29 | 
30 | #define S_IXUSR 00100
31 | #define S_IWUSR 00200
32 | #define S_IRUSR 00400
33 | #define S_IRWXU 00700
34 | 
35 | 
36 | int _open(char* name, int flag, int mode)
37 | {
38 | 	asm("SET_X0_FROM_BP" "SUB_X0_24" "DEREF_X0"
39 | 	    "SET_X3_FROM_X0"
40 | 	    "SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
41 | 	    "SET_X2_FROM_X0"
42 | 	    "SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
43 | 	    "SET_X1_FROM_X0"
44 | 	    "SET_X0_TO_FCNTL_H_AT_FDCWD"
45 | 	    "SET_X8_TO_SYS_OPENAT"
46 | 	    "SYSCALL");
47 | }
48 | 
49 | #define STDIN_FILENO  0
50 | #define STDOUT_FILENO 1
51 | #define STDERR_FILENO 2
52 | #endif
53 | 


--------------------------------------------------------------------------------
/aarch64/linux/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYS_STAT_C
19 | #define _SYS_STAT_C
20 | #include <sys/types.h>
21 | 
22 | #define S_IRWXU 00700
23 | #define S_IXUSR 00100
24 | #define S_IWUSR 00200
25 | #define S_IRUSR 00400
26 | 
27 | #define S_ISUID 04000
28 | #define S_ISGID 02000
29 | #define S_IXGRP 00010
30 | #define S_IXOTH 00001
31 | #define S_IRGRP 00040
32 | #define S_IROTH 00004
33 | #define S_IWGRP 00020
34 | #define S_IWOTH 00002
35 | #define S_IRWXG 00070
36 | #define S_IRWXO 00007
37 | 
38 | 
39 | int chmod(char *pathname, int mode)
40 | {
41 | 	asm("SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
42 | 	    "SET_X2_FROM_X0"
43 | 	    "SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
44 | 	    "SET_X1_FROM_X0"
45 | 	    "SET_X0_TO_0"
46 | 	    "SET_X3_FROM_X0"
47 | 	    "SET_X0_TO_FCNTL_H_AT_FDCWD"
48 | 	    "SET_X8_TO_SYS_FCHMODAT"
49 | 	    "SYSCALL");
50 | }
51 | 
52 | 
53 | int fchmod(int a, mode_t b)
54 | {
55 | 	asm("SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
56 | 	    "SET_X2_FROM_X0"
57 | 	    "SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
58 | 	    "SET_X1_FROM_X0"
59 | 	    "SET_X0_TO_0"
60 | 	    "SET_X3_FROM_X0"
61 | 	    "SET_X0_TO_FCNTL_H_AT_FDCWD"
62 | 	    "SET_X8_TO_SYS_FCHMOD"
63 | 	    "SYSCALL");
64 | }
65 | 
66 | 
67 | int mkdir(char const* a, mode_t b)
68 | {
69 | 	asm("SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
70 | 	    "SET_X2_FROM_X0"
71 | 	    "SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
72 | 	    "SET_X1_FROM_X0"
73 | 	    "SET_X0_TO_0"
74 | 	    "SET_X3_FROM_X0"
75 | 	    "SET_X0_TO_FCNTL_H_AT_FDCWD"
76 | 	    "SET_X8_TO_SYS_MKDIRAT"
77 | 	    "SYSCALL");
78 | }
79 | 
80 | 
81 | int mknod(char const* a, mode_t b, dev_t c)
82 | {
83 | 	asm("SET_X3_FROM_X2"
84 | 	    "SET_X2_FROM_X1"
85 | 	    "SET_X1_FROM_X0"
86 | 	    "SET_X0_TO_FCNTL_H_AT_FDCWD"
87 | 	    "SET_X8_TO_SYS_MKNODAT"
88 | 	    "SYSCALL");
89 | }
90 | 
91 | 
92 | mode_t umask(mode_t m)
93 | {
94 | 	asm("SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
95 | 	    "SET_X8_TO_SYS_UMASK"
96 | 	    "SYSCALL");
97 | }
98 | #endif
99 | 


--------------------------------------------------------------------------------
/amd64/ELF-amd64-debug.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### stage0's hex2 format
19 | ###    !<label>          1 byte relative
20 | ###    $<label>          2 byte address
21 | ###    @<label>          2 byte relative
22 | ###    &<label>          4 byte address
23 | ###    %<label>          4 byte relative
24 | 
25 | ### if you wish to use this header, you need to add :ELF_end to the end of your
26 | ### M1 or hex2 files.
27 | 
28 | ## ELF Header
29 | 
30 | :ELF_base
31 | 7F 45 4C 46                               # e_ident[EI_MAG0-3] ELF's magic number
32 | 
33 | 02                                        # e_ident[EI_CLASS] Indicating 64 bit
34 | 01                                        # e_ident[EI_DATA] Indicating little endianness
35 | 01                                        # e_ident[EI_VERSION] Indicating original elf
36 | 
37 | 03                                        # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
38 | 00                                        # e_ident[EI_ABIVERSION] See above
39 | 
40 | 00 00 00 00 00 00 00                      # e_ident[EI_PAD]
41 | 
42 | 02 00                                     # e_type Indicating Executable
43 | 3E 00                                     # e_machine Indicating AMD64
44 | 01 00 00 00                               # e_version Indicating original elf
45 | 
46 | &_start 00 00 00 00                       # e_entry Address of the entry point
47 | %ELF_program_headers>ELF_base 00 00 00 00 # e_phoff Address of program header table
48 | %ELF_section_headers>ELF_base 00 00 00 00 # e_shoff Address of section header table
49 | 
50 | 00 00 00 00                               # e_flags
51 | 
52 | 40 00                                     # e_ehsize Indicating our 64 Byte header
53 | 
54 | 38 00                                     # e_phentsize size of a program header table
55 | 01 00                                     # e_phnum number of entries in program table
56 | 
57 | 40 00                                     # e_shentsize size of a section header table
58 | 05 00                                     # e_shnum number of entries in section table
59 | 
60 | 02 00                                     # e_shstrndx index of the section names
61 | 
62 | 
63 | :ELF_program_headers
64 | :ELF_program_header__text
65 | 01 00 00 00                               # ph_type: PT-LOAD = 1
66 | 07 00 00 00                               # ph_flags: PF-X|PF-W|PF-R = 7
67 | 00 00 00 00 00 00 00 00                   # ph_offset
68 | &ELF_base 00 00 00 00                     # ph_vaddr
69 | &ELF_base 00 00 00 00                     # ph_physaddr
70 | %ELF_end>ELF_base 00 00 00 00             # ph_filesz
71 | %ELF_end>ELF_base 00 00 00 00             # ph_memsz
72 | 01 00 00 00 00 00 00 00                   # ph_align
73 | 
74 | :ELF_text
75 | 


--------------------------------------------------------------------------------
/amd64/ELF-amd64.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### stage0's hex2 format
19 | ###    !<label>          1 byte relative
20 | ###    $<label>          2 byte address
21 | ###    @<label>          2 byte relative
22 | ###    &<label>          4 byte address
23 | ###    %<label>          4 byte relative
24 | 
25 | ### if you wish to use this header, you need to add :ELF_end to the end of your
26 | ### M1 or hex2 files.
27 | 
28 | ## ELF Header
29 | 
30 | :ELF_base
31 | 7F 45 4C 46                               # e_ident[EI_MAG0-3] ELF's magic number
32 | 
33 | 02                                        # e_ident[EI_CLASS] Indicating 64 bit
34 | 01                                        # e_ident[EI_DATA] Indicating little endianness
35 | 01                                        # e_ident[EI_VERSION] Indicating original elf
36 | 
37 | 03                                        # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
38 | 00                                        # e_ident[EI_ABIVERSION] See above
39 | 
40 | 00 00 00 00 00 00 00                      # e_ident[EI_PAD]
41 | 
42 | 02 00                                     # e_type Indicating Executable
43 | 3E 00                                     # e_machine Indicating AMD64
44 | 01 00 00 00                               # e_version Indicating original elf
45 | 
46 | &_start 00 00 00 00                       # e_entry Address of the entry point
47 | %ELF_program_headers>ELF_base 00 00 00 00 # e_phoff Address of program header table
48 | 00 00 00 00 00 00 00 00                   # e_shoff Address of section header table
49 | 
50 | 00 00 00 00                               # e_flags
51 | 
52 | 40 00                                     # e_ehsize Indicating our 64 Byte header
53 | 
54 | 38 00                                     # e_phentsize size of a program header table
55 | 01 00                                     # e_phnum number of entries in program table
56 | 
57 | 00 00                                     # e_shentsize size of a section header table
58 | 00 00                                     # e_shnum number of entries in section table
59 | 
60 | 00 00                                     # e_shstrndx index of the section names
61 | 
62 | 
63 | :ELF_program_headers
64 | :ELF_program_header__text
65 | 01 00 00 00                               # ph_type: PT-LOAD = 1
66 | 07 00 00 00                               # ph_flags: PF-X|PF-W|PF-R = 7
67 | 00 00 00 00 00 00 00 00                   # ph_offset
68 | &ELF_base 00 00 00 00                     # ph_vaddr
69 | &ELF_base 00 00 00 00                     # ph_physaddr
70 | %ELF_end>ELF_base 00 00 00 00             # ph_filesz
71 | %ELF_end>ELF_base 00 00 00 00             # ph_memsz
72 | 01 00 00 00 00 00 00 00                   # ph_align
73 | 
74 | :ELF_text
75 | 


--------------------------------------------------------------------------------
/amd64/libc-core.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2016 Jeremiah Orians
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 
19 | 	mov_rbp,rsp                 ; Protect rsp
20 | 
21 | 	;; Prepare argv
22 | 	lea_rax,[rbp+DWORD] %8      ; ARGV_address = RBP + 8
23 | 	push_rax                    ; Put argv on the stack
24 | 
25 | 	;; Prepare envp
26 | 	mov_rax,rbp                 ; Address we need to load from
27 | 	mov_rax,[rax]               ; Get ARGC
28 | 	add_rax, %2                 ; OFFSET = ARGC + 2
29 | 	sal_rax, !3                 ; OFFSET = OFFSET * WORDSIZE
30 | 	add_rax,rbp                 ; ENVP_address = RSP + OFFSET
31 | 	push_rax                    ; Put envp on the stack
32 | 
33 | 	;; Stack offset
34 | 	add_rbp, %8                 ; Fix rbp
35 | 
36 | 	;; Perform the main loop
37 | 	call %FUNCTION_main
38 | 
39 | 	push_rax                    ; Put return value on the stack
40 | 	push_rax                    ; So that _exit gets it
41 | 
42 | :FUNCTION_exit
43 | :FUNCTION__exit
44 | 	pop_rbx
45 | 	pop_rdi
46 | 	mov_rax, %0x3C
47 | 	syscall
48 | 


--------------------------------------------------------------------------------
/amd64/libc-full.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2016 Jeremiah Orians
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 
19 | 	mov_rbp,rsp                 ; Protect rsp
20 | 
21 | 	;; Prepare argv
22 | 	lea_rax,[rbp+DWORD] %8      ; ARGV_address = RBP + 8
23 | 	push_rax                    ; Put argv on the stack
24 | 
25 | 	;; Prepare envp
26 | 	mov_rax,rbp                 ; Address we need to load from
27 | 	mov_rax,[rax]               ; Get ARGC
28 | 	add_rax, %2                 ; OFFSET = ARGC + 2
29 | 	sal_rax, !3                 ; OFFSET = OFFSET * WORDSIZE
30 | 	add_rax,rbp                 ; ENVP_address = RSP + OFFSET
31 | 	push_rax                    ; Put envp on the stack
32 | 	lea_rbx,[rip+DWORD] %GLOBAL__envp ; Get _envp global
33 | 	mov_[rbx],rax               ; Save environment to _envp
34 | 
35 | 	;; Stack offset
36 | 	add_rbp, %8                 ; Fix rbp
37 | 
38 | 	;; Setup for malloc
39 | 	call %FUNCTION___init_malloc
40 | 
41 | 	;; Setup for FILE*
42 | 	call %FUNCTION___init_io
43 | 
44 | 	;; Perform the main loop
45 | 	call %FUNCTION_main
46 | 
47 | 	push_rax                    ; Put return value on the stack
48 | 	push_rax                    ; So that _exit gets it
49 | 
50 | :FUNCTION_exit
51 | 	call %FUNCTION___kill_io
52 | :FUNCTION__exit
53 | 	pop_rbx
54 | 	pop_rdi
55 | 	mov_rax, %0x3C
56 | 	syscall
57 | 
58 | :GLOBAL__envp
59 | 	NULL
60 | 


--------------------------------------------------------------------------------
/amd64/linux/bootstrap.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | enum
 19 | {
 20 | 	stdin = 0,
 21 | 	stdout = 1,
 22 | 	stderr = 2,
 23 | };
 24 | 
 25 | enum
 26 | {
 27 | 	EOF = 0xFFFFFFFF,
 28 | 	NULL = 0,
 29 | };
 30 | 
 31 | enum
 32 | {
 33 | 	EXIT_FAILURE = 1,
 34 | 	EXIT_SUCCESS = 0,
 35 | };
 36 | 
 37 | enum
 38 | {
 39 | 	TRUE = 1,
 40 | 	FALSE = 0,
 41 | };
 42 | 
 43 | 
 44 | int fgetc(FILE* f)
 45 | {
 46 | 	asm("lea_rdi,[rsp+DWORD] %8"
 47 | 	    "mov_rdi,[rdi]"
 48 | 	    "mov_rax, %0"
 49 | 	    "push_rax"
 50 | 	    "lea_rsi,[rsp+DWORD] %0"
 51 | 	    "mov_rdx, %1"
 52 | 	    "syscall"
 53 | 	    "mov_rbx, %0"
 54 | 	    "cmp_rbx,rax"
 55 | 	    "pop_rax"
 56 | 	    "jne %FUNCTION_fgetc_Done"
 57 | 	    "mov_rax, %-1"
 58 | 	    ":FUNCTION_fgetc_Done");
 59 | }
 60 | 
 61 | void fputc(char s, FILE* f)
 62 | {
 63 | 	asm("mov_rax, %1"
 64 | 	    "lea_rdi,[rsp+DWORD] %8"
 65 | 	    "mov_rdi,[rdi]"
 66 | 	    "lea_rsi,[rsp+DWORD] %16"
 67 | 	    "mov_rdx, %1"
 68 | 	    "syscall");
 69 | }
 70 | 
 71 | void fputs(char* s, FILE* f)
 72 | {
 73 | 	while(0 != s[0])
 74 | 	{
 75 | 		fputc(s[0], f);
 76 | 		s = s + 1;
 77 | 	}
 78 | }
 79 | 
 80 | FILE* open(char* name, int flag, int mode)
 81 | {
 82 | 	asm("lea_rdi,[rsp+DWORD] %24"
 83 | 	    "mov_rdi,[rdi]"
 84 | 	    "lea_rsi,[rsp+DWORD] %16"
 85 | 	    "mov_rsi,[rsi]"
 86 | 	    "lea_rdx,[rsp+DWORD] %8"
 87 | 	    "mov_rdx,[rdx]"
 88 | 	    "mov_rax, %2"
 89 | 	    "syscall");
 90 | }
 91 | 
 92 | FILE* fopen(char* filename, char* mode)
 93 | {
 94 | 	FILE* f;
 95 | 	if('w' == mode[0])
 96 | 	{ /* 577 is O_WRONLY|O_CREAT|O_TRUNC, 384 is 600 in octal */
 97 | 		f = open(filename, 577 , 384);
 98 | 	}
 99 | 	else
100 | 	{ /* Everything else is a read */
101 | 		f = open(filename, 0, 0);
102 | 	}
103 | 
104 | 	/* Negative numbers are error codes */
105 | 	if(0 > f)
106 | 	{
107 | 		return 0;
108 | 	}
109 | 	return f;
110 | }
111 | 
112 | int close(int fd)
113 | {
114 | 	asm("lea_rdi,[rsp+DWORD] %8"
115 | 	    "mov_rdi,[rdi]"
116 | 	    "mov_rax, %3"
117 | 	    "syscall");
118 | }
119 | 
120 | int fclose(FILE* stream)
121 | {
122 | 	int error = close(stream);
123 | 	return error;
124 | }
125 | 
126 | int brk(void *addr)
127 | {
128 | 	asm("mov_rax,[rsp+DWORD] %8"
129 | 	    "push_rax"
130 | 	    "mov_rax, %12"
131 | 	    "pop_rbx"
132 | 	    "mov_rdi,rbx"
133 | 	    "syscall");
134 | }
135 | 
136 | long _malloc_ptr;
137 | long _brk_ptr;
138 | 
139 | void* malloc(int size)
140 | {
141 | 	if(NULL == _brk_ptr)
142 | 	{
143 | 		_brk_ptr = brk(0);
144 | 		_malloc_ptr = _brk_ptr;
145 | 	}
146 | 
147 | 	if(_brk_ptr < _malloc_ptr + size)
148 | 	{
149 | 		_brk_ptr = brk(_malloc_ptr + size);
150 | 		if(-1 == _brk_ptr) return 0;
151 | 	}
152 | 
153 | 	long old_malloc = _malloc_ptr;
154 | 	_malloc_ptr = _malloc_ptr + size;
155 | 	return old_malloc;
156 | }
157 | 
158 | int strlen(char* str )
159 | {
160 | 	int i = 0;
161 | 	while(0 != str[i]) i = i + 1;
162 | 	return i;
163 | }
164 | 
165 | void* memset(void* ptr, int value, int num)
166 | {
167 | 	char* s;
168 | 	for(s = ptr; 0 < num; num = num - 1)
169 | 	{
170 | 		s[0] = value;
171 | 		s = s + 1;
172 | 	}
173 | }
174 | 
175 | void* calloc(int count, int size)
176 | {
177 | 	void* ret = malloc(count * size);
178 | 	if(NULL == ret) return NULL;
179 | 	memset(ret, 0, (count * size));
180 | 	return ret;
181 | }
182 | 
183 | void free(void* l)
184 | {
185 | 	return;
186 | }
187 | 
188 | void exit(int value)
189 | {
190 | 	asm("pop_rbx"
191 | 	    "pop_rdi"
192 | 	    "mov_rax, %0x3C"
193 | 	    "syscall");
194 | }
195 | 


--------------------------------------------------------------------------------
/amd64/linux/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef __FCNTL_C
19 | #define __FCNTL_C
20 | 
21 | #define O_RDONLY 0
22 | #define O_WRONLY 1
23 | #define O_RDWR 2
24 | #define O_CREAT 00100
25 | #define O_EXCL 00200
26 | #define O_TRUNC 001000
27 | #define O_APPEND 002000
28 | 
29 | #define S_IXUSR 00100
30 | #define S_IWUSR 00200
31 | #define S_IRUSR 00400
32 | #define S_IRWXU 00700
33 | 
34 | 
35 | int _open(char* name, int flag, int mode)
36 | {
37 | 	asm("lea_rdi,[rsp+DWORD] %24"
38 | 	    "mov_rdi,[rdi]"
39 | 	    "lea_rsi,[rsp+DWORD] %16"
40 | 	    "mov_rsi,[rsi]"
41 | 	    "lea_rdx,[rsp+DWORD] %8"
42 | 	    "mov_rdx,[rdx]"
43 | 	    "mov_rax, %2"
44 | 	    "syscall");
45 | }
46 | 
47 | #define STDIN_FILENO  0
48 | #define STDOUT_FILENO 1
49 | #define STDERR_FILENO 2
50 | #endif
51 | 


--------------------------------------------------------------------------------
/amd64/linux/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYS_STAT_C
19 | #define _SYS_STAT_C
20 | 
21 | #include <sys/types.h>
22 | 
23 | #define S_IRWXU 00700
24 | #define S_IXUSR 00100
25 | #define S_IWUSR 00200
26 | #define S_IRUSR 00400
27 | 
28 | #define S_ISUID 04000
29 | #define S_ISGID 02000
30 | #define S_IXGRP 00010
31 | #define S_IXOTH 00001
32 | #define S_IRGRP 00040
33 | #define S_IROTH 00004
34 | #define S_IWGRP 00020
35 | #define S_IWOTH 00002
36 | #define S_IRWXG 00070
37 | #define S_IRWXO 00007
38 | 
39 | 
40 | int chmod(char *pathname, int mode)
41 | {
42 | 	asm("lea_rdi,[rsp+DWORD] %16"
43 | 	    "mov_rdi,[rdi]"
44 | 	    "lea_rsi,[rsp+DWORD] %8"
45 | 	    "mov_rsi,[rsi]"
46 | 	    "mov_rax, %90"
47 | 	    "syscall");
48 | }
49 | 
50 | 
51 | int fchmod(int a, mode_t b)
52 | {
53 | 	asm("lea_rdi,[rsp+DWORD] %16"
54 | 	    "mov_rdi,[rdi]"
55 | 	    "lea_rsi,[rsp+DWORD] %8"
56 | 	    "mov_rsi,[rsi]"
57 | 	    "mov_rax, %91"
58 | 	    "syscall");
59 | }
60 | 
61 | 
62 | int mkdir(char const* a, mode_t b)
63 | {
64 | 	asm("lea_rdi,[rsp+DWORD] %16"
65 | 	    "mov_rdi,[rdi]"
66 | 	    "lea_rsi,[rsp+DWORD] %8"
67 | 	    "mov_rsi,[rsi]"
68 | 	    "mov_rax, %83"
69 | 	    "syscall");
70 | }
71 | 
72 | 
73 | int mknod(char const* a, mode_t b, dev_t c)
74 | {
75 | 	asm("lea_rdi,[rsp+DWORD] %24"
76 | 	    "mov_rdi,[rdi]"
77 | 	    "lea_rsi,[rsp+DWORD] %16"
78 | 	    "mov_rsi,[rsi]"
79 | 	    "lea_rdx,[rsp+DWORD] %8"
80 | 	    "mov_rdx,[rdx]"
81 | 	    "mov_rax, %133"
82 | 	    "syscall");
83 | }
84 | 
85 | 
86 | mode_t umask(mode_t m)
87 | {
88 | 	asm("lea_rdi,[rsp+DWORD] %8"
89 | 	    "mov_rdi,[rdi]"
90 | 	    "mov_rax, %95"
91 | 	    "syscall");
92 | }
93 | #endif
94 | 


--------------------------------------------------------------------------------
/amd64/linux/unistd.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2020 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | 
 19 | #ifndef _UNISTD_C
 20 | #define _UNISTD_C
 21 | #include <sys/utsname.h>
 22 | #define NULL 0
 23 | #define __PATH_MAX 4096
 24 | 
 25 | void* malloc(unsigned size);
 26 | 
 27 | int access(char* pathname, int mode)
 28 | {
 29 | 	asm("lea_rdi,[rsp+DWORD] %16"
 30 | 	    "mov_rdi,[rdi]"
 31 | 	    "lea_rsi,[rsp+DWORD] %8"
 32 | 	    "mov_rsi,[rsi]"
 33 | 	    "mov_rax, %21"
 34 | 	    "syscall");
 35 | }
 36 | 
 37 | int chdir(char* path)
 38 | {
 39 | 	asm("lea_rdi,[rsp+DWORD] %8"
 40 | 	    "mov_rdi,[rdi]"
 41 | 	    "mov_rax, %80"
 42 | 	    "syscall");
 43 | }
 44 | 
 45 | int fchdir(int fd)
 46 | {
 47 | 	asm("lea_rdi,[rsp+DWORD] %8"
 48 | 	    "mov_rdi,[rdi]"
 49 | 	    "mov_rax, %81"
 50 | 	    "syscall");
 51 | }
 52 | 
 53 | void _exit(int value);
 54 | 
 55 | int fork()
 56 | {
 57 | 	asm("mov_rax, %57"
 58 | 	    "mov_rdi, %0"
 59 | 	    "syscall");
 60 | }
 61 | 
 62 | 
 63 | int waitpid (int pid, int* status_ptr, int options)
 64 | {
 65 | 	/* Uses wait4 with struct rusage *ru set to NULL */
 66 | 	asm("lea_rdi,[rsp+DWORD] %24"
 67 | 	    "mov_rdi,[rdi]"
 68 | 	    "lea_rsi,[rsp+DWORD] %16"
 69 | 	    "mov_rsi,[rsi]"
 70 | 	    "lea_rdx,[rsp+DWORD] %8"
 71 | 	    "mov_rdx,[rdx]"
 72 | 	    "mov_r10, %0"
 73 | 	    "mov_rax, %61"
 74 | 	    "syscall");
 75 | }
 76 | 
 77 | 
 78 | int execve(char* file_name, char** argv, char** envp)
 79 | {
 80 | 	asm("lea_rdi,[rsp+DWORD] %24"
 81 | 	    "mov_rdi,[rdi]"
 82 | 	    "lea_rsi,[rsp+DWORD] %16"
 83 | 	    "mov_rsi,[rsi]"
 84 | 	    "lea_rdx,[rsp+DWORD] %8"
 85 | 	    "mov_rdx,[rdx]"
 86 | 	    "mov_rax, %59"
 87 | 	    "syscall");
 88 | }
 89 | 
 90 | int read(int fd, char* buf, unsigned count)
 91 | { /*maybe*/
 92 | 	asm("lea_rdi,[rsp+DWORD] %24"
 93 | 	    "mov_rdi,[rdi]"
 94 | 	    "lea_rsi,[rsp+DWORD] %16"
 95 | 	    "mov_rsi,[rsi]"
 96 | 	    "lea_rdx,[rsp+DWORD] %8"
 97 | 	    "mov_rdx,[rdx]"
 98 | 	    "mov_rax, %0"
 99 | 	    "syscall");
100 | }
101 | 
102 | int write(int fd, char* buf, unsigned count)
103 | {/*maybe*/
104 | 	asm("lea_rdi,[rsp+DWORD] %24"
105 | 	    "mov_rdi,[rdi]"
106 | 	    "lea_rsi,[rsp+DWORD] %16"
107 | 	    "mov_rsi,[rsi]"
108 | 	    "lea_rdx,[rsp+DWORD] %8"
109 | 	    "mov_rdx,[rdx]"
110 | 	    "mov_rax, %1"
111 | 	    "syscall");
112 | }
113 | 
114 | int lseek(int fd, int offset, int whence)
115 | {
116 | 	asm("lea_rdi,[rsp+DWORD] %24"
117 | 	    "mov_rdi,[rdi]"
118 | 	    "lea_rsi,[rsp+DWORD] %16"
119 | 	    "mov_rsi,[rsi]"
120 | 	    "lea_rdx,[rsp+DWORD] %8"
121 | 	    "mov_rdx,[rdx]"
122 | 	    "mov_rax, %8"
123 | 	    "syscall");
124 | }
125 | 
126 | 
127 | int close(int fd)
128 | {
129 | 	asm("lea_rdi,[rsp+DWORD] %8"
130 | 	    "mov_rdi,[rdi]"
131 | 	    "mov_rax, %3"
132 | 	    "syscall");
133 | }
134 | 
135 | 
136 | int unlink (char* filename)
137 | {
138 | 	asm("lea_rdi,[rsp+DWORD] %8"
139 | 	    "mov_rdi,[rdi]"
140 | 	    "mov_rax, %87"
141 | 	    "syscall");
142 | }
143 | 
144 | int symlink(char *path1, char *path2)
145 | {
146 | 	asm("lea_rdi,[rsp+DWORD] %16"
147 | 	    "mov_rdi,[rdi]"
148 | 	    "lea_rsi,[rsp+DWORD] %8"
149 | 	    "mov_rsi,[rsi]"
150 | 	    "mov_rax, %88"
151 | 	    "syscall");
152 | }
153 | 
154 | int _getcwd(char* buf, int size)
155 | {
156 | 	asm("lea_rdi,[rsp+DWORD] %16"
157 | 	    "mov_rdi,[rdi]"
158 | 	    "lea_rsi,[rsp+DWORD] %8"
159 | 	    "mov_rsi,[rsi]"
160 | 	    "mov_rax, %79"
161 | 	    "syscall");
162 | }
163 | 
164 | 
165 | char* getcwd(char* buf, unsigned size)
166 | {
167 | 	int c = _getcwd(buf, size);
168 | 	if(0 == c) return NULL;
169 | 	return buf;
170 | }
171 | 
172 | 
173 | char* getwd(char* buf)
174 | {
175 | 	return getcwd(buf, __PATH_MAX);
176 | }
177 | 
178 | 
179 | char* get_current_dir_name()
180 | {
181 | 	return getcwd(malloc(__PATH_MAX), __PATH_MAX);
182 | }
183 | 
184 | 
185 | int brk(void *addr)
186 | {
187 | 	asm("mov_rax,[rsp+DWORD] %8"
188 | 	    "push_rax"
189 | 	    "mov_rax, %12"
190 | 	    "pop_rbx"
191 | 	    "mov_rdi,rbx"
192 | 	    "syscall");
193 | }
194 | 
195 | int uname(struct utsname* unameData)
196 | {
197 | 	asm("lea_rdi,[rsp+DWORD] %8"
198 | 	    "mov_rdi,[rdi]"
199 | 	    "mov_rax, %63"
200 | 	    "syscall");
201 | }
202 | 
203 | int unshare(int flags)
204 | {
205 | 	asm("lea_rdi,[rsp+DWORD] %8"
206 | 	    "mov_rdi,[rdi]"
207 | 	    "mov_rax, %272"
208 | 	    "syscall");
209 | }
210 | 
211 | int geteuid()
212 | {
213 | 	asm("mov_rax, %107"
214 | 	    "syscall");
215 | }
216 | 
217 | int getegid()
218 | {
219 | 	asm("mov_rax, %108"
220 | 	    "syscall");
221 | }
222 | 
223 | int mount(char *source, char *target, char *filesystemtype, SCM mountflags, void *data)
224 | {
225 | 	asm("lea_rdi,[rsp+DWORD] %40"
226 | 	    "mov_rdi,[rdi]"
227 | 	    "lea_rsi,[rsp+DWORD] %32"
228 | 	    "mov_rsi,[rsi]"
229 | 	    "lea_rdx,[rsp+DWORD] %24"
230 | 	    "mov_rdx,[rdx]"
231 | 	    "lea_r10,[rsp+DWORD] %16"
232 | 	    "mov_r10,[r10]"
233 | 	    "lea_r8,[rsp+DWORD] %8"
234 | 	    "mov_r8,[r8]"
235 | 	    "mov_rax, %165"
236 | 	    "syscall");
237 | }
238 | 
239 | int chroot(char *path)
240 | {
241 | 	asm("lea_rdi,[rsp+DWORD] %8"
242 | 	    "mov_rdi,[rdi]"
243 | 	    "mov_rax, %161"
244 | 	    "syscall");
245 | }
246 | 
247 | #endif
248 | 


--------------------------------------------------------------------------------
/amd64/uefi/libc-core.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2022 Andrius Štikonas
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 	# Save non-volatile registers
19 | 	push_rbp
20 | 	push_rbx
21 | 	push_rdi
22 | 	push_rsi
23 | 	push_r12
24 | 	push_r13
25 | 	push_r14
26 | 	push_r15
27 | 	mov_rbp,rsp                                    # save stack pointer
28 | 
29 | 	mov_[rip+DWORD],rsp %__return_address          # save UEFI return address
30 | 	mov_[rip+DWORD],rcx %GLOBAL__image_handle      # save image_handle
31 | 	mov_[rip+DWORD],rdx %GLOBAL__system            # save system
32 | 
33 | 	;; Do UEFI initialization
34 | 	call %FUNCTION__init
35 | 	call %exit_uefi_stack                          # Switch to user stack
36 | 
37 | 	;; Perform the main loop
38 | 	mov_rax,[rip+DWORD] %GLOBAL__argc              # Get argc
39 | 	push_rax                                       # Push it onto stack
40 | 	mov_rax,[rip+DWORD] %GLOBAL__argv              # Get argv
41 | 	push_rax                                       # Push it onto stack
42 | 	push !0                                        # envp = NULL
43 | 	call %FUNCTION_main
44 | 
45 | :FUNCTION__exit
46 | 	;; Do UEFI cleanup
47 | 	call %enter_uefi_stack                         # Switch back to UEFI stack
48 | 	push_rax                                       # Save exit code
49 | 	call %FUNCTION__cleanup
50 | 	pop_rax                                        # Restore exit code
51 | 
52 | :FUNCTION___exit
53 | 	mov_rsp,[rip+DWORD] %__return_address          # Get UEFI return address
54 | 	pop_r15
55 | 	pop_r14
56 | 	pop_r13
57 | 	pop_r12
58 | 	pop_rsi
59 | 	pop_rdi
60 | 	pop_rbx
61 | 	pop_rbp
62 | 	ret
63 | 
64 | # Switch to uefi stack
65 | # does not change any other registers except for rbp
66 | :enter_uefi_stack
67 | 	mov_[rip+DWORD],rax %__temp_rax           # save RAX
68 | 	pop_rax                                   # Save return address
69 | 	mov_[rip+DWORD],rsp %GLOBAL___user_stack  # save user stack
70 | 	mov_rsp,[rip+DWORD] %__uefi_stack         # restore system stack
71 | 	push_rax                                  # Restore return address
72 | 	mov_rax,[rip+DWORD] %__temp_rax           # restore RAX
73 | 	mov_rbp,rsp                               # Fix rbp
74 | 	add_rbp, %8                               # Fix rbp
75 | 	ret
76 | 
77 | # Switch to user stack
78 | # does not change any other registers except for rbp
79 | :exit_uefi_stack
80 | 	mov_[rip+DWORD],rax %__temp_rax           # save RAX
81 | 	pop_rax                                   # Save return address
82 | 	mov_[rip+DWORD],rsp %__uefi_stack         # save system stack
83 | 	mov_rsp,[rip+DWORD] %GLOBAL___user_stack  # restore user stack
84 | 	push_rax                                  # Restore return address
85 | 	mov_rax,[rip+DWORD] %__temp_rax           # restore RAX
86 | 	mov_rbp,rsp                               # Fix rbp
87 | 	add_rbp, %8                               # Fix rbp
88 | 	ret
89 | 
90 | :__return_address
91 | 	NULL
92 | 
93 | :__temp_rax
94 | 	NULL
95 | 
96 | :__uefi_stack
97 | 	NULL
98 | 


--------------------------------------------------------------------------------
/amd64/uefi/libc-full.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2022 Andrius Štikonas
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 	push_rbp
19 | 	push_rbx
20 | 	push_rdi
21 | 	push_rsi
22 | 	push_r12
23 | 	push_r13
24 | 	push_r14
25 | 	push_r15
26 | 	mov_rbp,rsp                                    # save stack pointer
27 | 
28 | 	mov_[rip+DWORD],rsp %__return_address          # save UEFI return address
29 | 	mov_[rip+DWORD],rcx %GLOBAL__image_handle      # save image_handle
30 | 	mov_[rip+DWORD],rdx %GLOBAL__system            # save system
31 | 
32 | 	;; Do UEFI initialization
33 | 	call %FUNCTION__init
34 | 	call %exit_uefi_stack                          # Switch to user stack
35 | 
36 | 	;; Perform the main loop
37 | 	mov_rax,[rip+DWORD] %GLOBAL__argc              # Get argc
38 | 	push_rax                                       # Push it onto stack
39 | 	mov_rax,[rip+DWORD] %GLOBAL__argv              # Get argv
40 | 	push_rax                                       # Push it onto stack
41 | 	mov_rax,[rip+DWORD] %GLOBAL__envp              # Get envp
42 | 	push_rax                                       # Push it onto stack
43 | 	call %FUNCTION_main
44 | 
45 | :FUNCTION__exit
46 | 	;; Do UEFI cleanup
47 | 	call %enter_uefi_stack                         # Switch back to UEFI stack
48 | 	push_rax                                       # Save exit code
49 | 	call %FUNCTION__cleanup
50 | 	pop_rax                                        # Restore exit code
51 | 
52 | :FUNCTION___exit
53 | 	mov_rsp,[rip+DWORD] %__return_address          # Get UEFI return address
54 | 	pop_r15
55 | 	pop_r14
56 | 	pop_r13
57 | 	pop_r12
58 | 	pop_rsi
59 | 	pop_rdi
60 | 	pop_rbx
61 | 	pop_rbp
62 | 	ret
63 | 
64 | # Switch to uefi stack
65 | # does not change any other registers except for rbp
66 | :enter_uefi_stack
67 | 	mov_[rip+DWORD],rax %__temp_rax           # save RAX
68 | 	pop_rax                                   # Save return address
69 | 	mov_[rip+DWORD],rsp %GLOBAL___user_stack  # save user stack
70 | 	mov_rsp,[rip+DWORD] %__uefi_stack         # restore system stack
71 | 	push_rax                                  # Restore return address
72 | 	mov_rax,[rip+DWORD] %__temp_rax           # restore RAX
73 | 	mov_rbp,rsp                               # Fix rbp
74 | 	add_rbp, %8                               # Fix rbp
75 | 	ret
76 | 
77 | # Switch to user stack
78 | # does not change any other registers except for rbp
79 | :exit_uefi_stack
80 | 	mov_[rip+DWORD],rax %__temp_rax           # save RAX
81 | 	pop_rax                                   # Save return address
82 | 	mov_[rip+DWORD],rsp %__uefi_stack         # save system stack
83 | 	mov_rsp,[rip+DWORD] %GLOBAL___user_stack  # restore user stack
84 | 	push_rax                                  # Restore return address
85 | 	mov_rax,[rip+DWORD] %__temp_rax           # restore RAX
86 | 	mov_rbp,rsp                               # Fix rbp
87 | 	add_rbp, %8                               # Fix rbp
88 | 	ret
89 | 
90 | :__return_address
91 | 	NULL
92 | 
93 | :__temp_rax
94 | 	NULL
95 | 
96 | :__uefi_stack
97 | 	NULL
98 | 


--------------------------------------------------------------------------------
/armv7l/ELF-armv7l-debug.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### stage0's hex2 format
19 | ###    !<label>          1 byte relative
20 | ###    $<label>          2 byte address
21 | ###    @<label>          2 byte relative
22 | ###    &<label>          4 byte address
23 | ###    %<label>          4 byte relative
24 | 
25 | ### if you wish to use this header, you need to add :ELF_end to the end of your
26 | ### M1 or hex2 files.
27 | 
28 | ## ELF Header
29 | 
30 | :ELF_base
31 | 7F 45 4C 46                    # e_ident[EI_MAG0-3] ELF's magic number
32 | 
33 | 01                             # e_ident[EI_CLASS] Indicating 32 bit
34 | 01                             # e_ident[EI_DATA] Indicating little endianness
35 | 01                             # e_ident[EI_VERSION] Indicating original elf
36 | 
37 | 03                             # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
38 | 00                             # e_ident[EI_ABIVERSION] See above
39 | 
40 | 00 00 00 00 00 00 00           # e_ident[EI_PAD]
41 | 
42 | 02 00                          # e_type Indicating Executable
43 | 28 00                          # e_machine Indicating 32bit ARM
44 | 01 00 00 00                    # e_version Indicating original elf
45 | 
46 | &_start                        # e_entry Address of the entry point
47 | %ELF_program_headers>ELF_base  # e_phoff Address of program header table
48 | %ELF_section_headers>ELF_base  # e_shoff Address of section header table
49 | 
50 | 00 02 00 05                    # e_flags
51 | 
52 | 34 00                          # e_ehsize Indicating our 52 Byte header
53 | 
54 | 20 00                          # e_phentsize size of a program header table
55 | 01 00                          # e_phnum number of entries in program table
56 | 
57 | 28 00                          # e_shentsize size of a section header table
58 | 05 00                          # e_shnum number of entries in section table
59 | 
60 | 02 00                          # e_shstrndx index of the section names
61 | 
62 | 
63 | :ELF_program_headers
64 | :ELF_program_header__text
65 | 01 00 00 00                    # ph_type: PT-LOAD = 1
66 | 00 00 00 00                    # ph_offset
67 | &ELF_base                      # ph_vaddr
68 | &ELF_base                      # ph_physaddr
69 | %ELF_end>ELF_base              # ph_filesz
70 | %ELF_end>ELF_base              # ph_memsz
71 | 07 00 00 00                    # ph_flags: PF-X|PF-W|PF-R = 7
72 | 00 00 01 00                    # ph_alignment
73 | 
74 | :ELF_text
75 | 


--------------------------------------------------------------------------------
/armv7l/ELF-armv7l.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### stage0's hex2 format
19 | ###    !<label>          1 byte relative
20 | ###    $<label>          2 byte address
21 | ###    @<label>          2 byte relative
22 | ###    &<label>          4 byte address
23 | ###    %<label>          4 byte relative
24 | 
25 | ### if you wish to use this header, you need to add :ELF_end to the end of your
26 | ### M1 or hex2 files.
27 | 
28 | ## ELF Header
29 | 
30 | :ELF_base
31 | 7F 45 4C 46                    # e_ident[EI_MAG0-3] ELF's magic number
32 | 
33 | 01                             # e_ident[EI_CLASS] Indicating 32 bit
34 | 01                             # e_ident[EI_DATA] Indicating little endianness
35 | 01                             # e_ident[EI_VERSION] Indicating original elf
36 | 
37 | 03                             # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
38 | 00                             # e_ident[EI_ABIVERSION] See above
39 | 
40 | 00 00 00 00 00 00 00           # e_ident[EI_PAD]
41 | 
42 | 02 00                          # e_type Indicating Executable
43 | 28 00                          # e_machine Indicating 32bit ARM
44 | 01 00 00 00                    # e_version Indicating original elf
45 | 
46 | &_start                        # e_entry Address of the entry point
47 | %ELF_program_headers>ELF_base  # e_phoff Address of program header table
48 | 00 00 00 00                    # e_shoff Address of section header table
49 | 
50 | 00 02 00 05                    # e_flags
51 | 
52 | 34 00                          # e_ehsize Indicating our 52 Byte header
53 | 
54 | 20 00                          # e_phentsize size of a program header table
55 | 01 00                          # e_phnum number of entries in program table
56 | 
57 | 00 00                          # e_shentsize size of a section header table
58 | 00 00                          # e_shnum number of entries in section table
59 | 
60 | 00 00                          # e_shstrndx index of the section names
61 | 
62 | 
63 | :ELF_program_headers
64 | :ELF_program_header__text
65 | 01 00 00 00                    # ph_type: PT-LOAD = 1
66 | 00 00 00 00                    # ph_offset
67 | &ELF_base                      # ph_vaddr
68 | &ELF_base                      # ph_physaddr
69 | %ELF_end>ELF_base              # ph_filesz
70 | %ELF_end>ELF_base              # ph_memsz
71 | 07 00 00 00                    # ph_flags: PF-X|PF-W|PF-R = 7
72 | 00 00 01 00                    # ph_alignment
73 | 
74 | :ELF_text
75 | 


--------------------------------------------------------------------------------
/armv7l/armv7l_defs.M1:
--------------------------------------------------------------------------------
  1 | ## Copyright (C) 2016 Jeremiah Orians
  2 | ## This file is part of stage0.
  3 | ##
  4 | ## stage0 is free software: you can redistribute it and/or modify
  5 | ## it under the terms of the GNU General Public License as published by
  6 | ## the Free Software Foundation, either version 3 of the License, or
  7 | ## (at your option) any later version.
  8 | ##
  9 | ## stage0 is distributed in the hope that it will be useful,
 10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | ## GNU General Public License for more details.
 13 | ##
 14 | ## You should have received a copy of the GNU General Public License
 15 | ## along with stage0.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | # M2-Planet standards
 18 | DEFINE NULL 00000000
 19 | 
 20 | # Registers
 21 | DEFINE R0 0
 22 | DEFINE R1 1
 23 | DEFINE R2 2
 24 | DEFINE R3 3
 25 | DEFINE R4 4
 26 | DEFINE R5 5
 27 | DEFINE R6 6
 28 | DEFINE R7 7
 29 | DEFINE R8 8
 30 | DEFINE R9 9
 31 | DEFINE R10 A
 32 | DEFINE R11 B
 33 | DEFINE R12 C
 34 | DEFINE BP C
 35 | DEFINE R13 D
 36 | DEFINE SP D
 37 | DEFINE R14 E
 38 | DEFINE LR E
 39 | DEFINE R15 F
 40 | DEFINE PC F
 41 | 
 42 | # Register masks for push/pop16
 43 | DEFINE {R0} 0100
 44 | DEFINE {R1} 0200
 45 | DEFINE {R2} 0400
 46 | DEFINE {R3} 0800
 47 | DEFINE {R4} 1000
 48 | DEFINE {R8} 0001
 49 | DEFINE {R9} 0002
 50 | DEFINE {R10} 0004
 51 | DEFINE {R11} 0008
 52 | DEFINE {BP} 0010
 53 | DEFINE {LR} 0040
 54 | 
 55 | # Bitshift constants
 56 | DEFINE NO_SHIFT 0
 57 | DEFINE LEFT 1
 58 | DEFINE RIGHT 3
 59 | DEFINE ARITH_RIGHT 5
 60 | 
 61 | # LOAD/STORE
 62 | DEFINE HALF_MEMORY E1
 63 | DEFINE MEMORY E5
 64 | DEFINE NO_OFFSET B0
 65 | DEFINE STORE32 08
 66 | DEFINE STORE16 0C
 67 | DEFINE STORE8 0C
 68 | DEFINE LOAD32 09
 69 | DEFINE LOADU8 0
 70 | DEFINE LOADS8 D0
 71 | DEFINE LOADS16 F0
 72 | DEFINE LOAD 0D
 73 | DEFINE LOADI8_ALWAYS 0A0E3
 74 | DEFINE LOADI8_G 0A0C3
 75 | DEFINE LOADI8_GE 0A0A3
 76 | DEFINE LOADI8_EQUAL 0A003
 77 | DEFINE LOADI8_NE 0A013
 78 | DEFINE LOADI8_LE 0A0D3
 79 | DEFINE LOADI8_L 0A0B3
 80 | DEFINE LOADI8_HI 0A083
 81 | DEFINE LOADI8_HS 0A023
 82 | DEFINE LOADI8_LS 0A093
 83 | DEFINE LOADI8_LO 0A033
 84 | 
 85 | # JUMP/BRANCH
 86 | DEFINE JUMP_ALWAYS EA
 87 | DEFINE JUMP_EQUAL 0A
 88 | DEFINE JUMP_NE 1A
 89 | DEFINE CALL_ALWAYS EB
 90 | DEFINE CALL_REG_ALWAYS FF2FE1
 91 | DEFINE RETURN FF2FE1
 92 | 
 93 | # Data movement
 94 | DEFINE MOVE_ALWAYS A0E1
 95 | DEFINE MVN_ALWAYS 0E0E1
 96 | DEFINE MVN_LT 0E0B1
 97 | DEFINE MVNI8_EQUAL 0E003
 98 | DEFINE PUSH_ALWAYS 2DE9
 99 | DEFINE POP_ALWAYS BDE8
100 | 
101 | # Arithmetic/logic
102 | DEFINE AUX_ALWAYS E1
103 | DEFINE IMM_ALWAYS E3
104 | DEFINE ARITH_ALWAYS E2
105 | DEFINE ARITH_GE A2
106 | DEFINE ARITH_LT B2
107 | DEFINE ARITH_NE 12
108 | DEFINE ARITH2_ALWAYS E0
109 | DEFINE ARITH2_GE A0
110 | DEFINE ADC 0A
111 | DEFINE ADCS 0B
112 | DEFINE ADD 08
113 | DEFINE ADDS 09
114 | DEFINE AND 00
115 | DEFINE CMP 005
116 | DEFINE CMPI8 005
117 | DEFINE MUL 0
118 | DEFINE MULS 1
119 | DEFINE OR 08
120 | DEFINE SHIFT A0
121 | DEFINE SUB 04
122 | DEFINE RSUB 06
123 | DEFINE XOR 02
124 | 
125 | # SYSCALL
126 | DEFINE SYSCALL_ALWAYS 000000EF
127 | 


--------------------------------------------------------------------------------
/armv7l/libc-core.M1:
--------------------------------------------------------------------------------
  1 | ## Copyright (C) 2016 Jeremiah Orians
  2 | ## This file is part of M2-Planet.
  3 | ##
  4 | ## M2-Planet is free software: you can redistribute it and/or modify
  5 | ## it under the terms of the GNU General Public License as published by
  6 | ## the Free Software Foundation, either version 3 of the License, or
  7 | ## (at your option) any later version.
  8 | ##
  9 | ## M2-Planet is distributed in the hope that it will be useful,
 10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | ## GNU General Public License for more details.
 13 | ##
 14 | ## You should have received a copy of the GNU General Public License
 15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | :_start
 18 | 	'0' SP BP NO_SHIFT MOVE_ALWAYS  ; Setup Base Pointer
 19 | 
 20 | 	;; Prepare argv
 21 | 	!4 R0 ADD BP ARITH_ALWAYS       ; ARGV_address = BP + 4
 22 | 	{R0} PUSH_ALWAYS                ; Put argv on the stack
 23 | 
 24 | 	;; Prepare envp
 25 | 	'0' BP R0 NO_SHIFT MOVE_ALWAYS  ; Address we need to load from
 26 | 	!0 R0 LOAD32 R0 MEMORY          ; Get ARGC
 27 | 	!2 R0 ADD R0 ARITH_ALWAYS       ; OFFSET = ARGC + 2
 28 | 	'0' R0 R0 '1' MOVE_ALWAYS       ; OFFSET = OFFSET * WORDSIZE
 29 | 	'0' R0 R0 ADD BP ARITH2_ALWAYS  ; ENVP_address = BP + OFFSET
 30 | 	{R0} PUSH_ALWAYS                ; Put envp on the stack
 31 | 
 32 | 	;; Stack offset
 33 | 	!4 BP ADD BP ARITH_ALWAYS       ; Fix BP
 34 | 
 35 | 	^~FUNCTION_main CALL_ALWAYS     ; Jump right into main
 36 | 
 37 | 	{R1} POP_ALWAYS                 ; Fix stack
 38 | 	{R1} POP_ALWAYS                 ; Fix stack
 39 | 	{R1} POP_ALWAYS                 ; Fix stack
 40 | 	{R0} PUSH_ALWAYS                ; put return on the stack
 41 | 	{R0} PUSH_ALWAYS                ; So that _exit will have it
 42 | 	{R0} PUSH_ALWAYS                ; So that _exit will have it
 43 | 
 44 | :FUNCTION_exit
 45 | :FUNCTION__exit
 46 | 	!4 R0 SUB R12 ARITH_ALWAYS
 47 | 	!0 R0 LOAD32 R0 MEMORY
 48 | 	!1 R7 LOADI8_ALWAYS
 49 | 	SYSCALL_ALWAYS                  ; exit
 50 | 
 51 | 
 52 | # Unsigned Divide
 53 | :divide
 54 | 	{R4} PUSH_ALWAYS                ; Protect R4
 55 | 	{R3} PUSH_ALWAYS                ; Protect R3
 56 | 	{R2} PUSH_ALWAYS                ; Protect R2
 57 | 
 58 | 	'0' R0 R3 NO_SHIFT MOVE_ALWAYS  ; MOV R3,R0
 59 | 	'0' R1 R2 NO_SHIFT MOVE_ALWAYS  ; MOV R2,R1
 60 | 
 61 | 	!0 R0 LOADI8_ALWAYS             ; MOV R0,#0
 62 | 	!0 CMPI8 R2 IMM_ALWAYS          ; CMP R2,#0
 63 | 	!1 R0 SUB R0 ARITH_LT           ; SUBLT R0,R0,#1
 64 | 	!0 CMPI8 R3 IMM_ALWAYS          ; CMP R3,#0
 65 | 	!0 R3 RSUB R3 ARITH_LT          ; RSBLT R3,R3,#0
 66 | 	'0' R0 R0 MVN_LT                ; MVNLT R0,R0
 67 | 	'0' R0 R4 NO_SHIFT MOVE_ALWAYS  ; MOV R4,R0
 68 | 
 69 | 	!32 R0 LOADI8_ALWAYS            ; MOV  R0,#32.
 70 | 	!0 R1 LOADI8_ALWAYS             ; MOV  R1,#0
 71 | :divide_loop
 72 | 	'0' R2 R2 ADDS R2 ARITH2_ALWAYS ; ADDS R2,R2,R2
 73 | 	'0' R1 R1 ADCS R1 ARITH2_ALWAYS ; ADCS R1,R1,R1
 74 | 	'0' R3 CMP R1 AUX_ALWAYS        ; CMP  R1,R3
 75 | 	'0' R3 R1 SUB R1 ARITH2_GE      ; SUBGE  R1,R1,R3
 76 | 	!1 R2 ADD R2 ARITH_GE           ; ADDGE  R2,R2,#1
 77 | 	!1 R0 SUB R0 ARITH_ALWAYS       ; SUB  R0,R0,#1
 78 | 	!0 CMPI8 R0 IMM_ALWAYS          ; CMP  R0,#0
 79 | 	^~divide_loop JUMP_NE           ; BNE  loop
 80 | 
 81 | 	'0' R2 R0 NO_SHIFT MOVE_ALWAYS  ; MOV R0,R2
 82 | 
 83 | 	{R2} POP_ALWAYS                 ; Restore R2
 84 | 	{R3} POP_ALWAYS                 ; Restore R3
 85 | 	{R4} POP_ALWAYS                 ; Restore R4
 86 | 	'1' LR RETURN
 87 | 
 88 | # Signed Divide
 89 | :divides
 90 | 	{R4} PUSH_ALWAYS                ; Protect R4
 91 | 	{R3} PUSH_ALWAYS                ; Protect R3
 92 | 	{R2} PUSH_ALWAYS                ; Protect R2
 93 | 
 94 | 	'0' R0 R3 NO_SHIFT MOVE_ALWAYS  ; MOV R3,R0
 95 | 	'0' R1 R2 NO_SHIFT MOVE_ALWAYS  ; MOV R2,R1
 96 | 
 97 | 	!0 R0 LOADI8_ALWAYS             ; MOV R0,#0
 98 | 	!0 CMPI8 R2 IMM_ALWAYS          ; CMP R2,#0
 99 | 	!0 R2 RSUB R2 ARITH_LT          ; RSBLT R2,R2,#0
100 | 	!1 R0 SUB R0 ARITH_LT           ; SUBLT R0,R0,#1
101 | 	!0 CMPI8 R3 IMM_ALWAYS          ; CMP R3,#0
102 | 	!0 R3 RSUB R3 ARITH_LT          ; RSBLT R3,R3,#0
103 | 	'0' R0 R0 MVN_LT                ; MVNLT R0,R0
104 | 	'0' R0 R4 NO_SHIFT MOVE_ALWAYS  ; MOV R4,R0
105 | 
106 | 	!32 R0 LOADI8_ALWAYS            ; MOV  R0,#32.
107 | 	!0 R1 LOADI8_ALWAYS             ; MOV  R1,#0
108 | :divides_loop
109 | 	'0' R2 R2 ADDS R2 ARITH2_ALWAYS ; ADDS R2,R2,R2
110 | 	'0' R1 R1 ADCS R1 ARITH2_ALWAYS ; ADCS R1,R1,R1
111 | 	'0' R3 CMP R1 AUX_ALWAYS        ; CMP  R1,R3
112 | 	'0' R3 R1 SUB R1 ARITH2_GE      ; SUBGE  R1,R1,R3
113 | 	!1 R2 ADD R2 ARITH_GE           ; ADDGE  R2,R2,#1
114 | 	!1 R0 SUB R0 ARITH_ALWAYS       ; SUB  R0,R0,#1
115 | 	!0 CMPI8 R0 IMM_ALWAYS          ; CMP  R0,#0
116 | 	^~divides_loop JUMP_NE          ; BNE  loop
117 | 
118 | 	!0 CMPI8 R4 IMM_ALWAYS          ; CMP R4,#0
119 | 	!0 R2 RSUB R2 ARITH_NE          ; RSBNE R2,R2,#0
120 | 	'0' R2 R0 NO_SHIFT MOVE_ALWAYS  ; MOV R0,R2
121 | 
122 | 	{R2} POP_ALWAYS                 ; Restore R2
123 | 	{R3} POP_ALWAYS                 ; Restore R3
124 | 	{R4} POP_ALWAYS                 ; Restore R4
125 | 	'1' LR RETURN
126 | 
127 | # Unsigned Modulus
128 | :modulus
129 | 	{LR} PUSH_ALWAYS                ; Prepare to leverage divide
130 | 	^~divide CALL_ALWAYS            ; Use divide
131 | 	'0' R1 R0 NO_SHIFT MOVE_ALWAYS  ; MOV R0,R1
132 | 	{LR} POP_ALWAYS                 ; Prepare for return
133 | 	'1' LR RETURN
134 | 
135 | # Signed Modulus
136 | :moduluss
137 | 	{LR} PUSH_ALWAYS                ; Prepare to leverage divide
138 | 	^~divides CALL_ALWAYS           ; Use divides
139 | 	'0' R1 R0 NO_SHIFT MOVE_ALWAYS  ; MOV R0,R1
140 | 	{LR} POP_ALWAYS                 ; Prepare for return
141 | 	'1' LR RETURN
142 | 


--------------------------------------------------------------------------------
/armv7l/libc-full.M1:
--------------------------------------------------------------------------------
  1 | ## Copyright (C) 2016 Jeremiah Orians
  2 | ## This file is part of M2-Planet.
  3 | ##
  4 | ## M2-Planet is free software: you can redistribute it and/or modify
  5 | ## it under the terms of the GNU General Public License as published by
  6 | ## the Free Software Foundation, either version 3 of the License, or
  7 | ## (at your option) any later version.
  8 | ##
  9 | ## M2-Planet is distributed in the hope that it will be useful,
 10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | ## GNU General Public License for more details.
 13 | ##
 14 | ## You should have received a copy of the GNU General Public License
 15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | :_start
 18 | 	'0' SP BP NO_SHIFT MOVE_ALWAYS  ; Setup Base Pointer
 19 | 
 20 | 	;; Prepare argv
 21 | 	!4 R0 ADD BP ARITH_ALWAYS       ; ARGV_address = BP + 4
 22 | 	{R0} PUSH_ALWAYS                ; Put argv on the stack
 23 | 
 24 | 	;; Prepare envp
 25 | 	'0' BP R0 NO_SHIFT MOVE_ALWAYS  ; Address we need to load from
 26 | 	!0 R0 LOAD32 R0 MEMORY          ; Get ARGC
 27 | 	!2 R0 ADD R0 ARITH_ALWAYS       ; OFFSET = ARGC + 2
 28 | 	'0' R0 R0 '1' MOVE_ALWAYS       ; OFFSET = OFFSET * WORDSIZE
 29 | 	'0' R0 R0 ADD BP ARITH2_ALWAYS  ; ENVP_address = BP + OFFSET
 30 | 	{R0} PUSH_ALWAYS                ; Put envp on the stack
 31 | 
 32 | 	;; Stack offset
 33 | 	!4 BP ADD BP ARITH_ALWAYS       ; Fix BP
 34 | 
 35 | 	^~FUNCTION___init_malloc CALL_ALWAYS ; Setup for malloc
 36 | 
 37 | 	^~FUNCTION___init_io CALL_ALWAYS ; Setup for FILE*
 38 | 
 39 | 	^~FUNCTION_main CALL_ALWAYS     ; Jump right into main
 40 | 
 41 | 	{R1} POP_ALWAYS                 ; Fix stack
 42 | 	{R1} POP_ALWAYS                 ; Fix stack
 43 | 	{R1} POP_ALWAYS                 ; Fix stack
 44 | 	{R0} PUSH_ALWAYS                ; put return on the stack
 45 | 	{R0} PUSH_ALWAYS                ; So that _exit will have it
 46 | 	{R0} PUSH_ALWAYS                ; So that _exit will have it
 47 | 
 48 | :FUNCTION_exit
 49 | 	^~FUNCTION___kill_io CALL_ALWAYS
 50 | 
 51 | :FUNCTION__exit
 52 | 	!4 R0 SUB R12 ARITH_ALWAYS
 53 | 	!0 R0 LOAD32 R0 MEMORY
 54 | 	!1 R7 LOADI8_ALWAYS
 55 | 	SYSCALL_ALWAYS                  ; exit
 56 | 
 57 | # Unsigned Divide
 58 | :divide
 59 | 	{R4} PUSH_ALWAYS                ; Protect R4
 60 | 	{R3} PUSH_ALWAYS                ; Protect R3
 61 | 	{R2} PUSH_ALWAYS                ; Protect R2
 62 | 
 63 | 	'0' R0 R3 NO_SHIFT MOVE_ALWAYS  ; MOV R3,R0
 64 | 	'0' R1 R2 NO_SHIFT MOVE_ALWAYS  ; MOV R2,R1
 65 | 
 66 | 	!0 R0 LOADI8_ALWAYS             ; MOV R0,#0
 67 | 	!0 CMPI8 R2 IMM_ALWAYS          ; CMP R2,#0
 68 | 	!1 R0 SUB R0 ARITH_LT           ; SUBLT R0,R0,#1
 69 | 	!0 CMPI8 R3 IMM_ALWAYS          ; CMP R3,#0
 70 | 	!0 R3 RSUB R3 ARITH_LT          ; RSBLT R3,R3,#0
 71 | 	'0' R0 R0 MVN_LT                ; MVNLT R0,R0
 72 | 	'0' R0 R4 NO_SHIFT MOVE_ALWAYS  ; MOV R4,R0
 73 | 
 74 | 	!32 R0 LOADI8_ALWAYS            ; MOV  R0,#32.
 75 | 	!0 R1 LOADI8_ALWAYS             ; MOV  R1,#0
 76 | :divide_loop
 77 | 	'0' R2 R2 ADDS R2 ARITH2_ALWAYS ; ADDS R2,R2,R2
 78 | 	'0' R1 R1 ADCS R1 ARITH2_ALWAYS ; ADCS R1,R1,R1
 79 | 	'0' R3 CMP R1 AUX_ALWAYS        ; CMP  R1,R3
 80 | 	'0' R3 R1 SUB R1 ARITH2_GE      ; SUBGE  R1,R1,R3
 81 | 	!1 R2 ADD R2 ARITH_GE           ; ADDGE  R2,R2,#1
 82 | 	!1 R0 SUB R0 ARITH_ALWAYS       ; SUB  R0,R0,#1
 83 | 	!0 CMPI8 R0 IMM_ALWAYS          ; CMP  R0,#0
 84 | 	^~divide_loop JUMP_NE           ; BNE  loop
 85 | 
 86 | 	'0' R2 R0 NO_SHIFT MOVE_ALWAYS  ; MOV R0,R2
 87 | 
 88 | 	{R2} POP_ALWAYS                 ; Restore R2
 89 | 	{R3} POP_ALWAYS                 ; Restore R3
 90 | 	{R4} POP_ALWAYS                 ; Restore R4
 91 | 	'1' LR RETURN
 92 | 
 93 | # Signed Divide
 94 | :divides
 95 | 	{R4} PUSH_ALWAYS                ; Protect R4
 96 | 	{R3} PUSH_ALWAYS                ; Protect R3
 97 | 	{R2} PUSH_ALWAYS                ; Protect R2
 98 | 
 99 | 	'0' R0 R3 NO_SHIFT MOVE_ALWAYS  ; MOV R3,R0
100 | 	'0' R1 R2 NO_SHIFT MOVE_ALWAYS  ; MOV R2,R1
101 | 
102 | 	!0 R0 LOADI8_ALWAYS             ; MOV R0,#0
103 | 	!0 CMPI8 R2 IMM_ALWAYS          ; CMP R2,#0
104 | 	!0 R2 RSUB R2 ARITH_LT          ; RSBLT R2,R2,#0
105 | 	!1 R0 SUB R0 ARITH_LT           ; SUBLT R0,R0,#1
106 | 	!0 CMPI8 R3 IMM_ALWAYS          ; CMP R3,#0
107 | 	!0 R3 RSUB R3 ARITH_LT          ; RSBLT R3,R3,#0
108 | 	'0' R0 R0 MVN_LT                ; MVNLT R0,R0
109 | 	'0' R0 R4 NO_SHIFT MOVE_ALWAYS  ; MOV R4,R0
110 | 
111 | 	!32 R0 LOADI8_ALWAYS            ; MOV  R0,#32.
112 | 	!0 R1 LOADI8_ALWAYS             ; MOV  R1,#0
113 | :divides_loop
114 | 	'0' R2 R2 ADDS R2 ARITH2_ALWAYS ; ADDS R2,R2,R2
115 | 	'0' R1 R1 ADCS R1 ARITH2_ALWAYS ; ADCS R1,R1,R1
116 | 	'0' R3 CMP R1 AUX_ALWAYS        ; CMP  R1,R3
117 | 	'0' R3 R1 SUB R1 ARITH2_GE      ; SUBGE  R1,R1,R3
118 | 	!1 R2 ADD R2 ARITH_GE           ; ADDGE  R2,R2,#1
119 | 	!1 R0 SUB R0 ARITH_ALWAYS       ; SUB  R0,R0,#1
120 | 	!0 CMPI8 R0 IMM_ALWAYS          ; CMP  R0,#0
121 | 	^~divides_loop JUMP_NE          ; BNE  loop
122 | 
123 | 	!0 CMPI8 R4 IMM_ALWAYS          ; CMP R4,#0
124 | 	!0 R2 RSUB R2 ARITH_NE          ; RSBNE R2,R2,#0
125 | 	'0' R2 R0 NO_SHIFT MOVE_ALWAYS  ; MOV R0,R2
126 | 
127 | 	{R2} POP_ALWAYS                 ; Restore R2
128 | 	{R3} POP_ALWAYS                 ; Restore R3
129 | 	{R4} POP_ALWAYS                 ; Restore R4
130 | 	'1' LR RETURN
131 | 
132 | # Unsigned Modulus
133 | :modulus
134 | 	{LR} PUSH_ALWAYS                ; Prepare to leverage divide
135 | 	^~divide CALL_ALWAYS            ; Use divide
136 | 	'0' R1 R0 NO_SHIFT MOVE_ALWAYS  ; MOV R0,R1
137 | 	{LR} POP_ALWAYS                 ; Prepare for return
138 | 	'1' LR RETURN
139 | 
140 | # Signed Modulus
141 | :moduluss
142 | 	{LR} PUSH_ALWAYS                ; Prepare to leverage divide
143 | 	^~divides CALL_ALWAYS           ; Use divides
144 | 	'0' R1 R0 NO_SHIFT MOVE_ALWAYS  ; MOV R0,R1
145 | 	{LR} POP_ALWAYS                 ; Prepare for return
146 | 	'1' LR RETURN
147 | 
148 | :GLOBAL__envp
149 | 	NULL
150 | 


--------------------------------------------------------------------------------
/armv7l/linux/bootstrap.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | enum
 19 | {
 20 | 	stdin = 0,
 21 | 	stdout = 1,
 22 | 	stderr = 2,
 23 | };
 24 | 
 25 | enum
 26 | {
 27 | 	EOF = 0xFFFFFFFF,
 28 | 	NULL = 0,
 29 | };
 30 | 
 31 | enum
 32 | {
 33 | 	EXIT_FAILURE = 1,
 34 | 	EXIT_SUCCESS = 0,
 35 | };
 36 | 
 37 | enum
 38 | {
 39 | 	TRUE = 1,
 40 | 	FALSE = 0,
 41 | };
 42 | 
 43 | 
 44 | int fgetc(FILE* f)
 45 | {
 46 | 	asm("!4 R0 SUB R12 ARITH_ALWAYS"
 47 | 	    "!0 R0 LOAD32 R0 MEMORY"
 48 | 	    "{R0} PUSH_ALWAYS"
 49 | 	    "'0' SP R1 NO_SHIFT MOVE_ALWAYS"
 50 | 	    "!1 R2 LOADI8_ALWAYS"
 51 | 	    "!3 R7 LOADI8_ALWAYS"
 52 | 	    "SYSCALL_ALWAYS"
 53 | 	    "!0 CMPI8 R0 IMM_ALWAYS"
 54 | 	    "{R0} POP_ALWAYS"
 55 | 	    "!0 R0 MVNI8_EQUAL");
 56 | }
 57 | 
 58 | void fputc(char s, FILE* f)
 59 | {
 60 | 	asm("!8 R0 SUB R12 ARITH_ALWAYS"
 61 | 	    "!0 R0 LOAD32 R0 MEMORY"
 62 | 	    "!4 R1 SUB R12 ARITH_ALWAYS"
 63 | 	    "!1 R2 LOADI8_ALWAYS"
 64 | 	    "!4 R7 LOADI8_ALWAYS"
 65 | 	    "SYSCALL_ALWAYS");
 66 | }
 67 | 
 68 | void fputs(char* s, FILE* f)
 69 | {
 70 | 	while(0 != s[0])
 71 | 	{
 72 | 		fputc(s[0], f);
 73 | 		s = s + 1;
 74 | 	}
 75 | }
 76 | 
 77 | FILE* open(char* name, int flag, int mode)
 78 | {
 79 | 	asm("!4 R0 SUB R12 ARITH_ALWAYS"
 80 | 	    "!0 R0 LOAD32 R0 MEMORY"
 81 | 	    "!8 R1 SUB R12 ARITH_ALWAYS"
 82 | 	    "!0 R1 LOAD32 R1 MEMORY"
 83 | 	    "!12 R2 SUB R12 ARITH_ALWAYS"
 84 | 	    "!0 R2 LOAD32 R2 MEMORY"
 85 | 	    "!5 R7 LOADI8_ALWAYS"
 86 | 	    "SYSCALL_ALWAYS");
 87 | }
 88 | 
 89 | FILE* fopen(char* filename, char* mode)
 90 | {
 91 | 	FILE* f;
 92 | 	if('w' == mode[0])
 93 | 	{ /* 577 is O_WRONLY|O_CREAT|O_TRUNC, 384 is 600 in octal */
 94 | 		f = open(filename, 577 , 384);
 95 | 	}
 96 | 	else
 97 | 	{ /* Everything else is a read */
 98 | 		f = open(filename, 0, 0);
 99 | 	}
100 | 
101 | 	/* Negative numbers are error codes */
102 | 	if(0 > f)
103 | 	{
104 | 		return 0;
105 | 	}
106 | 	return f;
107 | }
108 | 
109 | int close(int fd)
110 | {
111 | 	asm("!4 R0 SUB R12 ARITH_ALWAYS"
112 | 	    "!6 R7 LOADI8_ALWAYS"
113 | 	    "SYSCALL_ALWAYS");
114 | }
115 | 
116 | int fclose(FILE* stream)
117 | {
118 | 	int error = close(stream);
119 | 	return error;
120 | }
121 | 
122 | int brk(void *addr)
123 | {
124 | 	asm("!4 R0 SUB R12 ARITH_ALWAYS"
125 | 	    "!0 R0 LOAD32 R0 MEMORY"
126 | 	    "!45 R7 LOADI8_ALWAYS"
127 | 	    "SYSCALL_ALWAYS");
128 | }
129 | 
130 | long _malloc_ptr;
131 | long _brk_ptr;
132 | 
133 | void* malloc(int size)
134 | {
135 | 	if(NULL == _brk_ptr)
136 | 	{
137 | 		_brk_ptr = brk(0);
138 | 		_malloc_ptr = _brk_ptr;
139 | 	}
140 | 
141 | 	if(_brk_ptr < _malloc_ptr + size)
142 | 	{
143 | 		_brk_ptr = brk(_malloc_ptr + size);
144 | 		if(-1 == _brk_ptr) return 0;
145 | 	}
146 | 
147 | 	long old_malloc = _malloc_ptr;
148 | 	_malloc_ptr = _malloc_ptr + size;
149 | 	return old_malloc;
150 | }
151 | 
152 | int strlen(char* str )
153 | {
154 | 	int i = 0;
155 | 	while(0 != str[i]) i = i + 1;
156 | 	return i;
157 | }
158 | 
159 | void* memset(void* ptr, int value, int num)
160 | {
161 | 	char* s;
162 | 	for(s = ptr; 0 < num; num = num - 1)
163 | 	{
164 | 		s[0] = value;
165 | 		s = s + 1;
166 | 	}
167 | }
168 | 
169 | void* calloc(int count, int size)
170 | {
171 | 	void* ret = malloc(count * size);
172 | 	if(NULL == ret) return NULL;
173 | 	memset(ret, 0, (count * size));
174 | 	return ret;
175 | }
176 | 
177 | void free(void* l)
178 | {
179 | 	return;
180 | }
181 | 
182 | void exit(int value)
183 | {
184 | 	asm("!4 R0 SUB R12 ARITH_ALWAYS"
185 | 	    "!0 R0 LOAD32 R0 MEMORY"
186 | 	    "!1 R7 LOADI8_ALWAYS"
187 | 	    "SYSCALL_ALWAYS");
188 | }
189 | 


--------------------------------------------------------------------------------
/armv7l/linux/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef __FCNTL_C
19 | #define __FCNTL_C
20 | 
21 | #define O_RDONLY 0
22 | #define O_WRONLY 1
23 | #define O_RDWR 2
24 | #define O_CREAT 00100
25 | #define O_EXCL 00200
26 | #define O_TRUNC 001000
27 | #define O_APPEND 002000
28 | 
29 | #define S_IXUSR 00100
30 | #define S_IWUSR 00200
31 | #define S_IRUSR 00400
32 | #define S_IRWXU 00700
33 | 
34 | 
35 | int _open(char* name, int flag, int mode)
36 | {
37 | 	asm("!4 R0 SUB R12 ARITH_ALWAYS"
38 | 	    "!0 R0 LOAD32 R0 MEMORY"
39 | 	    "!8 R1 SUB R12 ARITH_ALWAYS"
40 | 	    "!0 R1 LOAD32 R1 MEMORY"
41 | 	    "!12 R2 SUB R12 ARITH_ALWAYS"
42 | 	    "!0 R2 LOAD32 R2 MEMORY"
43 | 	    "!5 R7 LOADI8_ALWAYS"
44 | 	    "SYSCALL_ALWAYS");
45 | }
46 | 
47 | #define STDIN_FILENO  0
48 | #define STDOUT_FILENO 1
49 | #define STDERR_FILENO 2
50 | #endif
51 | 


--------------------------------------------------------------------------------
/armv7l/linux/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYS_STAT_C
19 | #define _SYS_STAT_C
20 | 
21 | #include <sys/types.h>
22 | 
23 | #define S_IRWXU 00700
24 | #define S_IXUSR 00100
25 | #define S_IWUSR 00200
26 | #define S_IRUSR 00400
27 | 
28 | #define S_ISUID 04000
29 | #define S_ISGID 02000
30 | #define S_IXGRP 00010
31 | #define S_IXOTH 00001
32 | #define S_IRGRP 00040
33 | #define S_IROTH 00004
34 | #define S_IWGRP 00020
35 | #define S_IWOTH 00002
36 | #define S_IRWXG 00070
37 | #define S_IRWXO 00007
38 | 
39 | 
40 | int chmod(char *pathname, int mode)
41 | {
42 | 	asm("!15 R7 LOADI8_ALWAYS"
43 | 	    "!8 R1 SUB R12 ARITH_ALWAYS"
44 | 	    "!0 R1 LOAD32 R1 MEMORY"
45 | 	    "!4 R0 SUB R12 ARITH_ALWAYS"
46 | 	    "!0 R0 LOAD32 R0 MEMORY"
47 | 	    "SYSCALL_ALWAYS");
48 | }
49 | 
50 | 
51 | int fchmod(int a, mode_t b)
52 | {
53 | 	asm("!94 R7 LOADI8_ALWAYS"
54 | 	    "!8 R1 SUB R12 ARITH_ALWAYS"
55 | 	    "!0 R1 LOAD32 R1 MEMORY"
56 | 	    "!4 R0 SUB R12 ARITH_ALWAYS"
57 | 	    "!0 R0 LOAD32 R0 MEMORY"
58 | 	    "SYSCALL_ALWAYS");
59 | }
60 | 
61 | 
62 | int mkdir(char const* a, mode_t b)
63 | {
64 | 	asm("!39 R7 LOADI8_ALWAYS"
65 | 	    "!8 R1 SUB R12 ARITH_ALWAYS"
66 | 	    "!0 R1 LOAD32 R1 MEMORY"
67 | 	    "!4 R0 SUB R12 ARITH_ALWAYS"
68 | 	    "!0 R0 LOAD32 R0 MEMORY"
69 | 	    "SYSCALL_ALWAYS");
70 | }
71 | 
72 | 
73 | int mknod(char const* a, mode_t b, dev_t c)
74 | {
75 | 	asm("!14 R7 LOADI8_ALWAYS"
76 | 	    "!12 R2 SUB R12 ARITH_ALWAYS"
77 | 	    "!0 R2 LOAD32 R2 MEMORY"
78 | 	    "!8 R1 SUB R12 ARITH_ALWAYS"
79 | 	    "!0 R1 LOAD32 R1 MEMORY"
80 | 	    "!4 R0 SUB R12 ARITH_ALWAYS"
81 | 	    "!0 R0 LOAD32 R0 MEMORY"
82 | 	    "SYSCALL_ALWAYS");
83 | }
84 | 
85 | 
86 | mode_t umask(mode_t m)
87 | {
88 | 	asm("!60 R7 LOADI8_ALWAYS"
89 | 	    "!4 R0 SUB R12 ARITH_ALWAYS"
90 | 	    "!0 R0 LOAD32 R0 MEMORY"
91 | 	    "SYSCALL_ALWAYS");
92 | }
93 | #endif
94 | 


--------------------------------------------------------------------------------
/bootstrappable.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | #include <stdio.h>
 19 | #include <stdlib.h>
 20 | 
 21 | 
 22 | #define TRUE 1
 23 | #define FALSE 0
 24 | 
 25 | 
 26 | void require(int bool, char* error)
 27 | {
 28 | 	if(!bool)
 29 | 	{
 30 | 		fputs(error, stderr);
 31 | 		exit(EXIT_FAILURE);
 32 | 	}
 33 | }
 34 | 
 35 | 
 36 | int match(char* a, char* b)
 37 | {
 38 | 	if((NULL == a) && (NULL == b)) return TRUE;
 39 | 	if(NULL == a) return FALSE;
 40 | 	if(NULL == b) return FALSE;
 41 | 
 42 | 	int i = -1;
 43 | 	do
 44 | 	{
 45 | 		i = i + 1;
 46 | 		if(a[i] != b[i])
 47 | 		{
 48 | 			return FALSE;
 49 | 		}
 50 | 	} while((0 != a[i]) && (0 !=b[i]));
 51 | 	return TRUE;
 52 | }
 53 | 
 54 | 
 55 | int in_set(int c, char* s)
 56 | {
 57 | 	/* NULL set is always false */
 58 | 	if(NULL == s) return FALSE;
 59 | 
 60 | 	while(0 != s[0])
 61 | 	{
 62 | 		if(c == s[0]) return TRUE;
 63 | 		s = s + 1;
 64 | 	}
 65 | 	return FALSE;
 66 | }
 67 | 
 68 | /* INTERNAL ONLY */
 69 | int __index_number(char* s, char c)
 70 | {
 71 | 	int i = 0;
 72 | 	while(s[i] != c)
 73 | 	{
 74 | 		i = i + 1;
 75 | 		if(0 == s[i]) return -1;
 76 | 	}
 77 | 	return i;
 78 | }
 79 | 
 80 | /* INTERNAL ONLY */
 81 | int __toupper(int c)
 82 | {
 83 | 	if(in_set(c, "abcdefghijklmnopqrstuvwxyz")) return (c & 0xDF);
 84 | 	return c;
 85 | }
 86 | 
 87 | /* INTERNAL ONLY */
 88 | int __set_reader(char* set, int mult, char* input)
 89 | {
 90 | 	int n = 0;
 91 | 	int i = 0;
 92 | 	int hold;
 93 | 	int negative_p = FALSE;
 94 | 
 95 | 	if(input[0] == '-')
 96 | 	{
 97 | 		negative_p = TRUE;
 98 | 		i = i + 1;
 99 | 	}
100 | 
101 | 	while(in_set(input[i], set))
102 | 	{
103 | 		if('_' == input[i])
104 | 		{
105 | 			i = i + 1;
106 | 			continue;
107 | 		}
108 | 
109 | 		n = n * mult;
110 | 		hold = __index_number(set, __toupper(input[i]));
111 | 
112 | 		/* Input managed to change between in_set and index_number */
113 | 		if(-1 == hold) return 0;
114 | 		n = n + hold;
115 | 		i = i + 1;
116 | 	}
117 | 
118 | 	/* loop exited before NULL and thus invalid input */
119 | 	if(0 != input[i]) return 0;
120 | 
121 | 	if(negative_p)
122 | 	{
123 | 		n = 0 - n;
124 | 	}
125 | 
126 | 	return n;
127 | }
128 | 
129 | int strtoint(char *a)
130 | {
131 | 	int result = 0;
132 | 	/* If NULL string */
133 | 	if(0 == a[0])
134 | 	{
135 | 		result = 0;
136 | 	}
137 | 	/* Deal with binary */
138 | 	else if ('0' == a[0] && 'b' == a[1])
139 | 	{
140 | 		result = __set_reader("01_", 2, a+2);
141 | 	}
142 | 	/* Deal with hex */
143 | 	else if ('0' == a[0] &&  'x' == a[1])
144 | 	{
145 | 		result = __set_reader("0123456789ABCDEFabcdef_", 16, a+2);
146 | 	}
147 | 	/* Deal with octal */
148 | 	else if('0' == a[0])
149 | 	{
150 | 		result = __set_reader("01234567_", 8, a+1);
151 | 	}
152 | 	/* Deal with decimal */
153 | 	else
154 | 	{
155 | 		result = __set_reader("0123456789_", 10, a);
156 | 	}
157 | 
158 | 	/* Deal with sign extension for 64bit hosts */
159 | 	if(0 != (0x80000000 & result)) result = (0xFFFFFFFF << 31) | result;
160 | 	return result;
161 | }
162 | 
163 | char* int2str(int x, int base, int signed_p)
164 | {
165 | 	require(1 < base, "int2str doesn't support a base less than 2\n");
166 | 	require(37 > base, "int2str doesn't support a base more than 36\n");
167 | 	/* Be overly conservative and save space for 32binary digits and padding null */
168 | 	char* p = calloc(34, sizeof(char));
169 | 	/* if calloc fails return null to let calling code deal with it */
170 | 	if(NULL == p) return p;
171 | 
172 | 	p = p + 32;
173 | 	unsigned i;
174 | 	int sign_p = FALSE;
175 | 	char* table = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
176 | 
177 | 	if(signed_p && (10 == base) && (0 != (x & 0x80000000)))
178 | 	{
179 | 		/* Truncate to 31bits */
180 | 		i = -x & 0x7FFFFFFF;
181 | 		if(0 == i) return "-2147483648";
182 | 		sign_p = TRUE;
183 | 	} /* Truncate to 32bits */
184 | 	else i = x & (0x7FFFFFFF + 0x80000000); /* M2-Planet/cc_* can't handle large signed numbers in literals */
185 | 
186 | 	do
187 | 	{
188 | 		p[0] = table[i % base];
189 | 		p = p - 1;
190 | 		i = i / base;
191 | 	} while(0 < i);
192 | 
193 | 	if(sign_p)
194 | 	{
195 | 		p[0] = '-';
196 | 		p = p - 1;
197 | 	}
198 | 
199 | 	return p + 1;
200 | }
201 | 


--------------------------------------------------------------------------------
/bootstrappable.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _BOOTSTRAPPABLE_H
19 | #define _BOOTSTRAPPABLE_H
20 | 
21 | /* Essential common CONSTANTS*/
22 | #define TRUE 1
23 | #define FALSE 0
24 | 
25 | #ifdef __M2__
26 | #include <bootstrappable.c>
27 | #else
28 | /* Universally useful functions */
29 | void require(int bool, char* error);
30 | int match(char* a, char* b);
31 | int in_set(int c, char* s);
32 | int strtoint(char *a);
33 | char* int2str(int x, int base, int signed_p);
34 | 
35 | #endif
36 | #endif
37 | 


--------------------------------------------------------------------------------
/ctype.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2022 Andrius Štikonas
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | int isspace(char _c)
19 | {
20 | 	return _c == ' ' || _c - '\t' < 5;
21 | }
22 | 
23 | int isdigit(int _c)
24 | {
25 | 	return _c <= '9' && _c >= '0';
26 | }
27 | 
28 | 


--------------------------------------------------------------------------------
/ctype.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2022 Andrius Štikonas
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | 
19 | #ifndef _CTYPE_H
20 | #define _CTYPE_H
21 | 
22 | #ifdef __M2__
23 | #include <ctype.c>
24 | #else
25 | #endif
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _FCNTL_C
19 | #define _FCNTL_C
20 | 
21 | #ifdef __M2__
22 | #if __uefi__
23 | #include <uefi/fcntl.c>
24 | #elif __i386__
25 | #include <x86/linux/fcntl.c>
26 | #elif __x86_64__
27 | #include <amd64/linux/fcntl.c>
28 | #elif __arm__
29 | #include <armv7l/linux/fcntl.c>
30 | #elif __aarch64__
31 | #include <aarch64/linux/fcntl.c>
32 | #elif __riscv && __riscv_xlen==32
33 | #include <riscv32/linux/fcntl.c>
34 | #elif __riscv && __riscv_xlen==64
35 | #include <riscv64/linux/fcntl.c>
36 | #elif __knight_posix__
37 | #include <knight/linux/fcntl.c>
38 | #elif __knight__
39 | #include <knight/native/fcntl.c>
40 | #else
41 | #error arch not supported
42 | #endif
43 | #else
44 | extern int _open(char* name, int flag, int mode);
45 | #endif
46 | 
47 | int errno;
48 | 
49 | int open(char* name, int flag, int mode)
50 | {
51 | 	int fd = _open(name, flag, mode);
52 | 	if(0 > fd)
53 | 	{
54 | 		errno = -fd;
55 | 		fd = -1;
56 | 	}
57 | 	return fd;
58 | }
59 | 
60 | #endif
61 | 


--------------------------------------------------------------------------------
/fcntl.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _FCNTL_H
19 | #define _FCNTL_H
20 | 
21 | #ifdef __M2__
22 | #include <sys/types.h>
23 | #include <stddef.h>
24 | #include <fcntl.c>
25 | #else
26 | #define O_RDONLY 0
27 | #define O_WRONLY 1
28 | #define O_RDWR 2
29 | #define O_CREAT 00100
30 | #define O_EXCL 00200
31 | #define O_TRUNC 001000
32 | #define O_APPEND 002000
33 | 
34 | #define S_IXUSR 00100
35 | #define S_IWUSR 00200
36 | #define S_IRUSR 00400
37 | #define S_IRWXU 00700
38 | 
39 | 
40 | extern int open(char* name, int flag, int mode);
41 | 
42 | #define STDIN_FILENO  0
43 | #define STDOUT_FILENO 1
44 | #define STDERR_FILENO 2
45 | #endif
46 | #endif
47 | 


--------------------------------------------------------------------------------
/gcc_req.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | typedef unsigned long SCM;
19 | 


--------------------------------------------------------------------------------
/iso646.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2025 Gtker
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _STDISO646_H
19 | #define _STDISO646_H
20 | 
21 | #define and    &&
22 | #define and_eq &=
23 | #define bitand &
24 | #define bitor  |
25 | #define compl  ~
26 | #define not    !
27 | #define not_eq !=
28 | #define or     ||
29 | #define or_eq  |=
30 | #define xor    ^
31 | #define xor_eq ^=
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/knight/ELF-knight.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### stage0's hex2 format
19 | ###    !<label>          1 byte relative
20 | ###    $<label>          2 byte address
21 | ###    @<label>          2 byte relative
22 | ###    &<label>          4 byte address
23 | ###    %<label>          4 byte relative
24 | 
25 | ### if you wish to use this header, you need to add :ELF_end to the end of your
26 | ### M1 or hex2 files.
27 | 


--------------------------------------------------------------------------------
/knight/libc-core.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2016 Jeremiah Orians
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 	;; Kernel Setup R12 as HEAP pointer after end of the stack
19 | 	;; Kernel Setup R15 as Stack pointer after the initial stack frame
20 | 
21 | 	;; Default stack frame is:
22 | 	;; ARGC, ARGV, ENVP, NULL
23 | 
24 | 	SUBI R14 R15 16             ; Set our base pointer
25 | 
26 | 	;; Perform the main loop
27 | 	LOADR R0 4
28 | 	JUMP 4
29 | 	&FUNCTION_main
30 | 	CALL R0 R15
31 | 
32 | 	COPY R14 R15                ; Setup base pointer
33 | 	PUSHR R0 R15                ; Put return on the stack
34 | 
35 | :FUNCTION_exit
36 | :FUNCTION__exit
37 | 	LOAD R0 R14 0
38 | 	SYS_EXIT
39 | 


--------------------------------------------------------------------------------
/knight/libc-full.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2016 Jeremiah Orians
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 	;; Kernel Setup R12 as HEAP pointer after end of the stack
19 | 	;; Kernel Setup R15 as Stack pointer after the initial stack frame
20 | 
21 | 	;; Default stack frame is:
22 | 	;; ARGC, ARGV, ENVP, NULL
23 | 
24 | 	SUBI R14 R15 16             ; Set our base pointer
25 | 
26 | 	;; Setup for malloc
27 | 	LOADR R0 4
28 | 	JUMP 4
29 | 	&FUNCTION___init_malloc
30 | 	CALL R0 R15
31 | 
32 | 	;; Setup for FILE*
33 | 	LOADR R0 4
34 | 	JUMP 4
35 | 	&FUNCTION___init_io
36 | 	CALL R0 R15
37 | 
38 | 	;; Perform the main loop
39 | 	LOADR R0 4
40 | 	JUMP 4
41 | 	&FUNCTION_main
42 | 	CALL R0 R15
43 | 
44 | 	COPY R14 R15                ; Setup base pointer
45 | 	PUSHR R0 R15                ; Put return on the stack
46 | 
47 | :FUNCTION_exit
48 | 	LOADR R0 4
49 | 	JUMP 4
50 | 	&FUNCTION___kill_io
51 | 	CALL R0 R15
52 | 
53 | :FUNCTION__exit
54 | 	LOAD R0 R14 0
55 | 	SYS_EXIT
56 | 
57 | :GLOBAL__envp
58 | 	NULL
59 | 


--------------------------------------------------------------------------------
/knight/libc-native-file.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2016 Jeremiah Orians
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 	;; Prep TAPE_02
19 | 	LOADUI R0 0x1101
20 | 	FOPEN_WRITE
21 | 
22 | 	;; Prep TAPE_01
23 | 	LOADUI R0 0x1100
24 | 	FOPEN_READ
25 | 
26 | 	LOADR R15 4
27 | 	JUMP 4
28 | 	&STACK                      ; Setup initial stack pointer
29 | 	COPY R14 R15                ; Setup initial base pointer
30 | 
31 | 	LOADR32 R12 @HEAP           ; Setup HEAP pointer
32 | 	ADD R12 R12 R15             ; After Stack ends
33 | 
34 | 	;; Setup for FILE*
35 | 	LOADR R0 4
36 | 	JUMP 4
37 | 	&FUNCTION___init_io
38 | 	CALL R0 R15
39 | 
40 | 	LOADR R0 4
41 | 	JUMP 4
42 | 	&FUNCTION_main
43 | 	CALL R0 R15
44 | 
45 | :FUNCTION_exit
46 | 	LOADR R0 4
47 | 	JUMP 4
48 | 	&FUNCTION___kill_io
49 | 	CALL R0 R15
50 | 
51 | :FUNCTION__exit
52 | 	HALT                        ; Stop the machine
53 | 
54 | 	;; Our default heap offset (how big our stack ia)
55 | :HEAP
56 | 	'00100000'
57 | 


--------------------------------------------------------------------------------
/knight/libc-native.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2016 Jeremiah Orians
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 	; Setup initial stack pointer
19 | 	LOADR R15 4
20 | 	JUMP 4
21 | 	&STACK
22 | 
23 | 	LOADR32 R12 @HEAP           ; Setup HEAP pointer
24 | 	ADD R12 R12 R15             ; After Stack
25 | 
26 | 	; Setup initial base pointer
27 | 	COPY R14 R15
28 | 
29 | 	; Perform the main loop
30 | 	LOADR R0 4
31 | 	JUMP 4
32 | 	&FUNCTION_main
33 | 	CALL R0 R15
34 | 
35 | :FUNCTION_exit
36 | :FUNCTION__exit
37 | 	HALT                        ; Stop the machine
38 | 
39 | 	;; Our default heap pointer (offset from start of stack)
40 | :HEAP
41 | 	'00100000'
42 | 


--------------------------------------------------------------------------------
/knight/linux/bootstrap.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | enum
 19 | {
 20 | 	stdin = 0,
 21 | 	stdout = 1,
 22 | 	stderr = 2,
 23 | };
 24 | 
 25 | enum
 26 | {
 27 | 	EOF = 0xFFFFFFFF,
 28 | 	NULL = 0,
 29 | };
 30 | 
 31 | enum
 32 | {
 33 | 	EXIT_FAILURE = 1,
 34 | 	EXIT_SUCCESS = 0,
 35 | };
 36 | 
 37 | enum
 38 | {
 39 | 	TRUE = 1,
 40 | 	FALSE = 0,
 41 | };
 42 | 
 43 | 
 44 | int fgetc(FILE* f)
 45 | {
 46 | 	asm("LOAD R0 R14 0"
 47 | 	    "LOADI R1 -1"
 48 | 	    "COPY R2 R15"
 49 | 	    "PUSHR R1 R15"
 50 | 	    "MOVE R1 R2"
 51 | 	    "LOADI R2 1"
 52 | 	    "SYS_READ"
 53 | 	    "POPR R1 R15"
 54 | 	    "JUMP.Z R0 @FUNCTION_FGETC_DONE"
 55 | 	    "SR0I R1 24"
 56 | 	    ":FUNCTION_FGETC_DONE"
 57 | 	    "MOVE R0 R1");
 58 | }
 59 | 
 60 | void fputc(char s, FILE* f)
 61 | {
 62 | 	asm("LOAD R0 R14 0"
 63 | 	    "SL0I R0 24"
 64 | 	    "COPY R1 R15"
 65 | 	    "PUSHR R0 R15"
 66 | 	    "LOAD R0 R14 4"
 67 | 	    "LOADI R2 1"
 68 | 	    "SYS_WRITE"
 69 | 	    "POPR R1 R15");
 70 | }
 71 | 
 72 | void fputs(char* s, FILE* f)
 73 | {
 74 | 	while(0 != s[0])
 75 | 	{
 76 | 		fputc(s[0], f);
 77 | 		s = s + 1;
 78 | 	}
 79 | }
 80 | 
 81 | FILE* open(char* name, int flag, int mode)
 82 | {
 83 | 	asm("LOAD R0 R14 0"
 84 | 	    "LOAD R1 R14 4"
 85 | 	    "LOAD R2 R14 8"
 86 | 	    "SYS_OPEN"
 87 | 	    "FALSE R2");
 88 | }
 89 | 
 90 | FILE* fopen(char* filename, char* mode)
 91 | {
 92 | 	FILE* f;
 93 | 	if('w' == mode[0])
 94 | 	{ /* 577 is O_WRONLY|O_CREAT|O_TRUNC, 384 is 600 in octal */
 95 | 		f = open(filename, 577 , 384);
 96 | 	}
 97 | 	else
 98 | 	{ /* Everything else is a read */
 99 | 		f = open(filename, 0, 0);
100 | 	}
101 | 
102 | 	/* Negative numbers are error codes */
103 | 	if(0 > f)
104 | 	{
105 | 		return 0;
106 | 	}
107 | 	return f;
108 | }
109 | 
110 | int close(int fd)
111 | {
112 | 	asm("LOAD R0 R14 0"
113 | 	    "SYS_CLOSE");
114 | }
115 | 
116 | int fclose(FILE* stream)
117 | {
118 | 	int error = close(stream);
119 | 	return error;
120 | }
121 | 
122 | int brk(void *addr)
123 | {
124 | 	asm("LOAD R0 R14 0"
125 | 	    "ADDU R0 R12 R0"
126 | 	    "SWAP R0 R12");
127 | }
128 | 
129 | long _malloc_ptr;
130 | long _brk_ptr;
131 | 
132 | void* malloc(int size)
133 | {
134 | 	if(NULL == _brk_ptr)
135 | 	{
136 | 		_brk_ptr = brk(0);
137 | 		_malloc_ptr = _brk_ptr;
138 | 	}
139 | 
140 | 	if(_brk_ptr < _malloc_ptr + size)
141 | 	{
142 | 		_brk_ptr = brk(_malloc_ptr + size);
143 | 		if(-1 == _brk_ptr) return 0;
144 | 	}
145 | 
146 | 	long old_malloc = _malloc_ptr;
147 | 	_malloc_ptr = _malloc_ptr + size;
148 | 	return old_malloc;
149 | }
150 | 
151 | int strlen(char* str )
152 | {
153 | 	int i = 0;
154 | 	while(0 != str[i]) i = i + 1;
155 | 	return i;
156 | }
157 | 
158 | void* memset(void* ptr, int value, int num)
159 | {
160 | 	char* s;
161 | 	for(s = ptr; 0 < num; num = num - 1)
162 | 	{
163 | 		s[0] = value;
164 | 		s = s + 1;
165 | 	}
166 | }
167 | 
168 | void* calloc(int count, int size)
169 | {
170 | 	void* ret = malloc(count * size);
171 | 	if(NULL == ret) return NULL;
172 | 	memset(ret, 0, (count * size));
173 | 	return ret;
174 | }
175 | 
176 | void free(void* l)
177 | {
178 | 	return;
179 | }
180 | 
181 | void exit(int value)
182 | {
183 | 	asm("LOAD R0 R14 0"
184 | 	    "SYS_EXIT");
185 | }
186 | 


--------------------------------------------------------------------------------
/knight/linux/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef __FCNTL_C
19 | #define __FCNTL_C
20 | 
21 | #define O_RDONLY 0
22 | #define O_WRONLY 1
23 | #define O_RDWR 2
24 | #define O_CREAT 00100
25 | #define O_EXCL 00200
26 | #define O_TRUNC 001000
27 | #define O_APPEND 002000
28 | 
29 | #define S_IXUSR 00100
30 | #define S_IWUSR 00200
31 | #define S_IRUSR 00400
32 | #define S_IRWXU 00700
33 | 
34 | 
35 | int _open(char* name, int flag, int mode)
36 | {
37 | 	asm("LOAD R0 R14 0"
38 | 	    "LOAD R1 R14 4"
39 | 	    "LOAD R2 R14 8"
40 | 	    "SYS_OPEN");
41 | }
42 | 
43 | #define STDIN_FILENO  0
44 | #define STDOUT_FILENO 1
45 | #define STDERR_FILENO 2
46 | #endif
47 | 


--------------------------------------------------------------------------------
/knight/linux/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYS_STAT_C
19 | #define _SYS_STAT_C
20 | 
21 | #include <sys/types.h>
22 | 
23 | #define S_IRWXU 00700
24 | #define S_IXUSR 00100
25 | #define S_IWUSR 00200
26 | #define S_IRUSR 00400
27 | 
28 | #define S_ISUID 04000
29 | #define S_ISGID 02000
30 | #define S_IXGRP 00010
31 | #define S_IXOTH 00001
32 | #define S_IRGRP 00040
33 | #define S_IROTH 00004
34 | #define S_IWGRP 00020
35 | #define S_IWOTH 00002
36 | #define S_IRWXG 00070
37 | #define S_IRWXO 00007
38 | 
39 | 
40 | int chmod(char *pathname, int mode)
41 | {
42 | 	asm("LOAD R0 R14 0"
43 | 	    "LOAD R1 R14 4"
44 | 	    "SYS_CHMOD");
45 | }
46 | 
47 | 
48 | int fchmod(int a, mode_t b)
49 | {
50 | 	asm("LOAD R0 R14 0"
51 | 	    "LOAD R1 R14 4"
52 | 	    "SYS_FCHMOD");
53 | }
54 | 
55 | 
56 | int mkdir(char const* a, mode_t b)
57 | {
58 | 	asm("LOAD R0 R14 0"
59 | 	    "LOAD R1 R14 4"
60 | 	    "SYS_MKDIR");
61 | }
62 | 
63 | 
64 | int mknod(char const* a, mode_t b, dev_t c)
65 | {
66 | 	asm("LOAD R0 R14 0"
67 | 	    "LOAD R1 R14 4"
68 | 	    "LOAD R2 R14 8"
69 | 	    "SYS_MKNOD");
70 | }
71 | 
72 | 
73 | mode_t umask(mode_t m)
74 | {
75 | 	asm("LOAD R0 R14 0"
76 | 	    "SYS_UMASK");
77 | }
78 | 
79 | #endif
80 | 


--------------------------------------------------------------------------------
/knight/linux/unistd.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2020 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | #ifndef _UNISTD_C
 19 | #define _UNISTD_C
 20 | #include <sys/utsname.h>
 21 | #define NULL 0
 22 | #define __PATH_MAX 4096
 23 | 
 24 | void* malloc(unsigned size);
 25 | 
 26 | int access(char* pathname, int mode)
 27 | {
 28 | 	asm("LOAD R0 R14 0"
 29 | 	    "LOAD R1 R14 4"
 30 | 	    "SYS_ACCESS");
 31 | }
 32 | 
 33 | int chdir(char* path)
 34 | {
 35 | 	asm("LOAD R0 R14 0"
 36 | 	    "SYS_CHDIR");
 37 | }
 38 | 
 39 | int fchdir(int fd)
 40 | {
 41 | 	asm("LOAD R0 R14 0"
 42 | 	    "SYS_FCHDIR");
 43 | }
 44 | 
 45 | void _exit(int value);
 46 | 
 47 | int fork()
 48 | {
 49 | 	asm("SYS_FORK");
 50 | }
 51 | 
 52 | 
 53 | int waitpid (int pid, int* status_ptr, int options)
 54 | {
 55 | 	/* Uses wait4 with struct rusage *ru set to NULL */
 56 | 	asm("LOAD R0 R14 0"
 57 | 	    "LOAD R1 R14 4"
 58 | 	    "LOAD R2 R14 8"
 59 | 	    "FALSE R3"
 60 | 	    "SYS_WAIT4");
 61 | }
 62 | 
 63 | 
 64 | int execve(char* file_name, char** argv, char** envp)
 65 | {
 66 | 	asm("LOAD R0 R14 0"
 67 | 	    "LOAD R1 R14 4"
 68 | 	    "LOAD R2 R14 8"
 69 | 	    "SYS_EXECVE");
 70 | }
 71 | 
 72 | int read(int fd, char* buf, unsigned count)
 73 | {
 74 | 	asm("LOAD R0 R14 0"
 75 | 	    "LOAD R1 R14 4"
 76 | 	    "LOAD R2 R14 8"
 77 | 	    "SYS_READ");
 78 | }
 79 | 
 80 | int write(int fd, char* buf, unsigned count)
 81 | {
 82 | 	asm("LOAD R0 R14 0"
 83 | 	    "LOAD R1 R14 4"
 84 | 	    "LOAD R2 R14 8"
 85 | 	    "SYS_WRITE");
 86 | }
 87 | 
 88 | int lseek(int fd, int offset, int whence)
 89 | {
 90 | 	asm("LOAD R0 R14 0"
 91 | 	    "LOAD R1 R14 4"
 92 | 	    "LOAD R2 R14 8"
 93 | 	    "SYS_LSEEK");
 94 | }
 95 | 
 96 | int close(int fd)
 97 | {
 98 | 	asm("LOAD R0 R14 0"
 99 | 	    "SYS_CLOSE");
100 | }
101 | 
102 | 
103 | int unlink (char* filename)
104 | {
105 | 	asm("LOAD R0 R14 0"
106 | 	    "SYS_UNLINK");
107 | }
108 | 
109 | int symlink(char *path1, char *path2)
110 | {
111 | 	/* not implemented */
112 | 	return(-1);
113 | }
114 | 
115 | int _getcwd(char* buf, int size)
116 | {
117 | 	asm("LOAD R0 R14 0"
118 | 	    "LOAD R1 R14 4"
119 | 	    "SYS_GETCWD");
120 | }
121 | 
122 | 
123 | char* getcwd(char* buf, unsigned size)
124 | {
125 | 	int c = _getcwd(buf, size);
126 | 	if(0 == c) return NULL;
127 | 	return buf;
128 | }
129 | 
130 | 
131 | char* getwd(char* buf)
132 | {
133 | 	return getcwd(buf, __PATH_MAX);
134 | }
135 | 
136 | 
137 | char* get_current_dir_name()
138 | {
139 | 	return getcwd(malloc(__PATH_MAX), __PATH_MAX);
140 | }
141 | 
142 | /********************************************************************************
143 |  * All memory past the text segment and stack are always allocated to heap      *
144 |  * purposes and thus no syscalls are needed for brk                             *
145 |  ********************************************************************************/
146 | int brk(void *addr)
147 | {
148 | 	asm("LOAD R0 R14 0"
149 | 	    "ADDU R0 R12 R0"
150 | 	    "SWAP R0 R12");
151 | }
152 | 
153 | int uname(struct utsname* unameData)
154 | {
155 | 	asm("LOAD R0 R14 0"
156 | 	    "SYS_UNAME");
157 | }
158 | 
159 | #endif
160 | 


--------------------------------------------------------------------------------
/knight/native/bootstrap.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | enum
 19 | {
 20 | 	stdin = 0x1100,
 21 | 	stdout = 0x1101,
 22 | 	stderr = 0,
 23 | };
 24 | 
 25 | enum
 26 | {
 27 | 	EOF = 0xFFFFFFFF,
 28 | 	NULL = 0,
 29 | };
 30 | 
 31 | enum
 32 | {
 33 | 	EXIT_FAILURE = 1,
 34 | 	EXIT_SUCCESS = 0,
 35 | };
 36 | 
 37 | enum
 38 | {
 39 | 	TRUE = 1,
 40 | 	FALSE = 0,
 41 | };
 42 | 
 43 | 
 44 | int fgetc(FILE* f)
 45 | {
 46 | 	asm("LOAD R1 R14 0"
 47 | 	    "FGETC");
 48 | }
 49 | 
 50 | void fputc(char s, FILE* f)
 51 | {
 52 | 	asm("LOAD R0 R14 0"
 53 | 	    "LOAD R1 R14 4"
 54 | 	    "FPUTC");
 55 | }
 56 | 
 57 | void fputs(char* s, FILE* f)
 58 | {
 59 | 	while(0 != s[0])
 60 | 	{
 61 | 		fputc(s[0], f);
 62 | 		s = s + 1;
 63 | 	}
 64 | }
 65 | 
 66 | FILE* open_read(int filename)
 67 | {
 68 | 	asm("LOAD R0 R14 0"
 69 | 	    "FOPEN_READ");
 70 | }
 71 | 
 72 | FILE* open_write(int filename)
 73 | {
 74 | 	asm("LOAD R0 R14 0"
 75 | 	    "FOPEN_WRITE");
 76 | }
 77 | 
 78 | FILE* fopen(char* filename, char* mode)
 79 | {
 80 | 	FILE* f;
 81 | 	int fd = 0;
 82 | 	if(match(filename, "STDIN") || match(filename, "tape_01"))
 83 | 	{
 84 | 		fd = 0x1100;
 85 | 	}
 86 | 	else if(match(filename, "STDOUT") || match(filename, "tape_02"))
 87 | 	{
 88 | 		fd = 0x1101;
 89 | 	}
 90 | 
 91 | 	if('w' == mode[0])
 92 | 	{
 93 | 		f = open_write(fd);
 94 | 	}
 95 | 	else
 96 | 	{ /* Everything else is a read */
 97 | 		f = open_read(fd);
 98 | 	}
 99 | 
100 | 	/* Negative numbers are error codes */
101 | 	if(0 > f)
102 | 	{
103 | 		return 0;
104 | 	}
105 | 	return f;
106 | }
107 | 
108 | int close(int fd)
109 | {
110 | 	asm("LOAD R0 R14 0"
111 | 	    "FCLOSE");
112 | }
113 | 
114 | int fclose(FILE* stream)
115 | {
116 | 	int error = close(stream);
117 | 	return error;
118 | }
119 | 
120 | int brk(void *addr)
121 | {
122 | 	asm("LOAD R0 R14 0"
123 | 	    "ADDU R0 R12 R0"
124 | 	    "SWAP R0 R12");
125 | }
126 | 
127 | long _malloc_ptr;
128 | long _brk_ptr;
129 | 
130 | void* malloc(int size)
131 | {
132 | 	if(NULL == _brk_ptr)
133 | 	{
134 | 		_brk_ptr = brk(0);
135 | 		_malloc_ptr = _brk_ptr;
136 | 	}
137 | 
138 | 	if(_brk_ptr < _malloc_ptr + size)
139 | 	{
140 | 		_brk_ptr = brk(_malloc_ptr + size);
141 | 		if(-1 == _brk_ptr) return 0;
142 | 	}
143 | 
144 | 	long old_malloc = _malloc_ptr;
145 | 	_malloc_ptr = _malloc_ptr + size;
146 | 	return old_malloc;
147 | }
148 | 
149 | int strlen(char* str )
150 | {
151 | 	int i = 0;
152 | 	while(0 != str[i]) i = i + 1;
153 | 	return i;
154 | }
155 | 
156 | void* memset(void* ptr, int value, int num)
157 | {
158 | 	char* s;
159 | 	for(s = ptr; 0 < num; num = num - 1)
160 | 	{
161 | 		s[0] = value;
162 | 		s = s + 1;
163 | 	}
164 | }
165 | 
166 | void* calloc(int count, int size)
167 | {
168 | 	void* ret = malloc(count * size);
169 | 	if(NULL == ret) return NULL;
170 | 	memset(ret, 0, (count * size));
171 | 	return ret;
172 | }
173 | 
174 | void free(void* l)
175 | {
176 | 	return;
177 | }
178 | 
179 | void exit(int value)
180 | {
181 | 	asm("LOAD R0 R14 0"
182 | 	    "HALT");
183 | }
184 | 


--------------------------------------------------------------------------------
/knight/native/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #define O_RDONLY 0
19 | #define O_WRONLY 1
20 | #define O_RDWR 2
21 | #define O_CREAT 00100
22 | #define O_EXCL 00200
23 | #define O_TRUNC 001000
24 | #define O_APPEND 002000
25 | 
26 | #define S_IXUSR 00100
27 | #define S_IWUSR 00200
28 | #define S_IRUSR 00400
29 | #define S_IRWXU 00700
30 | 
31 | 
32 | int _open(char* name, int flag, int mode)
33 | {
34 | 	if((0 != flag) && (0 != mode))
35 | 	{
36 | 		asm("LOAD R0 R14 0"
37 | 		    "FOPEN_WRITE");
38 | 		return 0x1101;
39 | 	}
40 | 	else
41 | 	{
42 | 		asm("LOAD R0 R14 0"
43 | 		    "FOPEN_READ");
44 | 		return 0x1100;
45 | 	}
46 | }
47 | 
48 | #define STDIN_FILENO  0x1100
49 | #define STDOUT_FILENO 0x1101
50 | #define STDERR_FILENO 0
51 | 


--------------------------------------------------------------------------------
/knight/native/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #include <sys/types.h>
19 | 
20 | #define S_IRWXU 00700
21 | #define S_IXUSR 00100
22 | #define S_IWUSR 00200
23 | #define S_IRUSR 00400
24 | 
25 | #define S_ISUID 0400
26 | #define S_ISGID 02000
27 | #define S_IXGRP 00010
28 | #define S_IXOTH 00001
29 | #define S_IRGRP 00040
30 | #define S_IROTH 00004
31 | #define S_IWGRP 00020
32 | #define S_IWOTH 00002
33 | #define S_IRWXG 00070
34 | #define S_IRWXO 00007
35 | 
36 | 
37 | int chmod(char *pathname, int mode)
38 | {
39 | 	/* Completely meaningless on bare metal*/
40 | 	return 0;
41 | }
42 | 
43 | 
44 | int fchmod(int a, mode_t b)
45 | {
46 | 	/* Completely meaningless on bare metal*/
47 | 	return 0;
48 | }
49 | 
50 | 
51 | int mkdir(char const* a, mode_t b)
52 | {
53 | 	/* Completely meaningless on bare metal*/
54 | 	return 0;
55 | }
56 | 
57 | 
58 | int mknod(char const* a, mode_t b, dev_t c)
59 | {
60 | 	/* Completely meaningless on bare metal*/
61 | 	return 0;
62 | }
63 | 
64 | 
65 | mode_t umask(mode_t m)
66 | {
67 | 	/* Completely meaningless on bare metal*/
68 | 	return 0;
69 | }
70 | 


--------------------------------------------------------------------------------
/knight/native/unistd.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2020 Jeremiah Orians
  2 |  * Copyright (C) 2021 Andrius Štikonas
  3 |  * This file is part of M2-Planet.
  4 |  *
  5 |  * M2-Planet is free software: you can redistribute it and/or modify
  6 |  * it under the terms of the GNU General Public License as published by
  7 |  * the Free Software Foundation, either version 3 of the License, or
  8 |  * (at your option) any later version.
  9 |  *
 10 |  * M2-Planet is distributed in the hope that it will be useful,
 11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |  * GNU General Public License for more details.
 14 |  *
 15 |  * You should have received a copy of the GNU General Public License
 16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 17 |  */
 18 | 
 19 | #include <sys/utsname.h>
 20 | #define NULL 0
 21 | #define __PATH_MAX 4096
 22 | #define EOF 0xFFFFFFFF
 23 | 
 24 | void* malloc(unsigned size);
 25 | 
 26 | int access(char* pathname, int mode)
 27 | {
 28 | 	/* Completely meaningless in bare metal */
 29 | 	return 0;
 30 | }
 31 | 
 32 | int chdir(char* path)
 33 | {
 34 | 	/* Completely meaningless in bare metal */
 35 | 	return 0;
 36 | }
 37 | 
 38 | int fchdir(int fd)
 39 | {
 40 | 	/* Completely meaningless in bare metal */
 41 | 	return 0;
 42 | }
 43 | 
 44 | 
 45 | int fork()
 46 | {
 47 | 	/* Completely meaningless in bare metal */
 48 | 	return 0;
 49 | }
 50 | 
 51 | 
 52 | int waitpid (int pid, int* status_ptr, int options)
 53 | {
 54 | 	/* Completely meaningless in bare metal */
 55 | 	return 0;
 56 | }
 57 | 
 58 | 
 59 | int execve(char* file_name, char** argv, char** envp)
 60 | {
 61 | 	/* Completely meaningless in bare metal */
 62 | 	return 0;
 63 | }
 64 | 
 65 | int __read(int fd)
 66 | {
 67 | 	asm("LOAD R1 R14 0"
 68 | 	    "FGETC");
 69 | }
 70 | 
 71 | int read(int fd, char* buf, unsigned count)
 72 | {
 73 | 	unsigned i = 0;
 74 | 	int c;
 75 | 	while(i < count)
 76 | 	{
 77 | 		c = __read(fd);
 78 | 		if(EOF == c) break;
 79 | 		buf[i] = c;
 80 | 		i = i + 1;
 81 | 	}
 82 | 	return i;
 83 | }
 84 | 
 85 | void __write(char s, int fd)
 86 | {
 87 | 	asm("LOAD R0 R14 0"
 88 | 	    "LOAD R1 R14 4"
 89 | 	    "FPUTC");
 90 | }
 91 | 
 92 | int write(int fd, char* buf, unsigned count)
 93 | {
 94 | 	unsigned i = 0;
 95 | 	while(i < count)
 96 | 	{
 97 | 		__write(buf[i], fd);
 98 | 		i = i + 1;
 99 | 	}
100 | }
101 | 
102 | int lseek(int fd, int offset, int whence)
103 | {
104 | 	asm("LOAD R0 R14 0"
105 | 	    "LOAD R1 R14 4"
106 | 	    "LOAD R2 R14 8"
107 | 	    "FSEEK");
108 | }
109 | 
110 | int close(int fd)
111 | {
112 | 	asm("LOAD R0 R14 0"
113 | 	    "FCLOSE");
114 | }
115 | 
116 | 
117 | int unlink (char* filename)
118 | {
119 | 	/* Completely meaningless in bare metal */
120 | 	return 0;
121 | }
122 | 
123 | int symlink(char *path1, char *path2)
124 | {
125 | 	/* Completely meaningless in bare metal */
126 | 	return 0;
127 | }
128 | 
129 | int _getcwd(char* buf, int size)
130 | {
131 | 	/* Completely meaningless in bare metal */
132 | 	return 0;
133 | }
134 | 
135 | 
136 | char* getcwd(char* buf, unsigned size)
137 | {
138 | 	/* Completely meaningless in bare metal */
139 | 	return 0;
140 | 
141 | }
142 | 
143 | 
144 | char* getwd(char* buf)
145 | {
146 | 	/* Completely meaningless in bare metal */
147 | 	return 0;
148 | }
149 | 
150 | 
151 | char* get_current_dir_name()
152 | {
153 | 	/* Completely meaningless in bare metal */
154 | 	return 0;
155 | }
156 | 
157 | /********************************************************************************
158 |  * We are running on bare metal. Just don't go past the end of install RAM      *
159 |  ********************************************************************************/
160 | int brk(void *addr)
161 | {
162 | 	asm("LOAD R0 R14 0"
163 | 	    "ADDU R0 R12 R0"
164 | 	    "SWAP R0 R12");
165 | }
166 | 
167 | int uname(struct utsname* unameData)
168 | {
169 | 	/* Completely meaningless in bare metal */
170 | 	return 0;
171 | }
172 | 


--------------------------------------------------------------------------------
/riscv32/ELF-riscv32-debug.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### 32 bit elf header in hex2
19 | ### if you wish to use this header, you need to add :ELF_end to the end of your
20 | ### M1 or hex2 files.
21 | 
22 | ## ELF Header
23 | 
24 | :ELF_base
25 | 7F 45 4C 46        ## e_ident[EI_MAG0-3] ELF's magic number
26 | 
27 | 01                 ## e_ident[EI_CLASS] Indicating 32 bit
28 | 01                 ## e_ident[EI_DATA] Indicating little endianness
29 | 01                 ## e_ident[EI_VERSION] Indicating original elf
30 | 
31 | 03                 ## e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
32 | 00                 ## e_ident[EI_ABIVERSION] Set at 0 because none cares
33 | 
34 | 00 00 00 00 00 00 00 ## e_ident[EI_PAD]
35 | 02 00              ## e_type Indicating Executable
36 | F3 00              ## e_machine Indicating RISC-V
37 | 01 00 00 00        ## e_version Indicating original elf
38 | 
39 | &_start            ## e_entry Address of the entry point (Number of bytes this header is + Base Address)
40 | %ELF_program_headers>ELF_base ## e_phoff Address of program header table
41 | %ELF_section_headers>ELF_base ## e_shoff Address of section header table
42 | 
43 | 00 00 00 00        ## e_flags
44 | 34 00              ## e_ehsize Indicating our 52 Byte header
45 | 
46 | 20 00              ## e_phentsize size of a program header table
47 | 01 00              ## e_phnum number of entries in program table
48 | 
49 | 28 00              ## e_shentsize size of a section header table
50 | 05 00              ## e_shnum number of entries in section table
51 | 
52 | 02 00              ## e_shstrndx index of the section names
53 | 
54 | ## Program Header
55 | :ELF_program_headers
56 | :ELF_program_header__text
57 | 01 00 00 00        ## ph_type: PT-LOAD = 1
58 | 00 00 00 00        ## p_offset
59 | 
60 | &ELF_base          ## ph_vaddr
61 | &ELF_base          ## ph_physaddr
62 | 
63 | %ELF_end>ELF_base  ## p_filesz
64 | %ELF_end>ELF_base  ## p_memsz
65 | 
66 | 07 00 00 00        ## ph_flags: PF-X|PF-W|PF-R = 7
67 | 01 00 00 00        ## ph_align
68 | 
69 | :ELF_text
70 | 


--------------------------------------------------------------------------------
/riscv32/ELF-riscv32.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### 32 bit elf header in hex2
19 | ### if you wish to use this header, you need to add :ELF_end to the end of your
20 | ### M1 or hex2 files.
21 | 
22 | ## ELF Header
23 | 
24 | :ELF_base
25 | 7F 45 4C 46        ## e_ident[EI_MAG0-3] ELF's magic number
26 | 
27 | 01                 ## e_ident[EI_CLASS] Indicating 32 bit
28 | 01                 ## e_ident[EI_DATA] Indicating little endianness
29 | 01                 ## e_ident[EI_VERSION] Indicating original elf
30 | 
31 | 03                 ## e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
32 | 00                 ## e_ident[EI_ABIVERSION] Set at 0 because none cares
33 | 
34 | 00 00 00 00 00 00 00 ## e_ident[EI_PAD]
35 | 02 00              ## e_type Indicating Executable
36 | F3 00              ## e_machine Indicating RISC-V
37 | 01 00 00 00        ## e_version Indicating original elf
38 | 
39 | &_start            ## e_entry Address of the entry point (Number of bytes this header is + Base Address)
40 | %ELF_program_headers>ELF_base ## e_phoff Address of program header table
41 | 00 00 00 00        ## e_shoff Address of section header table
42 | 
43 | 00 00 00 00        ## e_flags
44 | 34 00              ## e_ehsize Indicating our 52 Byte header
45 | 
46 | 20 00              ## e_phentsize size of a program header table
47 | 01 00              ## e_phnum number of entries in program table
48 | 
49 | 00 00              ## e_shentsize size of a section header table
50 | 00 00              ## e_shnum number of entries in section table
51 | 
52 | 00 00              ## e_shstrndx index of the section names
53 | 
54 | ## Program Header
55 | :ELF_program_headers
56 | 01 00 00 00        ## ph_type: PT-LOAD = 1
57 | 00 00 00 00        ## p_offset
58 | 
59 | &ELF_base          ## ph_vaddr
60 | &ELF_base          ## ph_physaddr
61 | 
62 | %ELF_end>ELF_base  ## p_filesz
63 | %ELF_end>ELF_base  ## p_memsz
64 | 
65 | 07 00 00 00        ## ph_flags: PF-X|PF-W|PF-R = 7
66 | 01 00 00 00        ## ph_align
67 | 
68 | :ELF_text
69 | 


--------------------------------------------------------------------------------
/riscv32/libc-core.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2021 Andrius Štikonas
 2 | ## This file is part of stage0.
 3 | ##
 4 | ## stage0 is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## stage0 is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with stage0.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 |     rd_fp rs1_sp mv        ; Protect stack pointer
19 | 
20 |     ; Prepare argv
21 |     rd_a0 rs1_fp !4 addi   ; ARGV_address = FP + 4
22 |     rd_sp rs1_sp !-4 addi
23 |     rs1_sp rs2_a0 sw       ; Put argv on the stack
24 | 
25 |     ; Prepare envp
26 |     rd_a0 rs1_fp mv        ; Address we need to load from
27 |     rd_a0 rs1_a0 lw        ; Get ARGC
28 |     rd_a0 rs1_a0 !2 addi   ; OFFSET = ARGC + 2
29 |     rd_a0 rs1_a0 rs2_x3 slli ; OFFSET = OFFSET * WORDSIZE
30 |     rd_a0 rs1_fp rs2_a0 add ; ENVP_address = RSP + OFFSET
31 |     rd_sp rs1_sp !-4 addi
32 |     rs1_sp rs2_a0 sw       ; Put envp on the stack
33 | 
34 |     ; Stack offset
35 |     rd_fp rs1_fp !4 addi
36 | 
37 |     ; Call main function
38 |     rd_ra $FUNCTION_main jal
39 | 
40 |     ; Exit to kernel
41 | :FUNCTION_exit
42 | :FUNCTION__exit
43 |     rd_a7 !93 addi         ; Syscall for exit
44 |     ecall                  ; Exit with code in a0
45 | 


--------------------------------------------------------------------------------
/riscv32/libc-full.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2021 Andrius Štikonas
 2 | ## This file is part of stage0.
 3 | ##
 4 | ## stage0 is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## stage0 is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with stage0.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 |     rd_fp rs1_sp mv        ; Protect stack pointer
19 | 
20 |     ; Prepare argv
21 |     rd_a0 rs1_fp !4 addi   ; ARGV_address = FP + 4
22 |     rd_sp rs1_sp !-4 addi
23 |     rs1_sp rs2_a0 sw       ; Put argv on the stack
24 | 
25 |     ; Prepare envp
26 |     rd_a0 rs1_fp mv           ; Address we need to load from
27 |     rd_a0 rs1_a0 lw           ; Get ARGC
28 |     rd_a0 rs1_a0 !2 addi      ; OFFSET = ARGC + 2
29 |     rd_a0 rs1_a0 rs2_x2 slli  ; OFFSET = OFFSET * WORDSIZE
30 |     rd_a0 rs1_fp rs2_a0 add   ; ENVP_address = RSP + OFFSET
31 |     rd_sp rs1_sp !-4 addi
32 |     rs1_sp rs2_a0 sw          ; Put envp on the stack
33 |     rd_a1 ~GLOBAL__envp auipc ; Get _envp global
34 |     rd_a1 rs1_a1 !GLOBAL__envp addi
35 |     rs1_a1 rs2_a0 sw          ; Save environment to _envp
36 | 
37 |     ; Stack offset
38 |     rd_fp rs1_fp !4 addi
39 | 
40 |     ; Setup for malloc
41 |     rd_ra $FUNCTION___init_malloc jal
42 | 
43 |     ; Setup for FILE*
44 |     rd_ra $FUNCTION___init_io jal
45 | 
46 |     ; Call main function
47 |     rd_ra $FUNCTION_main jal
48 | 
49 |     ; Put return value on the stack so that _exit gets it
50 |     rd_sp rs1_sp !-8 addi
51 |     rs1_sp rs2_a0 sw
52 | 
53 |     ; Exit to kernel
54 | :FUNCTION_exit
55 |     rd_ra $FUNCTION___kill_io jal
56 | :FUNCTION__exit
57 |     rd_a0 rs1_sp lw
58 |     rd_a7 !93 addi         ; Syscall for exit
59 |     ecall                  ; Exit with code in a0
60 | 
61 | :GLOBAL__envp
62 | 	NULL
63 | 


--------------------------------------------------------------------------------
/riscv32/linux/bootstrap.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * Copyright (C) 2021 Andrius Štikonas
  3 |  * This file is part of M2-Planet.
  4 |  *
  5 |  * M2-Planet is free software: you can redistribute it and/or modify
  6 |  * it under the terms of the GNU General Public License as published by
  7 |  * the Free Software Foundation, either version 3 of the License, or
  8 |  * (at your option) any later version.
  9 |  *
 10 |  * M2-Planet is distributed in the hope that it will be useful,
 11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |  * GNU General Public License for more details.
 14 |  *
 15 |  * You should have received a copy of the GNU General Public License
 16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 17 |  */
 18 | 
 19 | enum
 20 | {
 21 | 	stdin = 0,
 22 | 	stdout = 1,
 23 | 	stderr = 2,
 24 | };
 25 | 
 26 | enum
 27 | {
 28 | 	EOF = 0xFFFFFFFF,
 29 | 	NULL = 0,
 30 | };
 31 | 
 32 | enum
 33 | {
 34 | 	EXIT_FAILURE = 1,
 35 | 	EXIT_SUCCESS = 0,
 36 | };
 37 | 
 38 | enum
 39 | {
 40 | 	TRUE = 1,
 41 | 	FALSE = 0,
 42 | };
 43 | 
 44 | 
 45 | int fgetc(FILE* f)
 46 | {
 47 | 	asm("rd_a0 rs1_fp !-4 lw"
 48 | 	    "rs1_sp rs2_a0 sw"
 49 | 	    "rd_a1 rs1_sp mv"
 50 | 	    "rd_a2 !1 addi"
 51 | 	    "rd_a7 !63 addi"
 52 | 	    "ecall"
 53 | 	    "rd_a1 mv"
 54 | 	    "rd_t0 rs1_a0 mv"
 55 | 	    "rd_a0 rs1_sp lw"
 56 | 	    "rs1_t0 @8 bnez"
 57 | 	    "rd_a0 !-1 addi");
 58 | }
 59 | 
 60 | void fputc(char s, FILE* f)
 61 | {
 62 | 	asm("rd_a0 rs1_fp !-8 lw"
 63 | 	    "rd_a1 rs1_fp !-4 addi"
 64 | 	    "rd_a2 !1 addi"   /* 1 byte */
 65 | 	    "rd_a7 !64 addi"  /* write */
 66 | 	    "ecall");
 67 | }
 68 | 
 69 | void fputs(char* s, FILE* f)
 70 | {
 71 | 	while(0 != s[0])
 72 | 	{
 73 | 		fputc(s[0], f);
 74 | 		s = s + 1;
 75 | 	}
 76 | }
 77 | 
 78 | FILE* open(char* name, int flag, int mode)
 79 | {
 80 | 	asm("rd_a0 !-100 addi" /* AT_FDCWD */
 81 | 	    "rd_a1 rs1_fp !-4 lw"
 82 | 	    "rd_a2 rs1_fp !-8 lw"
 83 | 	    "rd_a3 rs1_fp !-12 lw"
 84 | 	    "rd_a7 !56 addi"   /* openat */
 85 | 	    "ecall");
 86 | }
 87 | 
 88 | FILE* fopen(char* filename, char* mode)
 89 | {
 90 | 	FILE* f;
 91 | 	if('w' == mode[0])
 92 | 	{ /* 577 is O_WRONLY|O_CREAT|O_TRUNC, 384 is 600 in octal */
 93 | 		f = open(filename, 577 , 384);
 94 | 	}
 95 | 	else
 96 | 	{ /* Everything else is a read */
 97 | 		f = open(filename, 0, 0);
 98 | 	}
 99 | 
100 | 	/* Negative numbers are error codes */
101 | 	if(0 > f)
102 | 	{
103 | 		return 0;
104 | 	}
105 | 	return f;
106 | }
107 | 
108 | int close(int fd)
109 | {
110 | 	asm("rd_a0 rs1_fp !-4 lw"
111 | 	    "rd_a7 !57 addi"    /* close */
112 | 	    "ecall");
113 | }
114 | 
115 | int fclose(FILE* stream)
116 | {
117 | 	int error = close(stream);
118 | 	return error;
119 | }
120 | 
121 | int brk(void *addr)
122 | {
123 | 	asm("rd_a0 rs1_fp !-4 lw"
124 | 	    "rd_a7 !214 addi"   /* brk */
125 | 	    "ecall");
126 | }
127 | 
128 | long _malloc_ptr;
129 | long _brk_ptr;
130 | 
131 | void* malloc(int size)
132 | {
133 | 	if(NULL == _brk_ptr)
134 | 	{
135 | 		_brk_ptr = brk(0);
136 | 		_malloc_ptr = _brk_ptr;
137 | 	}
138 | 
139 | 	if(_brk_ptr < _malloc_ptr + size)
140 | 	{
141 | 		_brk_ptr = brk(_malloc_ptr + size);
142 | 		if(-1 == _brk_ptr) return 0;
143 | 	}
144 | 
145 | 	long old_malloc = _malloc_ptr;
146 | 	_malloc_ptr = _malloc_ptr + size;
147 | 	return old_malloc;
148 | }
149 | 
150 | int strlen(char* str )
151 | {
152 | 	int i = 0;
153 | 	while(0 != str[i]) i = i + 1;
154 | 	return i;
155 | }
156 | 
157 | void* memset(void* ptr, int value, int num)
158 | {
159 | 	char* s;
160 | 	for(s = ptr; 0 < num; num = num - 1)
161 | 	{
162 | 		s[0] = value;
163 | 		s = s + 1;
164 | 	}
165 | }
166 | 
167 | void* calloc(int count, int size)
168 | {
169 | 	void* ret = malloc(count * size);
170 | 	if(NULL == ret) return NULL;
171 | 	memset(ret, 0, (count * size));
172 | 	return ret;
173 | }
174 | 
175 | void free(void* l)
176 | {
177 | 	return;
178 | }
179 | 
180 | void exit(int value)
181 | {
182 | 	asm("rd_a0 rs1_fp !-4 lw"
183 | 	    "rd_a7 !93 addi"   /* exit */
184 | 	    "ecall");
185 | }
186 | 


--------------------------------------------------------------------------------
/riscv32/linux/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * Copyright (C) 2021 Andrius Štikonas
 3 |  * This file is part of M2-Planet.
 4 |  *
 5 |  * M2-Planet is free software: you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation, either version 3 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * M2-Planet is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 |  */
18 | 
19 | #ifndef __FCNTL_C
20 | #define __FCNTL_C
21 | 
22 | #define O_RDONLY 0
23 | #define O_WRONLY 1
24 | #define O_RDWR 2
25 | #define O_CREAT 00100
26 | #define O_EXCL 00200
27 | #define O_TRUNC 001000
28 | #define O_APPEND 002000
29 | 
30 | #define S_IXUSR 00100
31 | #define S_IWUSR 00200
32 | #define S_IRUSR 00400
33 | #define S_IRWXU 00700
34 | 
35 | 
36 | int _open(char* name, int flag, int mode)
37 | {
38 | 	asm("rd_a0 !-100 addi" /* AT_FDCWD */
39 | 	    "rd_a1 rs1_fp !-4 lw"
40 | 	    "rd_a2 rs1_fp !-8 lw"
41 | 	    "rd_a3 rs1_fp !-12 lw"
42 | 	    "rd_a7 !56 addi"
43 | 	    "ecall");
44 | }
45 | 
46 | #define STDIN_FILENO  0
47 | #define STDOUT_FILENO 1
48 | #define STDERR_FILENO 2
49 | #endif
50 | 


--------------------------------------------------------------------------------
/riscv32/linux/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * Copyright (C) 2021 Andrius Štikonas
 3 |  * This file is part of M2-Planet.
 4 |  *
 5 |  * M2-Planet is free software: you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation, either version 3 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * M2-Planet is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 |  */
18 | 
19 | #ifndef _SYS_STAT_C
20 | #define _SYS_STAT_C
21 | 
22 | #include <sys/types.h>
23 | 
24 | #define S_IRWXU 00700
25 | #define S_IXUSR 00100
26 | #define S_IWUSR 00200
27 | #define S_IRUSR 00400
28 | 
29 | #define S_ISUID 04000
30 | #define S_ISGID 02000
31 | #define S_IXGRP 00010
32 | #define S_IXOTH 00001
33 | #define S_IRGRP 00040
34 | #define S_IROTH 00004
35 | #define S_IWGRP 00020
36 | #define S_IWOTH 00002
37 | #define S_IRWXG 00070
38 | #define S_IRWXO 00007
39 | 
40 | 
41 | int chmod(char *pathname, int mode)
42 | {
43 |         asm("rd_a0 !-100 addi" /* AT_FDCWD */
44 | 	    "rd_a1 rs1_fp !-4 lw"
45 | 	    "rd_a2 rs1_fp !-8 lw"
46 | 	    "rd_a7 !53 addi"
47 | 	    "ecall");
48 | }
49 | 
50 | 
51 | int fchmod(int a, mode_t b)
52 | {
53 |         asm("rd_a0 !-100 addi" /* AT_FDCWD */
54 | 	    "rd_a1 rs1_fp !-4 lw"
55 | 	    "rd_a2 rs1_fp !-8 lw"
56 | 	    "rd_a7 !52 addi"
57 | 	    "ecall");
58 | }
59 | 
60 | 
61 | int mkdir(char const* a, mode_t b)
62 | {
63 |         asm("rd_a0 !-100 addi" /* AT_FDCWD */
64 | 	    "rd_a1 rs1_fp !-4 lw"
65 | 	    "rd_a2 rs1_fp !-8 lw"
66 | 	    "rd_a7 !34 addi"
67 | 	    "ecall");
68 | }
69 | 
70 | 
71 | int mknod(char const* a, mode_t b, dev_t c)
72 | {
73 |         asm("rd_a0 !-100 addi" /* AT_FDCWD */
74 | 	    "rd_a1 rs1_fp !-4 lw"
75 | 	    "rd_a2 rs1_fp !-8 lw"
76 | 	    "rd_a3 rs1_fp !-12 lw"
77 | 	    "rd_a7 !33 addi"
78 | 	    "ecall");
79 | }
80 | 
81 | 
82 | mode_t umask(mode_t m)
83 | {
84 | 	asm("rd_a0 rs1_fp !-4 lw"
85 | 	    "rd_a7 !166 addi"
86 | 	    "ecall");
87 | }
88 | 
89 | #endif
90 | 


--------------------------------------------------------------------------------
/riscv64/ELF-riscv64-debug.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### 64 bit elf header in hex2
19 | ### if you wish to use this header, you need to add :ELF_end to the end of your
20 | ### M1 or hex2 files.
21 | 
22 | ## ELF Header
23 | 
24 | :ELF_base
25 | 7F 45 4C 46        ## e_ident[EI_MAG0-3] ELF's magic number
26 | 
27 | 02                 ## e_ident[EI_CLASS] Indicating 64 bit
28 | 01                 ## e_ident[EI_DATA] Indicating little endianness
29 | 01                 ## e_ident[EI_VERSION] Indicating original elf
30 | 
31 | 03                 ## e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
32 | 00                 ## e_ident[EI_ABIVERSION] Set at 0 because none cares
33 | 
34 | 00 00 00 00 00 00 00 ## e_ident[EI_PAD]
35 | 02 00              ## e_type Indicating Executable
36 | F3 00              ## e_machine Indicating RISC-V
37 | 01 00 00 00        ## e_version Indicating original elf
38 | 
39 | &_start 00 00 00 00 ## e_entry Address of the entry point (Number of bytes this header is + Base Address)
40 | %ELF_program_headers>ELF_base 00 00 00 00 ## e_phoff Address of program header table
41 | %ELF_section_headers>ELF_base 00 00 00 00 ## e_shoff Address of section header table
42 | 
43 | 00 00 00 00        ## e_flags
44 | 40 00              ## e_ehsize Indicating our 64 Byte header
45 | 
46 | 38 00              ## e_phentsize size of a program header table
47 | 01 00              ## e_phnum number of entries in program table
48 | 
49 | 40 00              ## e_shentsize size of a section header table
50 | 05 00              ## e_shnum number of entries in section table
51 | 
52 | 02 00              ## e_shstrndx index of the section names
53 | 
54 | ## Program Header
55 | :ELF_program_headers
56 | :ELF_program_header__text
57 | 01 00 00 00             ## p_type
58 | 07 00 00 00             ## ph_flags: PF-X|PF-W|PF-R = 7
59 | 00 00 00 00 00 00 00 00 ## p_offset
60 | 
61 | &ELF_base 00 00 00 00 ## p_vaddr
62 | &ELF_base 00 00 00 00 ## p_physaddr
63 | 
64 | %ELF_end>ELF_base 00 00 00 00 ## p_filesz
65 | %ELF_end>ELF_base 00 00 00 00 ## p_memsz
66 | 
67 | 01 00 00 00 00 00 00 00 ## Required alignment
68 | 
69 | :ELF_text
70 | 


--------------------------------------------------------------------------------
/riscv64/ELF-riscv64.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### 64 bit elf header in hex2
19 | ### if you wish to use this header, you need to add :ELF_end to the end of your
20 | ### M1 or hex2 files.
21 | 
22 | ## ELF Header
23 | 
24 | :ELF_base
25 | 7F 45 4C 46        ## e_ident[EI_MAG0-3] ELF's magic number
26 | 
27 | 02                 ## e_ident[EI_CLASS] Indicating 64 bit
28 | 01                 ## e_ident[EI_DATA] Indicating little endianness
29 | 01                 ## e_ident[EI_VERSION] Indicating original elf
30 | 
31 | 03                 ## e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
32 | 00                 ## e_ident[EI_ABIVERSION] Set at 0 because none cares
33 | 
34 | 00 00 00 00 00 00 00 ## e_ident[EI_PAD]
35 | 02 00              ## e_type Indicating Executable
36 | F3 00              ## e_machine Indicating RISC-V
37 | 01 00 00 00        ## e_version Indicating original elf
38 | 
39 | &_start 00 00 00 00 ## e_entry Address of the entry point (Number of bytes this header is + Base Address)
40 | %ELF_program_headers>ELF_base 00 00 00 00 ## e_phoff Address of program header table
41 | 00 00 00 00 00 00 00 00 ## e_shoff Address of section header table
42 | 
43 | 00 00 00 00        ## e_flags
44 | 40 00              ## e_ehsize Indicating our 64 Byte header
45 | 
46 | 38 00              ## e_phentsize size of a program header table
47 | 01 00              ## e_phnum number of entries in program table
48 | 
49 | 00 00              ## e_shentsize size of a section header table
50 | 00 00              ## e_shnum number of entries in section table
51 | 
52 | 00 00              ## e_shstrndx index of the section names
53 | 
54 | ## Program Header
55 | :ELF_program_headers
56 | 01 00 00 00             ## p_type
57 | 07 00 00 00             ## ph_flags: PF-X|PF-W|PF-R = 7
58 | 00 00 00 00 00 00 00 00 ## p_offset
59 | 
60 | &ELF_base 00 00 00 00 ## p_vaddr
61 | &ELF_base 00 00 00 00 ## p_physaddr
62 | 
63 | %ELF_end>ELF_base 00 00 00 00 ## p_filesz
64 | %ELF_end>ELF_base 00 00 00 00 ## p_memsz
65 | 
66 | 01 00 00 00 00 00 00 00 ## Required alignment
67 | 
68 | :ELF_text
69 | 


--------------------------------------------------------------------------------
/riscv64/libc-core.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2021 Andrius Štikonas
 2 | ## This file is part of stage0.
 3 | ##
 4 | ## stage0 is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## stage0 is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with stage0.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 |     rd_fp rs1_sp mv        ; Protect stack pointer
19 | 
20 |     ; Prepare argv
21 |     rd_a0 rs1_fp !8 addi   ; ARGV_address = FP + 8
22 |     rd_sp rs1_sp !-8 addi
23 |     rs1_sp rs2_a0 sd       ; Put argv on the stack
24 | 
25 |     ; Prepare envp
26 |     rd_a0 rs1_fp mv        ; Address we need to load from
27 |     rd_a0 rs1_a0 ld        ; Get ARGC
28 |     rd_a0 rs1_a0 !2 addi   ; OFFSET = ARGC + 2
29 |     rd_a0 rs1_a0 rs2_x3 slli ; OFFSET = OFFSET * WORDSIZE
30 |     rd_a0 rs1_fp rs2_a0 add ; ENVP_address = RSP + OFFSET
31 |     rd_sp rs1_sp !-8 addi
32 |     rs1_sp rs2_a0 sd       ; Put envp on the stack
33 | 
34 |     ; Stack offset
35 |     rd_fp rs1_fp !8 addi
36 | 
37 |     ; Call main function
38 |     rd_ra $FUNCTION_main jal
39 | 
40 |     ; Exit to kernel
41 | :FUNCTION_exit
42 | :FUNCTION__exit
43 |     rd_a7 !93 addi         ; Syscall for exit
44 |     ecall                  ; Exit with code in a0
45 | 


--------------------------------------------------------------------------------
/riscv64/libc-full.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2021 Andrius Štikonas
 2 | ## This file is part of stage0.
 3 | ##
 4 | ## stage0 is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## stage0 is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with stage0.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 |     rd_fp rs1_sp mv        ; Protect stack pointer
19 | 
20 |     ; Prepare argv
21 |     rd_a0 rs1_fp !8 addi   ; ARGV_address = FP + 8
22 |     rd_sp rs1_sp !-8 addi
23 |     rs1_sp rs2_a0 sd       ; Put argv on the stack
24 | 
25 |     ; Prepare envp
26 |     rd_a0 rs1_fp mv           ; Address we need to load from
27 |     rd_a0 rs1_a0 ld           ; Get ARGC
28 |     rd_a0 rs1_a0 !2 addi      ; OFFSET = ARGC + 2
29 |     rd_a0 rs1_a0 rs2_x3 slli  ; OFFSET = OFFSET * WORDSIZE
30 |     rd_a0 rs1_fp rs2_a0 add   ; ENVP_address = RSP + OFFSET
31 |     rd_sp rs1_sp !-8 addi
32 |     rs1_sp rs2_a0 sd          ; Put envp on the stack
33 |     rd_a1 ~GLOBAL__envp auipc ; Get _envp global
34 |     rd_a1 rs1_a1 !GLOBAL__envp addi
35 |     rs1_a1 rs2_a0 sd          ; Save environment to _envp
36 | 
37 |     ; Stack offset
38 |     rd_fp rs1_fp !8 addi
39 | 
40 |     ; Setup for malloc
41 |     rd_ra $FUNCTION___init_malloc jal
42 | 
43 |     ; Setup for FILE*
44 |     rd_ra $FUNCTION___init_io jal
45 | 
46 |     ; Call main function
47 |     rd_ra $FUNCTION_main jal
48 | 
49 |     ; Put return value on the stack so that _exit gets it
50 |     rd_sp rs1_sp !-16 addi
51 |     rs1_sp rs2_a0 sd
52 | 
53 |     ; Exit to kernel
54 | :FUNCTION_exit
55 |     rd_ra $FUNCTION___kill_io jal
56 | :FUNCTION__exit
57 |     rd_a0 rs1_sp ld
58 |     rd_a7 !93 addi         ; Syscall for exit
59 |     ecall                  ; Exit with code in a0
60 | 
61 | :GLOBAL__envp
62 | 	NULL
63 | 


--------------------------------------------------------------------------------
/riscv64/linux/bootstrap.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * Copyright (C) 2021 Andrius Štikonas
  3 |  * This file is part of M2-Planet.
  4 |  *
  5 |  * M2-Planet is free software: you can redistribute it and/or modify
  6 |  * it under the terms of the GNU General Public License as published by
  7 |  * the Free Software Foundation, either version 3 of the License, or
  8 |  * (at your option) any later version.
  9 |  *
 10 |  * M2-Planet is distributed in the hope that it will be useful,
 11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |  * GNU General Public License for more details.
 14 |  *
 15 |  * You should have received a copy of the GNU General Public License
 16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 17 |  */
 18 | 
 19 | enum
 20 | {
 21 | 	stdin = 0,
 22 | 	stdout = 1,
 23 | 	stderr = 2,
 24 | };
 25 | 
 26 | enum
 27 | {
 28 | 	EOF = 0xFFFFFFFF,
 29 | 	NULL = 0,
 30 | };
 31 | 
 32 | enum
 33 | {
 34 | 	EXIT_FAILURE = 1,
 35 | 	EXIT_SUCCESS = 0,
 36 | };
 37 | 
 38 | enum
 39 | {
 40 | 	TRUE = 1,
 41 | 	FALSE = 0,
 42 | };
 43 | 
 44 | 
 45 | int fgetc(FILE* f)
 46 | {
 47 | 	asm("rd_a0 rs1_fp !-8 ld"
 48 | 	    "rs1_sp rs2_a0 sd"
 49 | 	    "rd_a1 rs1_sp mv"
 50 | 	    "rd_a2 !1 addi"
 51 | 	    "rd_a7 !63 addi"
 52 | 	    "ecall"
 53 | 	    "rd_a1 mv"
 54 | 	    "rd_t0 rs1_a0 mv"
 55 | 	    "rd_a0 rs1_sp ld"
 56 | 	    "rs1_t0 @8 bnez"
 57 | 	    "rd_a0 !-1 addi");
 58 | }
 59 | 
 60 | void fputc(char s, FILE* f)
 61 | {
 62 | 	asm("rd_a0 rs1_fp !-16 ld"
 63 | 	    "rd_a1 rs1_fp !-8 addi"
 64 | 	    "rd_a2 !1 addi"   /* 1 byte */
 65 | 	    "rd_a7 !64 addi"  /* write */
 66 | 	    "ecall");
 67 | }
 68 | 
 69 | void fputs(char* s, FILE* f)
 70 | {
 71 | 	while(0 != s[0])
 72 | 	{
 73 | 		fputc(s[0], f);
 74 | 		s = s + 1;
 75 | 	}
 76 | }
 77 | 
 78 | FILE* open(char* name, int flag, int mode)
 79 | {
 80 | 	asm("rd_a0 !-100 addi" /* AT_FDCWD */
 81 | 	    "rd_a1 rs1_fp !-8 ld"
 82 | 	    "rd_a2 rs1_fp !-16 ld"
 83 | 	    "rd_a3 rs1_fp !-24 ld"
 84 | 	    "rd_a7 !56 addi"   /* openat */
 85 | 	    "ecall");
 86 | }
 87 | 
 88 | FILE* fopen(char* filename, char* mode)
 89 | {
 90 | 	FILE* f;
 91 | 	if('w' == mode[0])
 92 | 	{ /* 577 is O_WRONLY|O_CREAT|O_TRUNC, 384 is 600 in octal */
 93 | 		f = open(filename, 577 , 384);
 94 | 	}
 95 | 	else
 96 | 	{ /* Everything else is a read */
 97 | 		f = open(filename, 0, 0);
 98 | 	}
 99 | 
100 | 	/* Negative numbers are error codes */
101 | 	if(0 > f)
102 | 	{
103 | 		return 0;
104 | 	}
105 | 	return f;
106 | }
107 | 
108 | int close(int fd)
109 | {
110 | 	asm("rd_a0 rs1_fp !-8 ld"
111 | 	    "rd_a7 !57 addi"    /* close */
112 | 	    "ecall");
113 | }
114 | 
115 | int fclose(FILE* stream)
116 | {
117 | 	int error = close(stream);
118 | 	return error;
119 | }
120 | 
121 | int brk(void *addr)
122 | {
123 | 	asm("rd_a0 rs1_fp !-8 ld"
124 | 	    "rd_a7 !214 addi"   /* brk */
125 | 	    "ecall");
126 | }
127 | 
128 | long _malloc_ptr;
129 | long _brk_ptr;
130 | 
131 | void* malloc(int size)
132 | {
133 | 	if(NULL == _brk_ptr)
134 | 	{
135 | 		_brk_ptr = brk(0);
136 | 		_malloc_ptr = _brk_ptr;
137 | 	}
138 | 
139 | 	if(_brk_ptr < _malloc_ptr + size)
140 | 	{
141 | 		_brk_ptr = brk(_malloc_ptr + size);
142 | 		if(-1 == _brk_ptr) return 0;
143 | 	}
144 | 
145 | 	long old_malloc = _malloc_ptr;
146 | 	_malloc_ptr = _malloc_ptr + size;
147 | 	return old_malloc;
148 | }
149 | 
150 | int strlen(char* str )
151 | {
152 | 	int i = 0;
153 | 	while(0 != str[i]) i = i + 1;
154 | 	return i;
155 | }
156 | 
157 | void* memset(void* ptr, int value, int num)
158 | {
159 | 	char* s;
160 | 	for(s = ptr; 0 < num; num = num - 1)
161 | 	{
162 | 		s[0] = value;
163 | 		s = s + 1;
164 | 	}
165 | }
166 | 
167 | void* calloc(int count, int size)
168 | {
169 | 	void* ret = malloc(count * size);
170 | 	if(NULL == ret) return NULL;
171 | 	memset(ret, 0, (count * size));
172 | 	return ret;
173 | }
174 | 
175 | void free(void* l)
176 | {
177 | 	return;
178 | }
179 | 
180 | void exit(int value)
181 | {
182 | 	asm("rd_a0 rs1_fp !-8 ld"
183 | 	    "rd_a7 !93 addi"   /* exit */
184 | 	    "ecall");
185 | }
186 | 


--------------------------------------------------------------------------------
/riscv64/linux/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * Copyright (C) 2021 Andrius Štikonas
 3 |  * This file is part of M2-Planet.
 4 |  *
 5 |  * M2-Planet is free software: you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation, either version 3 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * M2-Planet is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 |  */
18 | 
19 | #ifndef __FCNTL_C
20 | #define __FCNTL_C
21 | 
22 | #define O_RDONLY 0
23 | #define O_WRONLY 1
24 | #define O_RDWR 2
25 | #define O_CREAT 00100
26 | #define O_EXCL 00200
27 | #define O_TRUNC 001000
28 | #define O_APPEND 002000
29 | 
30 | #define S_IXUSR 00100
31 | #define S_IWUSR 00200
32 | #define S_IRUSR 00400
33 | #define S_IRWXU 00700
34 | 
35 | 
36 | int _open(char* name, int flag, int mode)
37 | {
38 | 	asm("rd_a0 !-100 addi" /* AT_FDCWD */
39 | 	    "rd_a1 rs1_fp !-8 ld"
40 | 	    "rd_a2 rs1_fp !-16 ld"
41 | 	    "rd_a3 rs1_fp !-24 ld"
42 | 	    "rd_a7 !56 addi"
43 | 	    "ecall");
44 | }
45 | 
46 | #define STDIN_FILENO  0
47 | #define STDOUT_FILENO 1
48 | #define STDERR_FILENO 2
49 | #endif
50 | 


--------------------------------------------------------------------------------
/riscv64/linux/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * Copyright (C) 2021 Andrius Štikonas
 3 |  * This file is part of M2-Planet.
 4 |  *
 5 |  * M2-Planet is free software: you can redistribute it and/or modify
 6 |  * it under the terms of the GNU General Public License as published by
 7 |  * the Free Software Foundation, either version 3 of the License, or
 8 |  * (at your option) any later version.
 9 |  *
10 |  * M2-Planet is distributed in the hope that it will be useful,
11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 |  * GNU General Public License for more details.
14 |  *
15 |  * You should have received a copy of the GNU General Public License
16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 |  */
18 | 
19 | #ifndef _SYS_STAT_C
20 | #define _SYS_STAT_C
21 | 
22 | #include <sys/types.h>
23 | 
24 | #define S_IRWXU 00700
25 | #define S_IXUSR 00100
26 | #define S_IWUSR 00200
27 | #define S_IRUSR 00400
28 | 
29 | #define S_ISUID 04000
30 | #define S_ISGID 02000
31 | #define S_IXGRP 00010
32 | #define S_IXOTH 00001
33 | #define S_IRGRP 00040
34 | #define S_IROTH 00004
35 | #define S_IWGRP 00020
36 | #define S_IWOTH 00002
37 | #define S_IRWXG 00070
38 | #define S_IRWXO 00007
39 | 
40 | 
41 | int chmod(char *pathname, int mode)
42 | {
43 |         asm("rd_a0 !-100 addi" /* AT_FDCWD */
44 | 	    "rd_a1 rs1_fp !-8 ld"
45 | 	    "rd_a2 rs1_fp !-16 ld"
46 | 	    "rd_a7 !53 addi"
47 | 	    "ecall");
48 | }
49 | 
50 | 
51 | int fchmod(int a, mode_t b)
52 | {
53 |         asm("rd_a0 !-100 addi" /* AT_FDCWD */
54 | 	    "rd_a1 rs1_fp !-8 ld"
55 | 	    "rd_a2 rs1_fp !-16 ld"
56 | 	    "rd_a7 !52 addi"
57 | 	    "ecall");
58 | }
59 | 
60 | 
61 | int mkdir(char const* a, mode_t b)
62 | {
63 |         asm("rd_a0 !-100 addi" /* AT_FDCWD */
64 | 	    "rd_a1 rs1_fp !-8 ld"
65 | 	    "rd_a2 rs1_fp !-16 ld"
66 | 	    "rd_a7 !34 addi"
67 | 	    "ecall");
68 | }
69 | 
70 | 
71 | int mknod(char const* a, mode_t b, dev_t c)
72 | {
73 |         asm("rd_a0 !-100 addi" /* AT_FDCWD */
74 | 	    "rd_a1 rs1_fp !-8 ld"
75 | 	    "rd_a2 rs1_fp !-16 ld"
76 | 	    "rd_a3 rs1_fp !-24 ld"
77 | 	    "rd_a7 !33 addi"
78 | 	    "ecall");
79 | }
80 | 
81 | 
82 | mode_t umask(mode_t m)
83 | {
84 | 	asm("rd_a0 rs1_fp !-8 ld"
85 | 	    "rd_a7 !166 addi"
86 | 	    "ecall");
87 | }
88 | 
89 | #endif
90 | 


--------------------------------------------------------------------------------
/riscv64/linux/unistd.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2020 Jeremiah Orians
  2 |  * Copyright (C) 2021 Andrius Štikonas
  3 |  * This file is part of M2-Planet.
  4 |  *
  5 |  * M2-Planet is free software: you can redistribute it and/or modify
  6 |  * it under the terms of the GNU General Public License as published by
  7 |  * the Free Software Foundation, either version 3 of the License, or
  8 |  * (at your option) any later version.
  9 |  *
 10 |  * M2-Planet is distributed in the hope that it will be useful,
 11 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 |  * GNU General Public License for more details.
 14 |  *
 15 |  * You should have received a copy of the GNU General Public License
 16 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 17 |  */
 18 | 
 19 | #ifndef _UNISTD_C
 20 | #define _UNISTD_C
 21 | #include <sys/utsname.h>
 22 | #define NULL 0
 23 | #define __PATH_MAX 4096
 24 | #define __SI_SWAP_ERRNO_CODE
 25 | 
 26 | void* malloc(unsigned size);
 27 | 
 28 | int access(char* pathname, int mode)
 29 | {
 30 | 	asm("rd_a0 !-100 addi" /* AT_FDCWD */
 31 | 	    "rd_a1 rs1_fp !-8 ld"
 32 | 	    "rd_a2 rs1_fp !-16 ld"
 33 | 	    "rd_a3 addi" /* flags = 0 */
 34 | 	    "rd_a7 !48 addi"
 35 | 	    "ecall");
 36 | }
 37 | 
 38 | int chdir(char* path)
 39 | {
 40 | 	asm("rd_a0 rs1_fp !-8 ld"
 41 | 	    "rd_a7 !49 addi"
 42 | 	    "ecall");
 43 | }
 44 | 
 45 | int fchdir(int fd)
 46 | {
 47 | 	asm("rd_a0 rs1_fp !-8 ld"
 48 | 	    "rd_a7 !50 addi"
 49 | 	    "ecall");
 50 | }
 51 | 
 52 | void _exit(int value);
 53 | 
 54 | int fork()
 55 | {
 56 | 	asm("rd_a7 !220 addi"
 57 | 	    "rd_a0 !17 addi" /* SIGCHld */
 58 | 	    "rd_a1 mv"       /* Child uses duplicate of parent's stack */
 59 | 	    "ecall");
 60 | }
 61 | 
 62 | 
 63 | int waitpid (int pid, int* status_ptr, int options)
 64 | {
 65 | 	/* Uses wait4 with struct rusage *ru set to NULL */
 66 | 	asm("rd_a0 rs1_fp !-8 ld"
 67 | 	    "rd_a1 rs1_fp !-16 ld"
 68 | 	    "rd_a2 rs1_fp !-24 ld"
 69 | 	    "rd_a3 addi"
 70 | 	    "rd_a7 !260 addi"
 71 | 	    "ecall");
 72 | }
 73 | 
 74 | 
 75 | int execve(char* file_name, char** argv, char** envp)
 76 | {
 77 | 	asm("rd_a0 rs1_fp !-8 ld"
 78 | 	    "rd_a1 rs1_fp !-16 ld"
 79 | 	    "rd_a2 rs1_fp !-24 ld"
 80 | 	    "rd_a7 !221 addi"
 81 | 	    "ecall");
 82 | }
 83 | 
 84 | int read(int fd, char* buf, unsigned count)
 85 | {
 86 | 	asm("rd_a0 rs1_fp !-8 ld"
 87 | 	    "rd_a1 rs1_fp !-16 ld"
 88 | 	    "rd_a2 rs1_fp !-24 ld"
 89 | 	    "rd_a7 !63 addi"
 90 | 	    "ecall");
 91 | }
 92 | 
 93 | int write(int fd, char* buf, unsigned count)
 94 | {
 95 | 	asm("rd_a0 rs1_fp !-8 ld"
 96 | 	    "rd_a1 rs1_fp !-16 ld"
 97 | 	    "rd_a2 rs1_fp !-24 ld"
 98 | 	    "rd_a7 !64 addi"
 99 | 	    "ecall");
100 | }
101 | 
102 | int lseek(int fd, int offset, int whence)
103 | {
104 | 	asm("rd_a0 rs1_fp !-8 ld"
105 | 	    "rd_a1 rs1_fp !-16 ld"
106 | 	    "rd_a2 rs1_fp !-24 ld"
107 | 	    "rd_a7 !62 addi"
108 | 	    "ecall");
109 | }
110 | 
111 | 
112 | int close(int fd)
113 | {
114 | 	asm("rd_a0 rs1_fp !-8 ld"
115 | 	    "rd_a7 !57 addi"    /* close */
116 | 	    "ecall");
117 | }
118 | 
119 | 
120 | int unlink (char* filename)
121 | {
122 | 	asm("rd_a0 !-100 addi" /* AT_FDCWD */
123 | 	    "rd_a1 rs1_fp !-8 ld"
124 | 	    "rd_a2 !0 addi"     /* No flags */
125 | 	    "rd_a7 !35 addi"    /* unlinkat */
126 | 	    "ecall");
127 | }
128 | 
129 | int symlink(char *path1, char *path2)
130 | {
131 | 	asm("rd_a0 rs1_fp !-8 ld"
132 | 	    "rd_a1 !-100 addi"  /* AT_FDCWD */
133 | 	    "rd_a2 rs1_fp !-16 ld"
134 | 	    "rd_a7 !36 addi"    /* symlinkat */
135 | 	    "ecall");
136 | }
137 | 
138 | 
139 | int _getcwd(char* buf, int size)
140 | {
141 | 	asm("rd_a0 rs1_fp !-8 ld"
142 | 	    "rd_a1 rs1_fp !-16 ld"
143 | 	    "rd_a7 !17 addi"
144 | 	    "ecall");
145 | }
146 | 
147 | 
148 | char* getcwd(char* buf, unsigned size)
149 | {
150 | 	int c = _getcwd(buf, size);
151 | 	if(0 == c) return NULL;
152 | 	return buf;
153 | }
154 | 
155 | 
156 | char* getwd(char* buf)
157 | {
158 | 	return getcwd(buf, __PATH_MAX);
159 | }
160 | 
161 | 
162 | char* get_current_dir_name()
163 | {
164 | 	return getcwd(malloc(__PATH_MAX), __PATH_MAX);
165 | }
166 | 
167 | 
168 | int brk(void *addr)
169 | {
170 | 	asm("rd_a0 rs1_fp !-8 ld"
171 | 	    "rd_a7 !214 addi"
172 | 	    "ecall");
173 | }
174 | 
175 | int uname(struct utsname* unameData)
176 | {
177 | 	asm("rd_a0 rs1_fp !-8 ld"
178 | 	    "rd_a7 !160 addi"
179 | 	    "ecall");
180 | }
181 | 
182 | int unshare(int flags)
183 | {
184 | 	asm("rd_a0 rs1_fp !-8 ld"
185 | 	    "rd_a7 !97 addi"
186 | 	    "ecall");
187 | }
188 | 
189 | int geteuid()
190 | {
191 | 	asm("rd_a7 !175 addi"
192 | 	    "ecall");
193 | }
194 | 
195 | int getegid()
196 | {
197 | 	asm("rd_a7 !177 addi"
198 | 	    "ecall");
199 | }
200 | 
201 | int mount(char *source, char *target, char *filesystemtype, SCM mountflags, void *data)
202 | {
203 | 	asm("rd_a0 rs1_fp !-8 ld"
204 | 	    "rd_a1 rs1_fp !-16 ld"
205 | 	    "rd_a2 rs1_fp !-24 ld"
206 | 	    "rd_a3 rs1_fp !-32 ld"
207 | 	    "rd_a4 rs1_fp !-40 ld"
208 | 	    "rd_a7 !40 addi"
209 | 	    "ecall");
210 | }
211 | 
212 | int chroot(char *path)
213 | {
214 | 	asm("rd_a0 rs1_fp !-8 ld"
215 | 	    "rd_a7 !51 addi"
216 | 	    "ecall");
217 | }
218 | 
219 | #endif
220 | 


--------------------------------------------------------------------------------
/signal.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2021 Andrius Štikonas
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SIGNAL_H
19 | #define _SIGNAL_H
20 | 
21 | #define CLD_EXITED      1       /* child has exited */
22 | #define CLD_KILLED      2       /* child was killed */
23 | #define CLD_DUMPED      3       /* child terminated abnormally */
24 | #define CLD_TRAPPED     4       /* traced child has trapped */
25 | #define CLD_STOPPED     5       /* child has stopped */
26 | #define CLD_CONTINUED   6       /* stopped child has continued */
27 | 
28 | struct siginfo_t {
29 | 	int si_signo;
30 | #ifdef __SI_SWAP_ERRNO_CODE
31 | 	int si_code;
32 | 	int si_errno;
33 | #else
34 | 	int si_errno;
35 | 	int si_code;
36 | #endif
37 | 	int si_pid;
38 | 	int si_uid;
39 | 	int si_status;
40 | 	int si_utime;
41 | 	int si_stime;
42 | };
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/stdarg.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2024 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _STDARG_H
19 | #define _STDARG_H
20 | 
21 | typedef __va_list va_list;
22 | 
23 | /* M2-Planet still has problems with function-like macros. */
24 | #define va_start __va_start
25 | #define va_arg __va_arg
26 | #define va_end __va_end
27 | #define va_copy(ap1, ap2) ap2 = ap1
28 | 
29 | #endif
30 | 


--------------------------------------------------------------------------------
/stdbool.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2024 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _STDBOOL_H
19 | #define _STDBOOL_H
20 | 
21 | #define __bool_true_false_are_defined 1
22 | 
23 | #define bool _Bool
24 | 
25 | #define true 1
26 | #define false 0
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/stddef.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _STDDEF_H
19 | #define _STDDEF_H
20 | #include <sys/types.h>
21 | 
22 | #define NULL 0
23 | typedef long ptrdiff_t;
24 | typedef ulong size_t;
25 | 
26 | #endif
27 | 


--------------------------------------------------------------------------------
/stdint.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2024 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _STDINT_H
19 | #define _STDINT_H
20 | 
21 | #ifdef __M2__
22 | /* nothing needed for M2-Planet as the standard types are included by default*/
23 | #else
24 | /* if we plan on supporting other compilers put stuff here */
25 | #endif
26 | #endif
27 | 


--------------------------------------------------------------------------------
/stdio.h:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | #ifndef _STDIO_H
 19 | #define _STDIO_H
 20 | 
 21 | #ifdef __M2__
 22 | 
 23 | /* Actual format of FILE */
 24 | struct __IO_FILE
 25 | {
 26 | 	int fd;
 27 | 	int bufmode; /* O_RDONLY = 0, O_WRONLY = 1 */
 28 | 	int bufpos;
 29 | 	int file_pos;
 30 | 	int buflen;
 31 | 	char* buffer;
 32 | 	struct __IO_FILE* next;
 33 | 	struct __IO_FILE* prev;
 34 | };
 35 | 
 36 | /* Now give us the FILE we all love */
 37 | typedef struct __IO_FILE FILE;
 38 | 
 39 | #include <stdio.c>
 40 | #else
 41 | 
 42 | #include <stdarg.h>
 43 | #include <sys/types.h>
 44 | #include <sys/stat.h>
 45 | #include <fcntl.h>
 46 | #include <unistd.h>
 47 | #include <stdlib.h>
 48 | 
 49 | /* Required constants */
 50 | /* For file I/O*/
 51 | #define EOF -1
 52 | #define BUFSIZ 4096
 53 | 
 54 | /* For lseek */
 55 | #define SEEK_SET 0
 56 | #define SEEK_CUR 1
 57 | #define SEEK_END 2
 58 | 
 59 | /* Actual format of FILE */
 60 | struct __IO_FILE
 61 | {
 62 | 	int fd;
 63 | 	int bufmode; /* 0 = no buffer, 1 = read, 2 = write */
 64 | 	int bufpos;
 65 | 	int buflen;
 66 | 	char* buffer;
 67 | };
 68 | 
 69 | /* Now give us the FILE we all love */
 70 | typedef struct __IO_FILE FILE;
 71 | 
 72 | /* Required variables */
 73 | extern FILE* stdin;
 74 | extern FILE* stdout;
 75 | extern FILE* stderr;
 76 | 
 77 | /* Standard C functions */
 78 | /* Getting */
 79 | extern int fgetc(FILE* f);
 80 | extern int getchar();
 81 | extern char* fgets(char* str, int count, FILE* stream);
 82 | extern size_t fread( void* buffer, size_t size, size_t count, FILE* stream );
 83 | 
 84 | /* Putting */
 85 | extern void fputc(char s, FILE* f);
 86 | extern void putchar(char s);
 87 | extern int fputs(char const* str, FILE* stream);
 88 | extern int puts(char const* str);
 89 | extern size_t fwrite(void const* buffer, size_t size, size_t count, FILE* stream );
 90 | 
 91 | /* File management */
 92 | extern FILE* fopen(char const* filename, char const* mode);
 93 | extern int fclose(FILE* stream);
 94 | extern int fflush(FILE* stream);
 95 | 
 96 | /* File Positioning */
 97 | extern int ungetc(int ch, FILE* stream);
 98 | extern long ftell(FILE* stream);
 99 | extern int fseek(FILE* f, long offset, int whence);
100 | extern void rewind(FILE* f);
101 | 
102 | /* Variadic functions */
103 | extern int fprintf(FILE* stream, char* format, ...);
104 | extern int printf(char* format, ...);
105 | extern int snprintf(char* s, size_t n, const char* format, ...);
106 | extern int sprintf(char* s, char* format, ...);
107 | extern int vfprintf(FILE* stream, char* format, va_list arg);
108 | extern int vprintf(const char * format, va_list arg);
109 | extern int vsnprintf(char* s, size_t n, const char* format, va_list arg);
110 | extern int vsprintf(char* s, const char* format, va_list arg);
111 | 
112 | #endif
113 | #endif
114 | 


--------------------------------------------------------------------------------
/stdlib.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _STDLIB_H
19 | #define _STDLIB_H
20 | #include <unistd.h>
21 | 
22 | #ifdef __M2__
23 | #include <stdlib.c>
24 | #else
25 | 
26 | 
27 | #define EXIT_FAILURE 1
28 | #define EXIT_SUCCESS 0
29 | 
30 | extern void exit(int value);
31 | 
32 | extern long _malloc_ptr;
33 | extern long _brk_ptr;
34 | 
35 | extern void free(void* l);
36 | extern void* malloc(unsigned size);
37 | extern void* memset(void* ptr, int value, int num);
38 | extern void* calloc(int count, int size);
39 | extern char *getenv(const char *name);
40 | extern int atoi(const char* str);
41 | 
42 | size_t wcstombs(char* dest, const wchar_t* src, size_t n);
43 | 
44 | #endif
45 | #endif
46 | 


--------------------------------------------------------------------------------
/stdnoreturn.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2025 Gtker
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _STDNORETURN_H
19 | #define _STDNORETURN_H
20 | 
21 | #define noreturn _Noreturn
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/string.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _STRING_H
19 | #define _STRING_H
20 | 
21 | #ifdef __M2__
22 | #include <string.c>
23 | #else
24 | #include <stddef.h>
25 | 
26 | /* String manipulation */
27 | char* strcpy(char* dest, char const* src);
28 | char* strncpy(char* dest, char const* src, size_t count);
29 | char* strcat(char* dest, char const* src);
30 | char* strncat(char* dest, char const* src, size_t count);
31 | 
32 | /* String examination */
33 | size_t strlen(char const* str );
34 | size_t strnlen_s(char const* str, size_t strsz );
35 | int strcmp(char const* lhs, char const* rhs );
36 | int strncmp(char const* lhs, char const* rhs, size_t count);
37 | char* strchr(char const* str, int ch);
38 | char* strrchr(char const* str, int ch);
39 | size_t strspn(char const* dest, char const* src);
40 | size_t strcspn(char const* dest, char const* src);
41 | char* strpbrk(char const* dest, char const* breakset);
42 | 
43 | /* Memory manipulation */
44 | void* memset(void* dest, int ch, size_t count);
45 | void* memcpy(void* dest, void const* src, size_t count);
46 | void* memmove(void* dest, void const* src, size_t count);
47 | int memcmp(void const* lhs, void const* rhs, size_t count);
48 | void* memchr(void const* ptr, int ch, size_t count);
49 | char* strstr(const char* haystack, const char* needle);
50 | char* strdup(const char* s);
51 | #endif
52 | #endif
53 | 


--------------------------------------------------------------------------------
/sys/stat.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYS_STAT_H
19 | #define _SYS_STAT_H
20 | 
21 | #ifdef __M2__
22 | #if __uefi__
23 | #include <uefi/sys/stat.c>
24 | #elif __i386__
25 | #include <x86/linux/sys/stat.c>
26 | #elif __x86_64__
27 | #include <amd64/linux/sys/stat.c>
28 | #elif __arm__
29 | #include <armv7l/linux/sys/stat.c>
30 | #elif __aarch64__
31 | #include <aarch64/linux/sys/stat.c>
32 | #elif __riscv && __riscv_xlen==32
33 | #include <riscv32/linux/sys/stat.c>
34 | #elif __riscv && __riscv_xlen==64
35 | #include <riscv64/linux/sys/stat.c>
36 | #elif __knight_posix__
37 | #include <knight/linux/sys/stat.c>
38 | #elif __knight__
39 | #include <knight/native/sys/stat.c>
40 | #else
41 | #error arch not supported
42 | #endif
43 | 
44 | #else
45 | #include <sys/types.h>
46 | 
47 | #define S_IRWXU 00700
48 | #define S_IXUSR 00100
49 | #define S_IWUSR 00200
50 | #define S_IRUSR 00400
51 | 
52 | #define S_ISUID 04000
53 | #define S_ISGID 02000
54 | #define S_IXGRP 00010
55 | #define S_IXOTH 00001
56 | #define S_IRGRP 00040
57 | #define S_IROTH 00004
58 | #define S_IWGRP 00020
59 | #define S_IWOTH 00002
60 | #define S_IRWXG 00070
61 | #define S_IRWXO 00007
62 | 
63 | 
64 | int chmod(char *pathname, int mode);
65 | int fchmod(int a, mode_t b);
66 | int mkdir(char const* a, mode_t b);
67 | int mknod(char const* a, mode_t b, dev_t c);
68 | mode_t umask(mode_t m);
69 | 
70 | #endif
71 | #endif
72 | 


--------------------------------------------------------------------------------
/sys/types.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYS_TYPES_H
19 | #define _SYS_TYPES_H
20 | 
21 | #ifndef __M2__
22 | #include "../gcc_req.h"
23 | #endif
24 | 
25 | typedef SCM ulong;
26 | typedef long ssize_t;
27 | typedef int pid_t;
28 | typedef long intptr_t;
29 | typedef ulong uintptr_t;
30 | typedef long clock_t;
31 | typedef int mode_t;
32 | typedef long dev_t;
33 | #endif
34 | 


--------------------------------------------------------------------------------
/sys/utsname.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2024 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _UTSNAME_H
19 | #define _UTSNAME_H
20 | struct utsname
21 | {
22 | 	char sysname[65];    /* Operating system name (e.g., "Linux") */
23 | 	char nodename[65];   /* Name within "some implementation-defined network" */
24 | 	char release[65];    /* Operating system release (e.g., "2.6.28") */
25 | 	char version[65];    /* Operating system version */
26 | 	char machine[65];    /* Hardware identifier */
27 | };
28 | 
29 | #ifdef __M2__
30 | /* already exists in $ARCH/linux/unistd.c */
31 | #else
32 | int uname(struct utsname*);
33 | #endif
34 | #endif
35 | 


--------------------------------------------------------------------------------
/sys/wait.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2024 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYSWAIT_H
19 | #define _SYSWAIT_H
20 | 
21 | #ifdef __M2__
22 | /* wait is defined in $ARCH/linux/unistd.c files */
23 | #else
24 | /* if we plan on supporting other compilers put stuff here */
25 | #endif
26 | #endif
27 | 


--------------------------------------------------------------------------------
/uefi/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef __FCNTL_C
19 | #define __FCNTL_C
20 | 
21 | #define O_RDONLY 0
22 | #define O_WRONLY 1
23 | #define O_RDWR 2
24 | #define O_CREAT 00100
25 | #define O_EXCL 00200
26 | #define O_TRUNC 001000
27 | #define O_APPEND 002000
28 | 
29 | #define S_IXUSR 00100
30 | #define S_IWUSR 00200
31 | #define S_IRUSR 00400
32 | #define S_IRWXU 00700
33 | 
34 | #include <uefi/uefi.c>
35 | 
36 | void free(void* l);
37 | 
38 | int __open(struct efi_file_protocol* _rootdir, char* name, long mode, long attributes)
39 | {
40 | 	struct efi_file_protocol* new_handle;
41 | 	char* wide_name = _posix_path_to_uefi(name);
42 | 	unsigned rval = __uefi_5(_rootdir, &new_handle, wide_name, mode, attributes, _rootdir->open);
43 | 	free(wide_name);
44 | 	if(rval != EFI_SUCCESS)
45 | 	{
46 | 		return -1;
47 | 	}
48 | 	return new_handle;
49 | }
50 | 
51 | void _set_file_size(struct efi_file_protocol* f, unsigned new_size)
52 | {
53 | 	/* Preallocate some extra space for file_name */
54 | 	size_t file_info_size = sizeof(struct efi_file_info);
55 | 	struct efi_file_info* file_info = calloc(1, file_info_size);
56 | 	unsigned r = __uefi_4(f, &EFI_FILE_INFO_GUID, &file_info_size, file_info, f->get_info);
57 | 	if(r != EFI_SUCCESS)
58 | 	{
59 | 		free(file_info);
60 | 		return;
61 | 	}
62 | 	file_info->file_size = new_size;
63 | 	__uefi_4(f, &EFI_FILE_INFO_GUID, file_info_size, file_info, f->set_info);
64 | 	free(file_info);
65 | }
66 | 
67 | int _open(char* name, int flag, int mode)
68 | {
69 | 	long mode = 0;
70 | 	long attributes = 0;
71 | 	if ((flag == (O_WRONLY | O_CREAT | O_TRUNC)) || (flag == (O_RDWR | O_CREAT | O_EXCL)))
72 | 	{
73 | 		mode = EFI_FILE_MODE_CREATE | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ;
74 | 	}
75 | 	else
76 | 	{       /* Everything else is a read */
77 | 		mode = EFI_FILE_MODE_READ;
78 | 		attributes = EFI_FILE_READ_ONLY;
79 | 	}
80 | 	int handle = __open(_rootdir, name, mode, attributes);
81 | 	if (flag & O_TRUNC)
82 | 	{
83 | 		_set_file_size(handle, 0);
84 | 	}
85 | 	return handle;
86 | }
87 | 
88 | #define STDIN_FILENO  0
89 | #define STDOUT_FILENO 1
90 | #define STDERR_FILENO 2
91 | #endif
92 | 


--------------------------------------------------------------------------------
/uefi/string_p.h:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | #include <stddef.h>
 19 | 
 20 | char* strcpy(char* dest, char const* src)
 21 | {
 22 | 	int i = 0;
 23 | 
 24 | 	while (0 != src[i])
 25 | 	{
 26 | 		dest[i] = src[i];
 27 | 		i = i + 1;
 28 | 	}
 29 | 	dest[i] = 0;
 30 | 
 31 | 	return dest;
 32 | }
 33 | 
 34 | 
 35 | char* strncpy(char* dest, char const* src, size_t count)
 36 | {
 37 | 	if(0 == count) return dest;
 38 | 	size_t i = 0;
 39 | 	while(0 != src[i])
 40 | 	{
 41 | 		dest[i] = src[i];
 42 | 		i = i + 1;
 43 | 		if(count == i) return dest;
 44 | 	}
 45 | 
 46 | 	while(i <= count)
 47 | 	{
 48 | 		dest[i] = 0;
 49 | 		i = i + 1;
 50 | 	}
 51 | 
 52 | 	return dest;
 53 | }
 54 | 
 55 | 
 56 | char* strcat(char* dest, char const* src)
 57 | {
 58 | 	int i = 0;
 59 | 	int j = 0;
 60 | 	while(0 != dest[i]) i = i + 1;
 61 | 	while(0 != src[j])
 62 | 	{
 63 | 		dest[i] = src[j];
 64 | 		i = i + 1;
 65 | 		j = j + 1;
 66 | 	}
 67 | 	dest[i] = 0;
 68 | 	return dest;
 69 | }
 70 | 
 71 | 
 72 | char* strncat(char* dest, char const* src, size_t count)
 73 | {
 74 | 	size_t i = 0;
 75 | 	size_t j = 0;
 76 | 	while(0 != dest[i]) i = i + 1;
 77 | 	while(0 != src[j])
 78 | 	{
 79 | 		if(count == j)
 80 | 		{
 81 | 			dest[i] = 0;
 82 | 			return dest;
 83 | 		}
 84 | 		dest[i] = src[j];
 85 | 		i = i + 1;
 86 | 		j = j + 1;
 87 | 	}
 88 | 	dest[i] = 0;
 89 | 	return dest;
 90 | }
 91 | 
 92 | 
 93 | size_t strlen(char const* str )
 94 | {
 95 | 	size_t i = 0;
 96 | 	while(0 != str[i]) i = i + 1;
 97 | 	return i;
 98 | }
 99 | 
100 | 
101 | size_t strnlen_s(char const* str, size_t strsz )
102 | {
103 | 	size_t i = 0;
104 | 	while(0 != str[i])
105 | 	{
106 | 		if(strsz == i) return i;
107 | 		i = i + 1;
108 | 	}
109 | 	return i;
110 | }
111 | 
112 | 
113 | int strcmp(char const* lhs, char const* rhs )
114 | {
115 | 	int i = 0;
116 | 	while(0 != lhs[i])
117 | 	{
118 | 		if(lhs[i] != rhs[i]) return lhs[i] - rhs[i];
119 | 		i = i + 1;
120 | 	}
121 | 
122 | 	return lhs[i] - rhs[i];
123 | }
124 | 
125 | 
126 | int strncmp(char const* lhs, char const* rhs, size_t count)
127 | {
128 | 	size_t i = 0;
129 | 	while(count > i)
130 | 	{
131 | 		if(0 == lhs[i]) break;
132 | 		if(lhs[i] != rhs[i]) return lhs[i] - rhs[i];
133 | 		i = i + 1;
134 | 	}
135 | 
136 | 	return 0;
137 | }
138 | 
139 | 
140 | char* strchr(char const* str, int ch)
141 | {
142 | 	char* p = str;
143 | 	while(ch != p[0])
144 | 	{
145 | 		if(0 == p[0]) return NULL;
146 | 		p = p + 1;
147 | 	}
148 | 	if(0 == p[0]) return NULL;
149 | 	return p;
150 | }
151 | 
152 | 
153 | char* strrchr(char const* str, int ch)
154 | {
155 | 	char* p = str;
156 | 	int i = 0;
157 | 	while(0 != p[i]) i = i + 1;
158 | 	while(ch != p[i])
159 | 	{
160 | 		if(0 == i) return NULL;
161 | 		i = i - 1;
162 | 	}
163 | 	return (p + i);
164 | }
165 | 
166 | 
167 | size_t strspn(char const* dest, char const* src)
168 | {
169 | 	if(0 == dest[0]) return 0;
170 | 	int i = 0;
171 | 	while(NULL != strchr(src, dest[i])) i = i + 1;
172 | 	return i;
173 | }
174 | 
175 | 
176 | size_t strcspn(char const* dest, char const* src)
177 | {
178 | 	int i = 0;
179 | 	while(NULL == strchr(src, dest[i])) i = i + 1;
180 | 	return i;
181 | }
182 | 
183 | 
184 | char* strpbrk(char const* dest, char const* breakset)
185 | {
186 | 	char* p = dest;
187 | 	char* s;
188 | 	while(0 != p[0])
189 | 	{
190 | 		s = strchr(breakset, p[0]);
191 | 		if(NULL != s) return strchr(p,  s[0]);
192 | 		p = p + 1;
193 | 	}
194 | 	return p;
195 | }
196 | 
197 | 
198 | void* memset(void* dest, int ch, size_t count)
199 | {
200 | 	if(NULL == dest) return dest;
201 | 	size_t i = 0;
202 | 	char* s = dest;
203 | 	while(i < count)
204 | 	{
205 | 		s[i] = ch;
206 | 		i = i + 1;
207 | 	}
208 | 	return dest;
209 | }
210 | 
211 | 
212 | void* memcpy(void* dest, void const* src, size_t count)
213 | {
214 | 	if(NULL == dest) return dest;
215 | 	if(NULL == src) return NULL;
216 | 
217 | 	char* s1 = dest;
218 | 	char const* s2 = src;
219 | 	size_t i = 0;
220 | 	while(i < count)
221 | 	{
222 | 		s1[i] = s2[i];
223 | 		i = i + 1;
224 | 	}
225 | 	return dest;
226 | }
227 | 
228 | void* memmove(void* dest, void const* src, size_t count)
229 | {
230 | 	if (dest < src) return memcpy (dest, src, count);
231 | 	char *p = dest;
232 | 	char const *q = src;
233 | 	count = count - 1;
234 | 	while (count >= 0)
235 | 	{
236 | 		p[count] = q[count];
237 | 		count = count - 1;
238 | 	}
239 | 	return dest;
240 | }
241 | 
242 | 
243 | int memcmp(void const* lhs, void const* rhs, size_t count)
244 | {
245 | 	if(0 == count) return 0;
246 | 	size_t i = 0;
247 | 	count = count - 1;
248 | 	char const* s1 = lhs;
249 | 	char const* s2 = rhs;
250 | 	while(i < count)
251 | 	{
252 | 		if(s1[i] != s2[i]) break;
253 | 		i = i + 1;
254 | 	}
255 | 	return (s1[i] - s2[i]);
256 | }
257 | 


--------------------------------------------------------------------------------
/uefi/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYS_STAT_C
19 | #define _SYS_STAT_C
20 | 
21 | #include <uefi/uefi.c>
22 | #include <sys/types.h>
23 | 
24 | #define S_IRWXU 00700
25 | #define S_IXUSR 00100
26 | #define S_IWUSR 00200
27 | #define S_IRUSR 00400
28 | 
29 | #define S_ISUID 04000
30 | #define S_ISGID 02000
31 | #define S_IXGRP 00010
32 | #define S_IXOTH 00001
33 | #define S_IRGRP 00040
34 | #define S_IROTH 00004
35 | #define S_IWGRP 00020
36 | #define S_IWOTH 00002
37 | #define S_IRWXG 00070
38 | #define S_IRWXO 00007
39 | 
40 | 
41 | int chmod(char *pathname, int mode)
42 | {
43 | 	return 0;
44 | }
45 | 
46 | 
47 | int fchmod(int a, mode_t b)
48 | {
49 | 	return 0;
50 | }
51 | 
52 | int __open(struct efi_file_protocol* _rootdir, char* name, long mode, long attributes);
53 | int mkdir(char const* name, mode_t _mode)
54 | {
55 | 	struct efi_file_protocol* new_directory;
56 | 	long mode = EFI_FILE_MODE_CREATE | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ;
57 | 	long attributes = EFI_FILE_DIRECTORY;
58 | 	long new_directory = __open(_rootdir, name, mode, attributes);
59 | 	if(new_directory != -1)
60 | 	{
61 | 		_close(new_directory);
62 | 		return 0;
63 | 	}
64 | 	return -1;
65 | }
66 | 
67 | 
68 | int mknod(char const* a, mode_t b, dev_t c)
69 | {
70 | 	return -1;
71 | }
72 | 
73 | 
74 | mode_t umask(mode_t m)
75 | {
76 | 	return 0;
77 | }
78 | 
79 | #endif
80 | 


--------------------------------------------------------------------------------
/unistd.h:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _UNISTD_H
19 | #define _UNISTD_H
20 | #include <sys/utsname.h>
21 | #ifdef __M2__
22 | #if __uefi__
23 | #include <uefi/unistd.c>
24 | #elif __i386__
25 | #include <x86/linux/unistd.c>
26 | #elif __x86_64__
27 | #include <amd64/linux/unistd.c>
28 | #elif __arm__
29 | #include <armv7l/linux/unistd.c>
30 | #elif __aarch64__
31 | #include <aarch64/linux/unistd.c>
32 | #elif __riscv && __riscv_xlen==32
33 | #include <riscv32/linux/unistd.c>
34 | #elif __riscv && __riscv_xlen==64
35 | #include <riscv64/linux/unistd.c>
36 | #elif __knight_posix__
37 | #include <knight/linux/unistd.c>
38 | #elif __knight__
39 | #include <knight/native/unistd.c>
40 | #else
41 | #error arch not supported
42 | #endif
43 | 
44 | #else
45 | #define NULL 0
46 | #define __PATH_MAX 4096
47 | 
48 | void* malloc(unsigned size);
49 | int access(char* pathname, int mode);
50 | int chdir(char* path);
51 | int fchdir(int fd);
52 | void _exit(int value);
53 | int fork();
54 | int waitpid (int pid, int* status_ptr, int options);
55 | int execve(char* file_name, char** argv, char** envp);
56 | int read(int fd, char* buf, unsigned count);
57 | int write(int fd, char* buf, unsigned count);
58 | int lseek(int fd, int offset, int whence);
59 | int close(int fd);
60 | int unlink (char *filename);
61 | int symlink(char *path1, char *path2);
62 | int _getcwd(char* buf, int size);
63 | char* getcwd(char* buf, unsigned size);
64 | char* getwd(char* buf);
65 | char* get_current_dir_name();
66 | int brk(void *addr);
67 | 
68 | int uname(struct utsname* unameData);
69 | 
70 | int unshare(int flags);
71 | 
72 | int geteuid();
73 | 
74 | int getegid();
75 | 
76 | int chroot(char const *path);
77 | 
78 | int mount(char const *source, char const *target, char const *filesystemtype, SCM mountflags, void const *data);
79 | 
80 | #endif
81 | #endif
82 | 


--------------------------------------------------------------------------------
/x86/ELF-x86-debug.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### stage0's hex2 format
19 | ###    !<label>          1 byte relative
20 | ###    $<label>          2 byte address
21 | ###    @<label>          2 byte relative
22 | ###    &<label>          4 byte address
23 | ###    %<label>          4 byte relative
24 | 
25 | ### if you wish to use this header, you need to add :ELF_end to the end of your
26 | ### M1 or hex2 files.
27 | 
28 | ## ELF Header
29 | 
30 | :ELF_base
31 | 7F 45 4C 46                    # e_ident[EI_MAG0-3] ELF's magic number
32 | 
33 | 01                             # e_ident[EI_CLASS] Indicating 32 bit
34 | 01                             # e_ident[EI_DATA] Indicating little endianness
35 | 01                             # e_ident[EI_VERSION] Indicating original elf
36 | 
37 | 03                             # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
38 | 00                             # e_ident[EI_ABIVERSION] See above
39 | 
40 | 00 00 00 00 00 00 00           # e_ident[EI_PAD]
41 | 
42 | 02 00                          # e_type Indicating Executable
43 | 03 00                          # e_machine Indicating 386
44 | 01 00 00 00                    # e_version Indicating original elf
45 | 
46 | &_start                        # e_entry Address of the entry point
47 | %ELF_program_headers>ELF_base  # e_phoff Address of program header table
48 | %ELF_section_headers>ELF_base  # e_shoff Address of section header table
49 | 
50 | 00 00 00 00                    # e_flags
51 | 
52 | 34 00                          # e_ehsize Indicating our 52 Byte header
53 | 
54 | 20 00                          # e_phentsize size of a program header table
55 | 01 00                          # e_phnum number of entries in program table
56 | 
57 | 28 00                          # e_shentsize size of a section header table
58 | 05 00                          # e_shnum number of entries in section table
59 | 
60 | 02 00                          # e_shstrndx index of the section names
61 | 
62 | 
63 | :ELF_program_headers
64 | :ELF_program_header__text
65 | 01 00 00 00                    # ph_type: PT-LOAD = 1
66 | 00 00 00 00                    # ph_offset
67 | &ELF_base                      # ph_vaddr
68 | &ELF_base                      # ph_physaddr
69 | %ELF_end>ELF_base              # ph_filesz
70 | %ELF_end>ELF_base              # ph_memsz
71 | 07 00 00 00                    # ph_flags: PF-X|PF-W|PF-R = 7
72 | 01 00 00 00                    # ph_alignment
73 | 
74 | :ELF_text
75 | 


--------------------------------------------------------------------------------
/x86/ELF-x86.hex2:
--------------------------------------------------------------------------------
 1 | ### Copyright (C) 2016 Jeremiah Orians
 2 | ### Copyright (C) 2017 Jan Nieuwenhuizen <janneke@gnu.org>
 3 | ### This file is part of M2-Planet.
 4 | ###
 5 | ### M2-Planet is free software: you can redistribute it and/or modify
 6 | ### it under the terms of the GNU General Public License as published by
 7 | ### the Free Software Foundation, either version 3 of the License, or
 8 | ### (at your option) any later version.
 9 | ###
10 | ### M2-Planet is distributed in the hope that it will be useful,
11 | ### but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | ### GNU General Public License for more details.
14 | ###
15 | ### You should have received a copy of the GNU General Public License
16 | ### along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | ### stage0's hex2 format
19 | ###    !<label>          1 byte relative
20 | ###    $<label>          2 byte address
21 | ###    @<label>          2 byte relative
22 | ###    &<label>          4 byte address
23 | ###    %<label>          4 byte relative
24 | 
25 | ### if you wish to use this header, you need to add :ELF_end to the end of your
26 | ### M1 or hex2 files.
27 | 
28 | ## ELF Header
29 | 
30 | :ELF_base
31 | 7F 45 4C 46                    # e_ident[EI_MAG0-3] ELF's magic number
32 | 
33 | 01                             # e_ident[EI_CLASS] Indicating 32 bit
34 | 01                             # e_ident[EI_DATA] Indicating little endianness
35 | 01                             # e_ident[EI_VERSION] Indicating original elf
36 | 
37 | 03                             # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
38 | 00                             # e_ident[EI_ABIVERSION] See above
39 | 
40 | 00 00 00 00 00 00 00           # e_ident[EI_PAD]
41 | 
42 | 02 00                          # e_type Indicating Executable
43 | 03 00                          # e_machine Indicating 386
44 | 01 00 00 00                    # e_version Indicating original elf
45 | 
46 | &_start                        # e_entry Address of the entry point
47 | %ELF_program_headers>ELF_base  # e_phoff Address of program header table
48 | 00 00 00 00                    # e_shoff Address of section header table
49 | 
50 | 00 00 00 00                    # e_flags
51 | 
52 | 34 00                          # e_ehsize Indicating our 52 Byte header
53 | 
54 | 20 00                          # e_phentsize size of a program header table
55 | 01 00                          # e_phnum number of entries in program table
56 | 
57 | 00 00                          # e_shentsize size of a section header table
58 | 00 00                          # e_shnum number of entries in section table
59 | 
60 | 00 00                          # e_shstrndx index of the section names
61 | 
62 | 
63 | :ELF_program_headers
64 | :ELF_program_header__text
65 | 01 00 00 00                    # ph_type: PT-LOAD = 1
66 | 00 00 00 00                    # ph_offset
67 | &ELF_base                      # ph_vaddr
68 | &ELF_base                      # ph_physaddr
69 | %ELF_end>ELF_base              # ph_filesz
70 | %ELF_end>ELF_base              # ph_memsz
71 | 07 00 00 00                    # ph_flags: PF-X|PF-W|PF-R = 7
72 | 01 00 00 00                    # ph_alignment
73 | 
74 | :ELF_text
75 | 


--------------------------------------------------------------------------------
/x86/libc-core.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2016 Jeremiah Orians
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 
19 | 	mov_ebp,esp                 ; Protect esp
20 | 
21 | 	;; Prepare argv
22 | 	lea_eax,[ebp+DWORD] %4      ; ARGV_address = EBP + 4
23 | 	push_eax                    ; Put argv on the stack
24 | 
25 | 	;; Prepare envp
26 | 	mov_eax,ebp                 ; Address we need to load from
27 | 	mov_eax,[eax]               ; Get ARGC
28 | 	add_eax, %2                 ; OFFSET = ARGC + 2
29 | 	sal_eax, !2                 ; OFFSET = OFFSET * WORDSIZE
30 | 	add_eax,ebp                 ; ENVP_address = ESP + OFFSET
31 | 	push_eax                    ; Put envp on the stack
32 | 
33 | 	;; Stack offset
34 | 	add_ebp, %4                 ; Fix ebp
35 | 
36 | 	;; Perform the main loop
37 | 	call %FUNCTION_main
38 | 	push_eax                    ; Put return on stack
39 | 	push_eax                    ; so that _exit gets the value
40 | 
41 | 	;; Exit to kernel
42 | :FUNCTION_exit
43 | :FUNCTION__exit
44 | 	mov_ebx,eax                 ; Using the return code given by main
45 | 	mov_eax, %1                 ; Syscall exit
46 | 	int !0x80                   ; Exit with that code
47 | 


--------------------------------------------------------------------------------
/x86/libc-full.M1:
--------------------------------------------------------------------------------
 1 | ## Copyright (C) 2016 Jeremiah Orians
 2 | ## This file is part of M2-Planet.
 3 | ##
 4 | ## M2-Planet is free software: you can redistribute it and/or modify
 5 | ## it under the terms of the GNU General Public License as published by
 6 | ## the Free Software Foundation, either version 3 of the License, or
 7 | ## (at your option) any later version.
 8 | ##
 9 | ## M2-Planet is distributed in the hope that it will be useful,
10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | ## GNU General Public License for more details.
13 | ##
14 | ## You should have received a copy of the GNU General Public License
15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 | 
17 | :_start
18 | 
19 | 	mov_ebp,esp                 ; Protect esp
20 | 
21 | 	;; Prepare argv
22 | 	lea_eax,[ebp+DWORD] %4      ; ARGV_address = EBP + 4
23 | 	push_eax                    ; Put argv on the stack
24 | 
25 | 	;; Prepare envp
26 | 	mov_eax,ebp                 ; Address we need to load from
27 | 	mov_eax,[eax]               ; Get ARGC
28 | 	add_eax, %2                 ; OFFSET = ARGC + 2
29 | 	sal_eax, !2                 ; OFFSET = OFFSET * WORDSIZE
30 | 	add_eax,ebp                 ; ENVP_address = ESP + OFFSET
31 | 	push_eax                    ; Put envp on the stack
32 | 	mov_ebx, &GLOBAL__envp      ; Get _envp global
33 | 	mov_[ebx],eax               ; Save environment to _envp
34 | 
35 | 	;; Stack offset
36 | 	add_ebp, %4                 ; Fix ebp
37 | 
38 | 	;; Setup for malloc
39 | 	call %FUNCTION___init_malloc
40 | 
41 | 	;; Setup for FILE*
42 | 	call %FUNCTION___init_io
43 | 
44 | 	;; Perform the main loop
45 | 	call %FUNCTION_main
46 | 	push_eax                    ; Put return on stack
47 | 	push_eax                    ; so that _exit gets the value
48 | 
49 | :FUNCTION_exit
50 | 	call %FUNCTION___kill_io
51 | :FUNCTION__exit
52 | 	pop_ebx
53 | 	pop_ebx
54 | 	mov_eax, %1
55 | 	int !0x80
56 | 
57 | :GLOBAL__envp
58 | 	NULL
59 | 


--------------------------------------------------------------------------------
/x86/linux/bootstrap.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2016 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | enum
 19 | {
 20 | 	stdin = 0,
 21 | 	stdout = 1,
 22 | 	stderr = 2,
 23 | };
 24 | 
 25 | enum
 26 | {
 27 | 	EOF = 0xFFFFFFFF,
 28 | 	NULL = 0,
 29 | };
 30 | 
 31 | enum
 32 | {
 33 | 	EXIT_FAILURE = 1,
 34 | 	EXIT_SUCCESS = 0,
 35 | };
 36 | 
 37 | enum
 38 | {
 39 | 	TRUE = 1,
 40 | 	FALSE = 0,
 41 | };
 42 | 
 43 | 
 44 | int fgetc(FILE* f)
 45 | {
 46 | 	asm("mov_eax, %3"
 47 | 	    "lea_ebx,[esp+DWORD] %4"
 48 | 	    "mov_ebx,[ebx]"
 49 | 	    "push_ebx"
 50 | 	    "mov_ecx,esp"
 51 | 	    "mov_edx, %1"
 52 | 	    "int !0x80"
 53 | 	    "test_eax,eax"
 54 | 	    "pop_eax"
 55 | 	    "jne %FUNCTION_fgetc_Done"
 56 | 	    "mov_eax, %-1"
 57 | 	    ":FUNCTION_fgetc_Done");
 58 | }
 59 | 
 60 | void fputc(char s, FILE* f)
 61 | {
 62 | 	asm("mov_eax, %4"
 63 | 	    "lea_ebx,[esp+DWORD] %4"
 64 | 	    "mov_ebx,[ebx]"
 65 | 	    "lea_ecx,[esp+DWORD] %8"
 66 | 	    "mov_edx, %1"
 67 | 	    "int !0x80");
 68 | }
 69 | 
 70 | void fputs(char* s, FILE* f)
 71 | {
 72 | 	while(0 != s[0])
 73 | 	{
 74 | 		fputc(s[0], f);
 75 | 		s = s + 1;
 76 | 	}
 77 | }
 78 | 
 79 | FILE* open(char* name, int flag, int mode)
 80 | {
 81 | 	asm("lea_ebx,[esp+DWORD] %12"
 82 | 	    "mov_ebx,[ebx]"
 83 | 	    "lea_ecx,[esp+DWORD] %8"
 84 | 	    "mov_ecx,[ecx]"
 85 | 	    "lea_edx,[esp+DWORD] %4"
 86 | 	    "mov_edx,[edx]"
 87 | 	    "mov_eax, %5"
 88 | 	    "int !0x80");
 89 | }
 90 | 
 91 | FILE* fopen(char* filename, char* mode)
 92 | {
 93 | 	FILE* f;
 94 | 	if('w' == mode[0])
 95 | 	{ /* 577 is O_WRONLY|O_CREAT|O_TRUNC, 384 is 600 in octal */
 96 | 		f = open(filename, 577 , 384);
 97 | 	}
 98 | 	else
 99 | 	{ /* Everything else is a read */
100 | 		f = open(filename, 0, 0);
101 | 	}
102 | 
103 | 	/* Negative numbers are error codes */
104 | 	if(0 > f)
105 | 	{
106 | 		return 0;
107 | 	}
108 | 	return f;
109 | }
110 | 
111 | int close(int fd)
112 | {
113 | 	asm("lea_ebx,[esp+DWORD] %4"
114 | 	    "mov_ebx,[ebx]"
115 | 	    "mov_eax, %6"
116 | 	    "int !0x80");
117 | }
118 | 
119 | int fclose(FILE* stream)
120 | {
121 | 	int error = close(stream);
122 | 	return error;
123 | }
124 | 
125 | int brk(void *addr)
126 | {
127 | 	asm("mov_eax,[esp+DWORD] %4"
128 | 	    "push_eax"
129 | 	    "mov_eax, %45"
130 | 	    "pop_ebx"
131 | 	    "int !0x80");
132 | }
133 | 
134 | long _malloc_ptr;
135 | long _brk_ptr;
136 | 
137 | void* malloc(int size)
138 | {
139 | 	if(NULL == _brk_ptr)
140 | 	{
141 | 		_brk_ptr = brk(0);
142 | 		_malloc_ptr = _brk_ptr;
143 | 	}
144 | 
145 | 	if(_brk_ptr < _malloc_ptr + size)
146 | 	{
147 | 		_brk_ptr = brk(_malloc_ptr + size);
148 | 		if(-1 == _brk_ptr) return 0;
149 | 	}
150 | 
151 | 	long old_malloc = _malloc_ptr;
152 | 	_malloc_ptr = _malloc_ptr + size;
153 | 	return old_malloc;
154 | }
155 | 
156 | int strlen(char* str )
157 | {
158 | 	int i = 0;
159 | 	while(0 != str[i]) i = i + 1;
160 | 	return i;
161 | }
162 | 
163 | void* memset(void* ptr, int value, int num)
164 | {
165 | 	char* s;
166 | 	for(s = ptr; 0 < num; num = num - 1)
167 | 	{
168 | 		s[0] = value;
169 | 		s = s + 1;
170 | 	}
171 | }
172 | 
173 | void* calloc(int count, int size)
174 | {
175 | 	void* ret = malloc(count * size);
176 | 	if(NULL == ret) return NULL;
177 | 	memset(ret, 0, (count * size));
178 | 	return ret;
179 | }
180 | 
181 | void free(void* l)
182 | {
183 | 	return;
184 | }
185 | 
186 | void exit(int value)
187 | {
188 | 	asm("pop_ebx"
189 | 	    "pop_ebx"
190 | 	    "mov_eax, %1"
191 | 	    "int !0x80");
192 | }
193 | 


--------------------------------------------------------------------------------
/x86/linux/fcntl.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2016 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef __FCNTL_C
19 | #define __FCNTL_C
20 | 
21 | #define O_RDONLY 0
22 | #define O_WRONLY 1
23 | #define O_RDWR 2
24 | #define O_CREAT 00100
25 | #define O_EXCL 00200
26 | #define O_TRUNC 001000
27 | #define O_APPEND 002000
28 | 
29 | #define S_IXUSR 00100
30 | #define S_IWUSR 00200
31 | #define S_IRUSR 00400
32 | #define S_IRWXU 00700
33 | 
34 | 
35 | int _open(char* name, int flag, int mode)
36 | {
37 | 	asm("lea_ebx,[esp+DWORD] %12"
38 | 	    "mov_ebx,[ebx]"
39 | 	    "lea_ecx,[esp+DWORD] %8"
40 | 	    "mov_ecx,[ecx]"
41 | 	    "lea_edx,[esp+DWORD] %4"
42 | 	    "mov_edx,[edx]"
43 | 	    "mov_eax, %5"
44 | 	    "int !0x80");
45 | }
46 | 
47 | #define STDIN_FILENO  0
48 | #define STDOUT_FILENO 1
49 | #define STDERR_FILENO 2
50 | #endif
51 | 


--------------------------------------------------------------------------------
/x86/linux/sys/stat.c:
--------------------------------------------------------------------------------
 1 | /* Copyright (C) 2020 Jeremiah Orians
 2 |  * This file is part of M2-Planet.
 3 |  *
 4 |  * M2-Planet is free software: you can redistribute it and/or modify
 5 |  * it under the terms of the GNU General Public License as published by
 6 |  * the Free Software Foundation, either version 3 of the License, or
 7 |  * (at your option) any later version.
 8 |  *
 9 |  * M2-Planet is distributed in the hope that it will be useful,
10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 |  * GNU General Public License for more details.
13 |  *
14 |  * You should have received a copy of the GNU General Public License
15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
16 |  */
17 | 
18 | #ifndef _SYS_STAT_C
19 | #define _SYS_STAT_C
20 | 
21 | #include <sys/types.h>
22 | 
23 | #define S_IRWXU 00700
24 | #define S_IXUSR 00100
25 | #define S_IWUSR 00200
26 | #define S_IRUSR 00400
27 | 
28 | #define S_ISUID 04000
29 | #define S_ISGID 02000
30 | #define S_IXGRP 00010
31 | #define S_IXOTH 00001
32 | #define S_IRGRP 00040
33 | #define S_IROTH 00004
34 | #define S_IWGRP 00020
35 | #define S_IWOTH 00002
36 | #define S_IRWXG 00070
37 | #define S_IRWXO 00007
38 | 
39 | 
40 | int chmod(char *pathname, int mode)
41 | {
42 | 	asm("lea_ebx,[esp+DWORD] %8"
43 | 	    "mov_ebx,[ebx]"
44 | 	    "lea_ecx,[esp+DWORD] %4"
45 | 	    "mov_ecx,[ecx]"
46 | 	    "mov_eax, %15"
47 | 	    "int !0x80");
48 | }
49 | 
50 | 
51 | int fchmod(int a, mode_t b)
52 | {
53 | 	asm("lea_ebx,[esp+DWORD] %8"
54 | 	    "mov_ebx,[ebx]"
55 | 	    "lea_ecx,[esp+DWORD] %4"
56 | 	    "mov_ecx,[ecx]"
57 | 	    "mov_eax, %94"
58 | 	    "int !0x80");
59 | }
60 | 
61 | 
62 | int mkdir(char const* a, mode_t b)
63 | {
64 | 	asm("lea_ebx,[esp+DWORD] %8"
65 | 	    "mov_ebx,[ebx]"
66 | 	    "lea_ecx,[esp+DWORD] %4"
67 | 	    "mov_ecx,[ecx]"
68 | 	    "mov_eax, %39"
69 | 	    "int !0x80");
70 | }
71 | 
72 | 
73 | int mknod(char const* a, mode_t b, dev_t c)
74 | {
75 | 	asm("lea_ebx,[esp+DWORD] %12"
76 | 	    "mov_ebx,[ebx]"
77 | 	    "lea_ecx,[esp+DWORD] %8"
78 | 	    "mov_ecx,[ecx]"
79 | 	    "lea_edx,[esp+DWORD] %4"
80 | 	    "mov_edx,[edx]"
81 | 	    "mov_eax, %14"
82 | 	    "int !0x80");
83 | }
84 | 
85 | 
86 | mode_t umask(mode_t m)
87 | {
88 | 	asm("lea_ebx,[esp+DWORD] %4"
89 | 	    "mov_ebx,[ebx]"
90 | 	    "mov_eax, %60"
91 | 	    "int !0x80");
92 | }
93 | 
94 | #endif
95 | 


--------------------------------------------------------------------------------
/x86/linux/unistd.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (C) 2020 Jeremiah Orians
  2 |  * This file is part of M2-Planet.
  3 |  *
  4 |  * M2-Planet is free software: you can redistribute it and/or modify
  5 |  * it under the terms of the GNU General Public License as published by
  6 |  * the Free Software Foundation, either version 3 of the License, or
  7 |  * (at your option) any later version.
  8 |  *
  9 |  * M2-Planet is distributed in the hope that it will be useful,
 10 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 |  * GNU General Public License for more details.
 13 |  *
 14 |  * You should have received a copy of the GNU General Public License
 15 |  * along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 |  */
 17 | 
 18 | #ifndef _UNISTD_C
 19 | #define _UNISTD_C
 20 | #include <sys/utsname.h>
 21 | #define NULL 0
 22 | #define __PATH_MAX 4096
 23 | 
 24 | void* malloc(unsigned size);
 25 | 
 26 | int access(char* pathname, int mode)
 27 | {
 28 | 	asm("lea_ebx,[esp+DWORD] %8"
 29 | 	    "mov_ebx,[ebx]"
 30 | 	    "lea_ecx,[esp+DWORD] %4"
 31 | 	    "mov_ecx,[ecx]"
 32 | 	    "mov_eax, %33"
 33 | 	    "int !0x80");
 34 | }
 35 | 
 36 | int chdir(char* path)
 37 | {
 38 | 	asm("lea_ebx,[esp+DWORD] %4"
 39 | 	    "mov_ebx,[ebx]"
 40 | 	    "mov_eax, %12"
 41 | 	    "int !0x80");
 42 | }
 43 | 
 44 | int fchdir(int fd)
 45 | {
 46 | 	asm("lea_ebx,[esp+DWORD] %4"
 47 | 	    "mov_ebx,[ebx]"
 48 | 	    "mov_eax, %133"
 49 | 	    "int !0x80");
 50 | }
 51 | 
 52 | /* Defined in the libc */
 53 | void _exit(int value);
 54 | 
 55 | int fork()
 56 | {
 57 | 	asm("mov_eax, %2"
 58 | 	    "mov_ebx, %0"
 59 | 	    "int !0x80");
 60 | }
 61 | 
 62 | 
 63 | int waitpid (int pid, int* status_ptr, int options)
 64 | {
 65 | 	asm("lea_ebx,[esp+DWORD] %12"
 66 | 	    "mov_ebx,[ebx]"
 67 | 	    "lea_ecx,[esp+DWORD] %8"
 68 | 	    "mov_ecx,[ecx]"
 69 | 	    "lea_edx,[esp+DWORD] %4"
 70 | 	    "mov_edx,[edx]"
 71 | 	    "mov_eax, %7"
 72 | 	    "int !0x80");
 73 | }
 74 | 
 75 | 
 76 | int execve(char* file_name, char** argv, char** envp)
 77 | {
 78 | 	asm("lea_ebx,[esp+DWORD] %12"
 79 | 	    "mov_ebx,[ebx]"
 80 | 	    "lea_ecx,[esp+DWORD] %8"
 81 | 	    "mov_ecx,[ecx]"
 82 | 	    "lea_edx,[esp+DWORD] %4"
 83 | 	    "mov_edx,[edx]"
 84 | 	    "mov_eax, %11"
 85 | 	    "int !0x80");
 86 | }
 87 | 
 88 | int read(int fd, char* buf, unsigned count) {
 89 | 	asm("lea_ebx,[esp+DWORD] %12"
 90 | 	    "mov_ebx,[ebx]"
 91 | 	    "lea_ecx,[esp+DWORD] %8"
 92 | 	    "mov_ecx,[ecx]"
 93 | 	    "lea_edx,[esp+DWORD] %4"
 94 | 	    "mov_edx,[edx]"
 95 | 	    "mov_eax, %3"
 96 | 	    "int !0x80");
 97 | }
 98 | 
 99 | int write(int fd, char* buf, unsigned count) {
100 | 	asm("lea_ebx,[esp+DWORD] %12"
101 | 	    "mov_ebx,[ebx]"
102 | 	    "lea_ecx,[esp+DWORD] %8"
103 | 	    "mov_ecx,[ecx]"
104 | 	    "lea_edx,[esp+DWORD] %4"
105 | 	    "mov_edx,[edx]"
106 | 	    "mov_eax, %4"
107 | 	    "int !0x80");
108 | }
109 | 
110 | int lseek(int fd, int offset, int whence)
111 | {
112 | 	asm("lea_ebx,[esp+DWORD] %12"
113 | 	    "mov_ebx,[ebx]"
114 | 	    "lea_ecx,[esp+DWORD] %8"
115 | 	    "mov_ecx,[ecx]"
116 | 	    "lea_edx,[esp+DWORD] %4"
117 | 	    "mov_edx,[edx]"
118 | 	    "mov_eax, %19"
119 | 	    "int !0x80");
120 | }
121 | 
122 | int close(int fd)
123 | {
124 | 	asm("lea_ebx,[esp+DWORD] %4"
125 | 	    "mov_ebx,[ebx]"
126 | 	    "mov_eax, %6"
127 | 	    "int !0x80");
128 | }
129 | 
130 | 
131 | int unlink (char *filename)
132 | {
133 | 	asm("lea_ebx,[esp+DWORD] %4"
134 | 	    "mov_ebx,[ebx]"
135 | 	    "mov_eax, %10"
136 | 	    "int !0x80");
137 | }
138 | 
139 | int symlink(char *path1, char *path2)
140 | {
141 | 	asm("lea_ebx,[esp+DWORD] %8"
142 | 	    "mov_ebx,[ebx]"
143 | 	    "lea_ecx,[esp+DWORD] %4"
144 | 	    "mov_ecx,[ecx]"
145 | 	    "mov_eax, %83"
146 | 	    "int !0x80");
147 | }
148 | 
149 | int _getcwd(char* buf, int size)
150 | {
151 | 	asm("lea_ebx,[esp+DWORD] %8"
152 | 	    "mov_ebx,[ebx]"
153 | 	    "lea_ecx,[esp+DWORD] %4"
154 | 	    "mov_ecx,[ecx]"
155 | 	    "mov_eax, %183"
156 | 	    "int !0x80");
157 | }
158 | 
159 | 
160 | char* getcwd(char* buf, unsigned size)
161 | {
162 | 	int c = _getcwd(buf, size);
163 | 	if(0 == c) return NULL;
164 | 	return buf;
165 | }
166 | 
167 | 
168 | char* getwd(char* buf)
169 | {
170 | 	return getcwd(buf, __PATH_MAX);
171 | }
172 | 
173 | 
174 | char* get_current_dir_name()
175 | {
176 | 	return getcwd(malloc(__PATH_MAX), __PATH_MAX);
177 | }
178 | 
179 | 
180 | int brk(void *addr)
181 | {
182 | 	asm("mov_eax,[esp+DWORD] %4"
183 | 	    "push_eax"
184 | 	    "mov_eax, %45"
185 | 	    "pop_ebx"
186 | 	    "int !0x80");
187 | }
188 | 
189 | int uname(struct utsname* unameData)
190 | {
191 | 	asm("lea_ebx,[esp+DWORD] %4"
192 | 	    "mov_ebx,[ebx]"
193 | 	    "mov_eax, %109"
194 | 	    "int !0x80");
195 | }
196 | 
197 | int unshare(int flags)
198 | {
199 | 	asm("lea_ebx,[esp+DWORD] %4"
200 | 	    "mov_ebx,[ebx]"
201 | 	    "mov_eax, %310"
202 | 	    "int !0x80");
203 | }
204 | 
205 | int geteuid()
206 | {
207 | 	asm("mov_eax, %201"
208 | 	    "int !0x80");
209 | }
210 | 
211 | int getegid()
212 | {
213 | 	asm("mov_eax, %202"
214 | 	    "int !0x80");
215 | }
216 | 
217 | int mount(char *source, char *target, char *filesystemtype, SCM mountflags, void *data)
218 | {
219 | 	asm("push_esi"
220 | 	    "lea_ebx,[esp+DWORD] %24"
221 | 	    "mov_ebx,[ebx]"
222 | 	    "lea_ecx,[esp+DWORD] %20"
223 | 	    "mov_ecx,[ecx]"
224 | 	    "lea_edx,[esp+DWORD] %16"
225 | 	    "mov_edx,[edx]"
226 | 	    "lea_esi,[esp+DWORD] %12"
227 | 	    "mov_esi,[esi]"
228 | 	    "lea_edi,[esp+DWORD] %8"
229 | 	    "mov_edi,[edi]"
230 | 	    "mov_eax, %21"
231 | 	    "int !0x80"
232 | 	    "pop_esi");
233 | }
234 | 
235 | int chroot(char *path)
236 | {
237 | 	asm("lea_ebx,[esp+DWORD] %4"
238 | 	    "mov_ebx,[ebx]"
239 | 	    "mov_eax, %61"
240 | 	    "int !0x80");
241 | }
242 | 
243 | #endif
244 | 


--------------------------------------------------------------------------------
/x86/x86_defs.M1:
--------------------------------------------------------------------------------
  1 | ## Copyright (C) 2017 Jeremiah Orians
  2 | ## This file is part of M2-Planet.
  3 | ##
  4 | ## M2-Planet is free software: you can redistribute it and/or modify
  5 | ## it under the terms of the GNU General Public License as published by
  6 | ## the Free Software Foundation, either version 3 of the License, or
  7 | ## (at your option) any later version.
  8 | ##
  9 | ## M2-Planet is distributed in the hope that it will be useful,
 10 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 | ## GNU General Public License for more details.
 13 | ##
 14 | ## You should have received a copy of the GNU General Public License
 15 | ## along with M2-Planet.  If not, see <http://www.gnu.org/licenses/>.
 16 | 
 17 | 
 18 | DEFINE add_eax, 05
 19 | DEFINE add_eax,BYTE 83C0
 20 | DEFINE add_ebp, 81C5
 21 | DEFINE add_ebx,eax 01C3
 22 | DEFINE add_eax,ebp 01E8
 23 | DEFINE add_eax,ebx 01D8
 24 | DEFINE add_eax,ecx 01C8
 25 | DEFINE add_eax,edx 01D0
 26 | DEFINE add_eax,edi 01F8
 27 | DEFINE add_esp,ecx 01CC
 28 | DEFINE add_esp,edx 01D4
 29 | DEFINE add_esp,ebx 01DC
 30 | DEFINE add_esp,edi 01FC
 31 | DEFINE and_eax,ebx 21D8
 32 | DEFINE call E8
 33 | DEFINE call_eax FFD0
 34 | DEFINE cmp 39C3
 35 | DEFINE cdq 99
 36 | DEFINE div_ebx F7F3
 37 | DEFINE idiv_ebx F7FB
 38 | DEFINE int CD
 39 | DEFINE je 0F84
 40 | DEFINE jne 0F85
 41 | DEFINE jmp E9
 42 | DEFINE lea_eax,[ecx+DWORD] 8D81
 43 | DEFINE lea_eax,[edx+DWORD] 8D82
 44 | DEFINE lea_eax,[ebp+DWORD] 8D85
 45 | DEFINE lea_eax,[esi+DWORD] 8D86
 46 | DEFINE lea_eax,[edi+DWORD] 8D87
 47 | DEFINE lea_eax,[esp+DWORD] 8D8424
 48 | DEFINE lea_ebx,[esp+DWORD] 8D9C24
 49 | DEFINE lea_ebx,[ecx+DWORD] 8D99
 50 | DEFINE lea_ebx,[edx+DWORD] 8D9A
 51 | DEFINE lea_ebx,[esi+DWORD] 8D9E
 52 | DEFINE lea_ebx,[edi+DWORD] 8D9F
 53 | DEFINE lea_ecx,[esp+DWORD] 8D8C24
 54 | DEFINE lea_edx,[esp+DWORD] 8D9424
 55 | DEFINE lea_esi,[esp+DWORD] 8DB424
 56 | DEFINE lea_edi,[esp+DWORD] 8DBC24
 57 | DEFINE mov_eax,[esp+DWORD] 8B8424
 58 | DEFINE mov_eax,ebp 89E8
 59 | DEFINE mov_eax,ebx 89D8
 60 | DEFINE mov_eax,ebx 89D8
 61 | DEFINE mov_eax,ecx 89C8
 62 | DEFINE mov_eax,edx 89D0
 63 | DEFINE mov_edx,eax 89C2
 64 | DEFINE mov_ebx,eax 89C3
 65 | DEFINE mov_ecx,eax 89C1
 66 | DEFINE mov_ecx,esp 89E1
 67 | DEFINE mov_esi,esp 89E6
 68 | DEFINE mov_edi,esp 89E7
 69 | DEFINE mov_ebp,edi 89fd
 70 | DEFINE mov_esp,esi 89F4
 71 | DEFINE mov_ebp,esp 89E5
 72 | DEFINE mov_esp,ebp 89EC
 73 | DEFINE mov_eax, B8
 74 | DEFINE mov_ebx, BB
 75 | DEFINE mov_ecx, B9
 76 | DEFINE mov_edx, BA
 77 | DEFINE mov_edi, BF
 78 | DEFINE mov_edx, BA
 79 | DEFINE mov_eax,[eax] 8B00
 80 | DEFINE mov_ebx,[ebx] 8B1B
 81 | DEFINE mov_ecx,[ecx] 8B09
 82 | DEFINE mov_edx,[edx] 8B12
 83 | DEFINE mov_esi,[esi] 8B36
 84 | DEFINE mov_edi,[edi] 8B3F
 85 | DEFINE mov_[ebx],al 8803
 86 | DEFINE mov_[ebx],ax 668903
 87 | DEFINE mov_[ebx],eax 8903
 88 | DEFINE movsx_eax,BYTE_PTR_[eax] 0FBE00
 89 | DEFINE movsx_ebx,BYTE_PTR_[ebx] 0FBE1B
 90 | DEFINE movsx_eax,WORD_PTR_[eax] 0FBF00
 91 | DEFINE movzx_eax,BYTE_PTR_[eax] 0FB600
 92 | DEFINE movzx_eax,WORD_PTR_[eax] 0FB700
 93 | DEFINE movzx_eax,al 0FB6C0
 94 | DEFINE mul_ebx F7E3
 95 | DEFINE mul_ecx F7E1
 96 | DEFINE mul_edx F7E2
 97 | DEFINE mul_edi F7E7
 98 | DEFINE imul_ebx F7EB
 99 | DEFINE NULL 00000000
100 | DEFINE not_eax F7D0
101 | DEFINE or_eax,ebx 09D8
102 | DEFINE pop_eax 58
103 | DEFINE pop_ebx 5B
104 | DEFINE pop_ebp 5D
105 | DEFINE pop_esi 5E
106 | DEFINE pop_edi 5F
107 | DEFINE push_eax 50
108 | DEFINE push_ebx 53
109 | DEFINE push_ebp 55
110 | DEFINE push_esi 56
111 | DEFINE push_edi 57
112 | DEFINE ret C3
113 | DEFINE sal_eax, C1E0
114 | DEFINE sal_eax,cl D3E0
115 | DEFINE shl_eax,cl D3E0
116 | DEFINE sar_eax,cl D3F8
117 | DEFINE shr_eax,cl D3E8
118 | DEFINE seta_al 0F97C0
119 | DEFINE setae_al 0F93C0
120 | DEFINE setb_al 0F92C0
121 | DEFINE setbe_al 0F96C0
122 | DEFINE sete_al 0F94C0
123 | DEFINE setle_al 0F9EC0
124 | DEFINE setl_al 0F9CC0
125 | DEFINE setge_al 0F9DC0
126 | DEFINE setg_al 0F9FC0
127 | DEFINE setne_al 0F95C0
128 | DEFINE sub_eax, 2d
129 | DEFINE sub_eax,BYTE 83E8
130 | DEFINE sub_eax,ebx 29D8
131 | DEFINE sub_eax,ecx 29C8
132 | DEFINE sub_eax,edx 29D0
133 | DEFINE sub_eax,edi 29F8
134 | DEFINE sub_ebx,eax 29C3
135 | DEFINE sub_esp, 81EC
136 | DEFINE sub_esp,BYTE 83EC
137 | DEFINE sub_esp,edi 29FC
138 | DEFINE sub_esp,ecx 29CC
139 | DEFINE sub_esp,edx 29D4
140 | DEFINE test_eax,eax 85C0
141 | DEFINE xchg_ebx,eax 93
142 | DEFINE xor_eax,ebx 31D8
143 | DEFINE xor_eax,eax 31C0
144 | DEFINE xor_ebx,ebx 31DB
145 | DEFINE xor_ecx,ecx 31C9
146 | DEFINE xor_edx,edx 31D2
147 | DEFINE xor_edi,edi 31FF
148 | DEFINE xor_esi,esi 31F6
149 | 


--------------------------------------------------------------------------------