birth-software/bloat-buster
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Start embracing the devil: CMake

Browse Source
This commit is contained in:
David Gonzalez Martin 2024-10-19 15:18:48 -06:00 committed by David
parent 4d058bebf6
commit f7c1077706
25 changed files with 13700 additions and 4594 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
.github/workflows/ci.yml vendored
View File

@ -9,12 +9,14 @@ on:
- cron: "0 0 * * *"
jobs:
linux_build_and_test:
linux_Debug:
runs-on: ubuntu-24.04
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: sudo apt install -y ninja-build
- name: System information
run: |
uname -a
@ -22,34 +24,180 @@ jobs:
clang -v
- name: Build and test
run: |
./project.sh test all
macos_build_and_test:
./project.sh "build_type=Debug" test all
linux_MinSizeRel:
runs-on: ubuntu-24.04
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: sudo apt install -y ninja-build
- name: System information
run: |
uname -a
lsb_release -a
clang -v
- name: Build and test
run: |
./project.sh "build_type=MinSizeRel" test all
linux_RelWithDebInfo:
runs-on: ubuntu-24.04
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: sudo apt install -y ninja-build
- name: System information
run: |
uname -a
lsb_release -a
clang -v
- name: Build and test
run: |
./project.sh "build_type=RelWithDebInfo" test all
linux_Release:
runs-on: ubuntu-24.04
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: sudo apt install -y ninja-build
- name: System information
run: |
uname -a
lsb_release -a
clang -v
- name: Build and test
run: |
./project.sh "build_type=Release" test all
macos_Debug:
runs-on: macos-15
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install LLVM
- name: Install dependencies
run: |
brew install llvm
brew install llvm ninja
- name: System information
run: |
uname -a
sw_vers -productVersion
clang -v
- name: Build and test
run: ./project.sh "build_type=Debug" test all
macos_MinSizeRel:
runs-on: macos-15
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: |
./project.sh test all
windows_build_and_test:
brew install llvm ninja
- name: System information
run: |
uname -a
sw_vers -productVersion
clang -v
- name: Build and test
run: ./project.sh "build_type=MinSizeRel" test all
macos_RelWithDebInfo:
runs-on: macos-15
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: |
brew install llvm ninja
- name: System information
run: |
uname -a
sw_vers -productVersion
clang -v
- name: Build and test
run: ./project.sh "build_type=RelWithDebInfo" test all
macos_Release:
runs-on: macos-15
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: |
brew install llvm ninja
- name: System information
run: |
uname -a
sw_vers -productVersion
clang -v
- name: Build and test
run: ./project.sh "build_type=Release" test all
windows_Debug:
runs-on: windows-latest
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: choco install ninja
# - name: System information
# run: |
# systeminfo
# clang -v
- name: Build and test
run: |
./project.bat test all
run: pwsh ./project.ps1 "build_type=Debug" test all
env:
LANG: en_US.UTF-8 # Ensure UTF-8 encoding
windows_MinSizeRel:
runs-on: windows-latest
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: choco install ninja
# - name: System information
# run: |
# systeminfo
# clang -v
- name: Build and test
run: pwsh ./project.ps1 "build_type=MinSizeRel" test all
env:
LANG: en_US.UTF-8 # Ensure UTF-8 encoding
windows_RelWithDebInfo:
runs-on: windows-latest
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: choco install ninja
# - name: System information
# run: |
# systeminfo
# clang -v
- name: Build and test
run: pwsh ./project.ps1 "build_type=RelWithDebInfo" test all
env:
LANG: en_US.UTF-8 # Ensure UTF-8 encoding
windows_Release:
runs-on: windows-latest
timeout-minutes: 15
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Install dependencies
run: choco install ninja
# - name: System information
# run: |
# systeminfo
# clang -v
- name: Build and test
run: pwsh ./project.ps1 "build_type=Release" test all
env:
LANG: en_US.UTF-8 # Ensure UTF-8 encoding

1
.gitignore vendored
View File

@ -4,3 +4,4 @@ nest/
perf.data*
project
project.dSYM/
.cache/

36
CMakeLists.txt Normal file
View File

@ -0,0 +1,36 @@
cmake_minimum_required(VERSION 3.10)
project(nest)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_C_STANDARD 23)
set(CMAKE_CXX_STANDARD 23)
add_compile_options(
-pedantic
-Wall -Wextra -Wpedantic
-Wno-nested-anon-types -Wno-keyword-macro -Wno-gnu-auto-type -Wno-auto-decl-extensions -Wno-gnu-empty-initializer -Wno-fixed-enum-extension -Wno-gnu-binary-literal
-fno-exceptions -fno-stack-protector
-fdiagnostics-color=always -ferror-limit=1
-march=native
)
include_directories("bootstrap/include")
set(LIBRARY_NAME "std")
set(RUNNER_NAME "runner")
set(COMPILER_NAME "nest")
add_library("${LIBRARY_NAME}"
"bootstrap/std/base.c"
"bootstrap/std/string.c"
"bootstrap/std/os.c"
"bootstrap/std/entry_point.c"
"bootstrap/std/virtual_buffer.c"
"bootstrap/std/md5.c"
"bootstrap/std/sha1.c"
)
add_executable("${RUNNER_NAME}" "bootstrap/runner/runner.c")
target_link_libraries(${RUNNER_NAME} ${LIBRARY_NAME})
add_executable("${COMPILER_NAME}"
"bootstrap/src/main.c"
"bootstrap/src/pdb_image.c"
)
target_link_libraries(${COMPILER_NAME} ${LIBRARY_NAME})

611
bootstrap/build.c
View File

@ -1,611 +0,0 @@
#include "lib.h"
#define build_dir "build"
#define nest_dir "nest"
typedef enum OptimizationMode : u8
{
O0,
O1,
O2,
O3,
Os,
Oz,
OPTIMIZATION_COUNT,
} OptimizationMode;
declare_slice(OptimizationMode);
typedef enum Compiler : u8
{
gcc,
clang,
COMPILER_COUNT,
} Compiler;
declare_slice(Compiler);
global const Compiler default_compiler = clang;
typedef enum Linkage: u8
{
LINKAGE_DYNAMIC,
LINKAGE_STATIC,
LINKAGE_COUNT,
} Linkage;
declare_slice(Linkage);
STRUCT(CompileOptions)
{
char* out_path;
char* in_path;
OptimizationMode optimization_mode:3;
u8 debug_info:1;
u8 error_on_warning:1;
Compiler compiler:1;
Linkage linkage:1;
};
decl_vbp(char);
fn u8 is_debug(OptimizationMode optimization_mode, u8 debug_info)
{
return (optimization_mode == O0) & (debug_info != 0);
}
fn void compile_c(Arena* arena, CompileOptions options, char** envp)
{
VirtualBufferP(char) argument_stack = {};
auto* args = &argument_stack;
char* compiler;
switch (options.compiler)
{
case gcc:
compiler = "/usr/bin/gcc";
break;
case clang:
#if _WIN32
compiler = "clang";
#elif defined( __APPLE__)
compiler = "/opt/homebrew/opt/llvm/bin/clang";
#else
compiler = "/usr/bin/clang";
#endif
break;
case COMPILER_COUNT:
unreachable();
}
*vb_add(args, 1) = compiler;
// *vb_add(args, 1) = "-E";
*vb_add(args, 1) = options.in_path;
*vb_add(args, 1) = "-o";
*vb_add(args, 1) = options.out_path;
if (options.debug_info)
{
*vb_add(args, 1) = "-g";
}
switch (options.optimization_mode)
{
case O0:
*vb_add(args, 1) = "-O0";
break;
case O1:
*vb_add(args, 1) = "-O1";
break;
case O2:
*vb_add(args, 1) = "-O2";
break;
case O3:
*vb_add(args, 1) = "-O3";
break;
case Os:
*vb_add(args, 1) = "-Os";
break;
case Oz:
*vb_add(args, 1) = "-Oz";
break;
case OPTIMIZATION_COUNT:
unreachable();
}
*vb_add(args, 1) = "-march=native";
if (options.error_on_warning)
{
*vb_add(args, 1) = "-Werror";
}
char* general_options[] = {
"-std=gnu2x",
"-Wall",
"-Wextra",
"-Wpedantic",
"-Wconversion",
"-Wno-nested-anon-types",
"-Wno-keyword-macro",
"-Wno-gnu-auto-type",
"-Wno-auto-decl-extensions",
"-Wno-gnu-empty-initializer",
"-Wno-fixed-enum-extension",
"-Wno-gnu-binary-literal",
"-pedantic",
"-fno-exceptions",
"-fno-stack-protector",
"-ferror-limit=1",
};
memcpy(vb_add(args, array_length(general_options)), general_options, sizeof(general_options));
if (!is_debug(options.optimization_mode, options.debug_info))
{
*vb_add(args, 1) = "-DNDEBUG=1";
}
if (options.linkage == LINKAGE_STATIC)
{
char* static_options[] = { "-ffreestanding", "-nostdlib", "-static", "-DSTATIC", "-lgcc" };
memcpy(vb_add(args, array_length(static_options)), static_options, sizeof(static_options));
}
// *vb_add(args, 1) = "-DSILENT";
if (options.compiler == clang)
{
*vb_add(args, 1) = "-MJ";
*vb_add(args, 1) = build_dir "/" "compile_commands.json";
}
*vb_add(args, 1) = 0;
run_command(arena, (CStringSlice) { .pointer = args->pointer, .length = args->length }, envp);
}
typedef enum CompilerBackend
{
COMPILER_BACKEND_INTERPRETER,
COMPILER_BACKEND_C,
COMPILER_BACKEND_MACHINE,
COMPILER_BACKEND_COUNT,
} CompilerBackend;
declare_slice(CompilerBackend);
fn void compile_and_run(Arena* arena, CompileOptions options, char** envp, CompilerBackend compiler_backend, u8 debug, char* nest_source_path)
{
compile_c(arena, options, envp);
CStringSlice args = {};
char* compiler_backend_string;
switch (compiler_backend)
{
case COMPILER_BACKEND_C:
compiler_backend_string = "c";
break;
case COMPILER_BACKEND_INTERPRETER:
compiler_backend_string = "i";
break;
case COMPILER_BACKEND_MACHINE:
compiler_backend_string = "m";
break;
case COMPILER_BACKEND_COUNT:
unreachable();
}
#define common_compile_and_run_args \
options.out_path, \
nest_source_path, \
compiler_backend_string, \
0,
if (debug)
{
#if _WIN32
args = (CStringSlice) array_to_slice(((char*[]){
"C:\\Users\\David\\Downloads\\remedybg_0_4_0_7\\remedybg.exe",
"-g",
common_compile_and_run_args
}));
#elif defined(__linux__)
args = (CStringSlice) array_to_slice(((char*[]){
"/home/david/source/gf/gf2",
"-ex",
"set auto-solib-add off",
"-ex",
"r",
"--args",
common_compile_and_run_args
}));
#elif defined(__APPLE__)
args = (CStringSlice) array_to_slice(((char*[]){
"/usr/bin/lldb",
"-o",
"run",
"--",
common_compile_and_run_args
}));
#endif
}
else
{
args = (CStringSlice) array_to_slice(((char*[]){
common_compile_and_run_args
}));
}
run_command(arena, args, envp);
}
typedef enum Command : u8
{
COMMAND_DEBUG,
COMMAND_RUN_TESTS,
COMMAND_COMPILE,
COMMAND_COUNT,
} Command;
STRUCT(TestOptions)
{
Slice(Linkage) linkages;
Slice(OptimizationMode) optimization_modes;
Slice(String) test_paths;
Slice(CompilerBackend) compiler_backends;
};
fn String linkage_name(Linkage linkage)
{
switch (linkage)
{
case LINKAGE_STATIC:
return strlit("static");
case LINKAGE_DYNAMIC:
return strlit("dynamic");
case LINKAGE_COUNT:
unreachable();
}
}
fn String optimization_name(OptimizationMode optimization_mode)
{
switch (optimization_mode)
{
case O0:
return strlit("O0");
case O1:
return strlit("O1");
case O2:
return strlit("O2");
case O3:
return strlit("O3");
case Os:
return strlit("Os");
case Oz:
return strlit("Oz");
case OPTIMIZATION_COUNT:
unreachable();
}
}
global const auto compiler_source_path = "bootstrap/main.c";
fn void run_tests(Arena* arena, TestOptions const * const test_options, char** envp)
{
CompileOptions compile_options = {};
compile_options.compiler = default_compiler;
compile_options.debug_info = 1;
compile_options.in_path = compiler_source_path;
for (u32 linkage_i = 0; linkage_i < test_options->linkages.length; linkage_i += 1)
{
compile_options.linkage = test_options->linkages.pointer[linkage_i];
auto linkage_string = linkage_name(compile_options.linkage);
for (u32 optimization_i = 0; optimization_i < test_options->optimization_modes.length; optimization_i += 1)
{
compile_options.optimization_mode = test_options->optimization_modes.pointer[optimization_i];
auto optimization_string = optimization_name(compile_options.optimization_mode);
print("\n===========================\n");
print("TESTS (linkage={s}, optimization={s})\n", linkage_string, optimization_string);
print("===========================\n\n");
String compiler_path_split[] = {
strlit("./" build_dir "/" "nest"),
strlit("_"),
optimization_string,
strlit("_"),
linkage_string,
#if _WIN32
strlit(".exe"),
#endif
};
String compiler_path = arena_join_string(arena, ((Slice(String)) array_to_slice(compiler_path_split)));
compile_options.out_path = string_to_c(compiler_path);
compile_c(arena, compile_options, envp);
print("\n===========================\n");
print("COMPILER BUILD [OK]\n");
print("===========================\n\n");
for (u32 test_i = 0; test_i < test_options->test_paths.length; test_i += 1)
{
String test_path = test_options->test_paths.pointer[test_i];
char* test_path_c = string_to_c(test_path);
auto test_dir = string_no_extension(test_path);
auto test_name = string_base(test_dir);
for (u32 engine_i = 0; engine_i < test_options->compiler_backends.length; engine_i += 1)
{
CompilerBackend compiler_backend = test_options->compiler_backends.pointer[engine_i];
char* compiler_backend_string;
switch (compiler_backend)
{
case COMPILER_BACKEND_C:
compiler_backend_string = "c";
break;
case COMPILER_BACKEND_INTERPRETER:
compiler_backend_string = "i";
break;
case COMPILER_BACKEND_MACHINE:
compiler_backend_string = "m";
break;
case COMPILER_BACKEND_COUNT:
unreachable();
}
char* arguments[] = {
compile_options.out_path,
test_path_c,
compiler_backend_string,
0,
};
run_command(arena, (CStringSlice) array_to_slice(arguments), envp);
if (compiler_backend != COMPILER_BACKEND_INTERPRETER)
{
String path_split[] = {
strlit("./" nest_dir "/"),
test_name,
#if _WIN32
strlit(".exe"),
#endif
};
String out_program = arena_join_string(arena, ((Slice(String)) array_to_slice(path_split)));
char* run_arguments[] = {
string_to_c(out_program),
0,
};
run_command(arena, (CStringSlice) array_to_slice(run_arguments), envp);
}
}
}
}
}
}
fn void entry_point(int argc, char* argv[], char* envp[])
{
if (argc < 2)
{
print("Expected some arguments\n");
fail();
}
Arena* arena = arena_init_default(KB(64));
CompilerBackend preferred_compiler_backend = COMPILER_BACKEND_COUNT;
Command command = COMMAND_COUNT;
u8 test_every_config = 0;
String source_file_path = {};
for (int i = 1; i < argc; i += 1)
{
char* c_argument = argv[i];
auto argument = cstr(c_argument);
if (s_equal(argument, strlit("i")))
{
preferred_compiler_backend = COMPILER_BACKEND_INTERPRETER;
}
else if (s_equal(argument, strlit("c")))
{
preferred_compiler_backend = COMPILER_BACKEND_C;
}
else if (s_equal(argument, strlit("m")))
{
preferred_compiler_backend = COMPILER_BACKEND_MACHINE;
}
else if (s_equal(argument, strlit("test")))
{
command = COMMAND_RUN_TESTS;
}
else if (s_equal(argument, strlit("debug")))
{
command = COMMAND_DEBUG;
}
else if (s_equal(argument, strlit("compile")))
{
command = COMMAND_COMPILE;
}
else if (s_equal(argument, strlit("all")))
{
test_every_config = 1;
}
}
auto index = 2 - (command == COMMAND_COUNT);
if (argc > index)
{
auto* c_argument = argv[index];
auto argument = cstr(c_argument);
String expected_starts[] = {
strlit("tests/"),
strlit("tests\\"),
strlit("./tests/"),
strlit(".\\tests\\"),
strlit("src/"),
strlit("src\\"),
strlit("./src/"),
strlit(".\\src\\"),
};
for (u32 i = 0; i < array_length(expected_starts); i += 1)
{
auto expected_start = expected_starts[i];
if (expected_start.length < argument.length)
{
// TODO: make our own function
if (strncmp(c_argument, string_to_c(expected_start), expected_start.length) == 0)
{
source_file_path = argument;
break;
}
}
}
}
if (command == COMMAND_COUNT && !source_file_path.pointer)
{
print("Expected a command\n");
fail();
}
if (command == COMMAND_COUNT)
{
command = COMMAND_COMPILE;
}
if ((command == COMMAND_DEBUG) | ((command == COMMAND_RUN_TESTS) & (test_every_config == 0)))
{
if (preferred_compiler_backend == COMPILER_BACKEND_COUNT)
{
preferred_compiler_backend = COMPILER_BACKEND_MACHINE;
}
}
switch (command)
{
case COMMAND_DEBUG:
if (!source_file_path.pointer)
{
fail();
}
// Test always with dynamic linkage because it's more trustworthy
Linkage linkage = LINKAGE_DYNAMIC;
compile_and_run(arena, (CompileOptions) {
.in_path = compiler_source_path,
.out_path = linkage == LINKAGE_DYNAMIC ? (
build_dir "/" "nest_O0_dynamic"
#if _WIN32
".exe"
#endif
) : (
build_dir "/" "nest_O0_static"
#if _WIN32
".exe"
#endif
),
.compiler = default_compiler,
.debug_info = 1,
.error_on_warning = 0,
.optimization_mode = O0,
.linkage = linkage,
}, envp, preferred_compiler_backend, 1, string_to_c(source_file_path));
break;
case COMMAND_RUN_TESTS:
{
Linkage all_linkages[] = {
LINKAGE_DYNAMIC,
#ifdef __linux__
LINKAGE_STATIC
#endif
};
OptimizationMode all_optimization_modes[] = {
O0,
O1,
O2,
O3,
Os,
Oz
};
// static_assert(array_length(all_optimization_modes) == OPTIMIZATION_COUNT);
String every_single_test[] = {
strlit("tests/first.nat"),
// strlit("tests/add_sub.nat"),
// strlit("tests/mul.nat"),
// strlit("tests/div.nat"),
// strlit("tests/and.nat"),
// strlit("tests/or.nat"),
// strlit("tests/xor.nat"),
// strlit("tests/return_var.nat"),
// strlit("tests/return_mod_scope.nat"),
// strlit("tests/shift_left.nat"),
// strlit("tests/shift_right.nat"),
// strlit("tests/thousand_simple_functions.nat"),
// strlit("tests/simple_arg.nat"),
// strlit("tests/comparison.nat"),
};
CompilerBackend all_compiler_backends[] = {
// COMPILER_BACKEND_INTERPRETER,
// COMPILER_BACKEND_C,
COMPILER_BACKEND_MACHINE,
};
Slice(Linkage) linkage_selection;
Slice(OptimizationMode) optimization_selection;
Slice(CompilerBackend) compiler_backend_selection;
if (test_every_config)
{
#ifdef __linux__
linkage_selection = (Slice(Linkage)) array_to_slice(all_linkages);
#else
linkage_selection = (Slice(Linkage)) { .pointer = &all_linkages[0], .length = 1 };
#endif
optimization_selection = (Slice(OptimizationMode)) array_to_slice(all_optimization_modes);
compiler_backend_selection = (Slice(CompilerBackend)) array_to_slice(all_compiler_backends);
}
else
{
linkage_selection = (Slice(Linkage)) { .pointer = &all_linkages[0], .length = 1 };
optimization_selection = (Slice(OptimizationMode)) { .pointer = &all_optimization_modes[0], .length = 1 };
compiler_backend_selection = (Slice(CompilerBackend)) { .pointer = &preferred_compiler_backend, .length = 1 };
}
Slice(String) test_selection;
if (source_file_path.pointer)
{
test_selection = (Slice(String)) { .pointer = &source_file_path, .length = 1 };
}
else
{
test_selection = (Slice(String)) array_to_slice(every_single_test);
}
run_tests(arena, &(TestOptions) {
.linkages = linkage_selection,
.optimization_modes = optimization_selection,
.test_paths = test_selection,
.compiler_backends = compiler_backend_selection,
}, envp);
} break;
case COMMAND_COMPILE:
compile_c(arena, (CompileOptions) {
.in_path = compiler_source_path,
.out_path = build_dir "/" "nest_O0_static",
.compiler = default_compiler,
.debug_info = 1,
.error_on_warning = 0,
.optimization_mode = O0,
// #if defined(__linux__)
// .linkage = LINKAGE_STATIC,
// #else
.linkage = LINKAGE_DYNAMIC,
// #endif
}, envp);
break;
case COMMAND_COUNT:
unreachable();
}
}

236
bootstrap/include/std/base.h Normal file
View File

@ -0,0 +1,236 @@
#pragma once
#ifdef NDEBUG
#define _DEBUG 0
#else
#define _DEBUG 1
#endif
#ifdef STATIC
#define LINK_LIBC 0
#else
#define LINK_LIBC 1
#endif
#include <stdint.h>
#include <stdarg.h>
#include <stddef.h>
#if defined(__x86_64__)
#include <immintrin.h>
#endif
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef __uint128_t u128;
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef __int128_t s128;
typedef size_t usize;
typedef float f32;
typedef double f64;
typedef u32 Hash32;
typedef u64 Hash64;
#define STRUCT_FORWARD_DECL(S) typedef struct S S
#define STRUCT(S) STRUCT_FORWARD_DECL(S); struct S
#define UNION_FORWARD_DECL(U) typedef union U U
#define UNION(U) UNION_FORWARD_DECL(U); union U
#define Slice(T) Slice_ ## T
#define SliceP(T) SliceP_ ## T
#define declare_slice_ex(T, StructName) STRUCT(StructName) \
{\
T* pointer;\
u64 length;\
}
#define declare_slice(T) declare_slice_ex(T, Slice(T))
#define declare_slice_p(T) declare_slice_ex(T*, SliceP(T))
declare_slice(u8);
declare_slice(u16);
declare_slice(u32);
declare_slice(u64);
declare_slice(s8);
declare_slice(s16);
declare_slice(s32);
declare_slice(s64);
declare_slice_p(char);
typedef Slice(u8) String;
declare_slice(String);
typedef SliceP(char) CStringSlice;
#ifdef _WIN32
typedef void* FileDescriptor;
#else
typedef int FileDescriptor;
#endif
#define FOR_N(it, start, end) \
for (u32 it = (start), end__ = (end); it < end__; ++it)
#define FOR_REV_N(it, start, end) \
for (u32 it = (end), start__ = (start); (it--) > start__;)
#define FOR_BIT(it, start, bits) \
for (typeof(bits) _bits_ = (bits), it = (start); _bits_; _bits_ >>= 1, ++it) if (_bits_ & 1)
#define FOREACH_SET(it, set) \
FOR_N(_i, 0, ((set)->arr.capacity + 63) / 64) FOR_BIT(it, _i*64, (set)->arr.pointer[_i])
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define INFINITY __builtin_inff()
#define NAN __builtin_nanf("")
#define fn static
#define method __attribute__((visibility("internal")))
#define global static
#define forceinline __attribute__((always_inline))
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#define breakpoint() __builtin_debugtrap()
#define fail() trap()
#define trap() bad_exit("Trap reached", __FILE__, __LINE__)
#define array_length(arr) sizeof(arr) / sizeof((arr)[0])
#define KB(n) ((n) * 1024)
#define MB(n) ((n) * 1024 * 1024)
#define GB(n) ((u64)(n) * 1024 * 1024 * 1024)
#define TB(n) ((u64)(n) * 1024 * 1024 * 1024 * 1024)
#define unused(x) (void)(x)
#define may_be_unused __attribute__((unused))
#define trunc(Destination, source) (Destination)(source)
#define cast(Destination, Source, source) cast_ ## Source ## _to_ ## Destination (source, __FILE__, __LINE__)
#define bad_exit(message, file, line) do { print(message " at {cstr}:{u32}\n", file, line); __builtin_trap(); } while(0)
#define size_until_end(T, field_name) (sizeof(T) - offsetof(T, field_name))
#define SWAP(a, b) \
do {\
auto temp = a;\
a = b;\
b = temp;\
} while (0)
#define slice_from_pointer_range(T, start, end) (Slice(T)) { .pointer = start, .length = (u64)(end - start), }
#define strlit_len(s) (sizeof(s) - 1)
#define strlit(s) (String){ .pointer = (u8*)(s), .length = strlit_len(s), }
#define ch_to_str(ch) (String){ .pointer = &ch, .length = 1 }
#define array_to_slice(arr) { .pointer = (arr), .length = array_length(arr) }
#define array_to_bytes(arr) { .pointer = (u8*)(arr), .length = sizeof(arr) }
#define pointer_to_bytes(p) (String) { .pointer = (u8*)(p), .length = sizeof(*p) }
#define scalar_to_bytes(s) pointer_to_bytes(&(s))
#define string_to_c(s) ((char*)((s).pointer))
#define cstr(s) ((String) { .pointer = (u8*)(s), .length = strlen((char*)s), } )
#define case_to_name(prefix, e) case prefix ## e: return strlit(#e)
const may_be_unused global u8 brace_open = '{';
const may_be_unused global u8 brace_close = '}';
const may_be_unused global u8 parenthesis_open = '(';
const may_be_unused global u8 parenthesis_close = ')';
const may_be_unused global u8 bracket_open = '[';
const may_be_unused global u8 bracket_close = ']';
#define s_get(s, i) (s).pointer[i]
#define s_get_pointer(s, i) &((s).pointer[i])
#define s_get_slice(T, s, start, end) (Slice(T)){ .pointer = ((s).pointer) + (start), .length = (end) - (start) }
#define s_equal(a, b) ((a).length == (b).length && memcmp((a).pointer, (b).pointer, sizeof(*((a).pointer)) * (a).length) == 0)
#if _DEBUG
#define assert(x) if (unlikely(!(x))) { bad_exit("Assert failed: \"" # x "\"", __FILE__, __LINE__); }
#else
#define assert(x) unlikely(!(x))
#endif
#ifdef unreachable
#undef unreachable
#endif
#if _DEBUG
#define unreachable() bad_exit("Unreachable triggered", __FILE__, __LINE__)
#else
#define unreachable() __builtin_unreachable()
#endif
#ifdef static_assert
#undef static_assert
#endif
#define static_assert(x) _Static_assert((x), "Static assert failed!")
#define alignof(x) _Alignof(x)
#define auto __auto_type
#define todo() do { print("TODO at {cstr}:{u32}\n", __FILE__, __LINE__); __builtin_trap(); } while(0)
u64 align_forward(u64 value, u64 alignment);
u64 align_backward(u64 value, u64 alignment);
u8 log2_alignment(u64 alignment);
u8 is_power_of_two(u64 value);
u8 first_bit_set_32(u32 value);
u64 first_bit_set_64(u64 value);
void* memcpy(void* const restrict dst, const void* const restrict src, usize size);
void* memmove(void* const dst, const void* const src, usize n);
void* memset(void* dst, int n, usize size);
int memcmp(const void* a, const void* b, usize n);
usize strlen (const char* c_string);
int strcmp(const char* s1, const char* s2);
int strncmp(const char* s1, const char* s2, usize length);
u8 cast_u32_to_u8(u32 source, const char* name, int line);
u16 cast_u32_to_u16(u32 source, const char* name, int line);
s16 cast_u32_to_s16(u32 source, const char* name, int line);
s32 cast_u32_to_s32(u32 source, const char* name, int line);
u8 cast_u64_to_u8(u64 source, const char* name, int line);
u16 cast_u64_to_u16(u64 source, const char* name, int line);
u32 cast_u64_to_u32(u64 source, const char* name, int line);
s32 cast_u64_to_s32(u64 source, const char* name, int line);
s64 cast_u64_to_s64(u64 source, const char* name, int line);
u8 cast_s32_to_u8(s32 source, const char* name, int line);
u16 cast_s32_to_u16(s32 source, const char* name, int line);
u32 cast_s32_to_u32(s32 source, const char* name, int line);
u64 cast_s32_to_u64(s32 source, const char* name, int line);
s16 cast_s32_to_s16(s32 source, const char* name, int line);
u16 cast_s64_to_u16(s64 source, const char* name, int line);
u32 cast_s64_to_u32(s64 source, const char* name, int line);
u64 cast_s64_to_u64(s64 source, const char* name, int line);
s32 cast_s64_to_s32(s64 source, const char* name, int line);
u32 format_decimal(String buffer, u64 decimal);
u32 format_hexadecimal(String buffer, u64 hexadecimal);
u64 format_float(String buffer, f64 value_double);
u64 is_decimal_digit(u8 ch);
u32 is_space(u8 ch, u8 next_ch);
u8 get_next_ch_safe(String string, u64 index);
u64 is_identifier_start(u8 ch);
u64 is_identifier_ch(u8 ch);
u64 is_alphabetic(u8 ch);
u64 parse_decimal(String string);
global const Hash64 fnv_offset = 14695981039346656037ull;
global const u64 fnv_prime = 1099511628211ull;
Hash32 hash32_fib_end(Hash32 hash);
Hash32 hash64_fib_end(Hash64 hash);
Hash64 hash_byte(Hash64 source, u8 ch);
Hash64 hash_bytes(String bytes);
Hash32 hash64_to_hash32(Hash64 hash64);
u64 round_up_to_next_power_of_2(u64 n);

11
bootstrap/include/std/entry_point.h Normal file
View File

@ -0,0 +1,11 @@
#include <std/base.h>
void entry_point(int argc, char* argv[], char* envp[]);
#if LINK_LIBC == 0
[[gnu::naked]] [[noreturn]] void _start();
#endif
#if LINK_LIBC == 0
void static_entry_point(int argc, char* argv[]);
#endif

8
bootstrap/include/std/md5.h Normal file
View File

@ -0,0 +1,8 @@
#include <std/base.h>
STRUCT(MD5Result)
{
u8 hash[16];
};
MD5Result md5_string(String string);

83
bootstrap/include/std/os.h Normal file
View File

@ -0,0 +1,83 @@
#include <std/base.h>
STRUCT(OSFileOpenFlags)
{
u32 truncate:1;
u32 executable:1;
u32 write:1;
u32 read:1;
u32 create:1;
};
STRUCT(OSFilePermissions)
{
u8 readable:1;
u8 writable:1;
u8 executable:1;
};
STRUCT(OSReserveProtectionFlags)
{
u32 read:1;
u32 write:1;
u32 execute:1;
u32 reserved:29;
};
STRUCT(OSReserveMapFlags)
{
u32 priv:1;
u32 anon:1;
u32 noreserve:1;
u32 reserved:29;
};
STRUCT(Arena)
{
u64 reserved_size;
u64 committed;
u64 commit_position;
u64 granularity;
u8 reserved[4 * 8];
};
#if __APPLE__
const global u64 page_size = KB(16);
#else
const global u64 page_size = KB(4);
#endif
global u64 minimum_granularity = page_size;
// global u64 middle_granularity = MB(2);
global u64 default_size = GB(4);
void print(const char* format, ...);
void run_command(Arena* arena, CStringSlice arguments, char* envp[]);
String file_read(Arena* arena, String path);
String path_dir(String string);
String path_base(String string);
String path_no_extension(String string);
Arena* arena_init(u64 reserved_size, u64 granularity, u64 initial_size);
Arena* arena_init_default(u64 initial_size);
String arena_join_string(Arena* arena, Slice(String) pieces);
u8* arena_allocate_bytes(Arena* arena, u64 size, u64 alignment);
void arena_reset(Arena* arena);
#define arena_allocate(arena, T, count) (T*)(arena_allocate_bytes(arena, sizeof(T) * count, alignof(T)))
#define arena_allocate_slice(arena, T, count) (Slice(T)){ .pointer = arena_allocate(arena, T, count), .length = count }
u8* os_reserve(u64 base, u64 size, OSReserveProtectionFlags protection, OSReserveMapFlags map);
void os_commit(void* address, u64 size);
u8 os_file_descriptor_is_valid(FileDescriptor fd);
FileDescriptor os_file_open(String path, OSFileOpenFlags flags, OSFilePermissions permissions);
void os_file_close(FileDescriptor fd);
u64 os_file_get_size(FileDescriptor fd);
void os_file_write(FileDescriptor fd, String content);
FileDescriptor os_stdout_get();
void os_directory_make(String path);
void calibrate_cpu_timer();

0
bootstrap/include/std/sha1.h Normal file
View File

5
bootstrap/include/std/string.h Normal file
View File

@ -0,0 +1,5 @@
#include <std/base.h>
s32 string_first_ch(String string, u8 ch);
s64 string_last_ch(String string, u8 ch);
u8 string_starts_with(String string, String start);

48
bootstrap/include/std/virtual_buffer.h Normal file
View File

@ -0,0 +1,48 @@
#include <std/base.h>
#define VirtualBuffer(T) VirtualBuffer_ ## T
#define VirtualBufferP(T) VirtualBufferPointerTo_ ## T
#define decl_vb_ex(T, StructName) \
struct StructName \
{\
T* pointer;\
u32 length;\
u32 capacity;\
};\
typedef struct StructName StructName
#define decl_vb(T) decl_vb_ex(T, VirtualBuffer(T))
#define decl_vbp(T) decl_vb_ex(T*, VirtualBufferP(T))
decl_vb(u8);
decl_vbp(u8);
decl_vb(u16);
decl_vbp(u16);
decl_vb(u32);
decl_vbp(u32);
decl_vb(s32);
decl_vbp(s32);
decl_vb(s64);
decl_vbp(s64);
decl_vb(String);
#define vb_size_of_element(vb) sizeof(*((vb)->pointer))
#define vb_add(vb, count) (typeof((vb)->pointer)) vb_generic_add((VirtualBuffer(u8)*)(vb), (vb_size_of_element(vb)), (count))
#define vb_add_scalar(vb, S) (S*) vb_generic_add(vb, 1, sizeof(S))
#define vb_copy_scalar(vb, s) *vb_add_scalar(vb, typeof(s)) = s
#define vb_append_struct(vb, T, s) *(vb_add_struct(vb, T)) = s
#define vb_append_one(vb, item) (typeof((vb)->pointer)) vb_generic_append((VirtualBuffer(u8)*)(vb), &(item), (vb_size_of_element(vb)), 1)
#define vb_to_bytes(vb) (Slice(u8)) { .pointer = (u8*)((vb).pointer), .length = (vb_size_of_element(vb)) * (vb).length, }
#define vb_ensure_capacity(vb, count) vb_generic_ensure_capacity((VirtualBuffer(u8)*)(vb), vb_size_of_element(vb), (count))
#define vb_copy_array(vb, arr) memcpy(vb_add(vb, array_length(arr)), arr, sizeof(arr))
#define vb_add_any_array(vb, E, count) (E*)vb_generic_add(vb, vb_size_of_element(vb), sizeof(E) * count)
#define vb_copy_any_array(vb, arr) memcpy(vb_generic_add(vb, vb_size_of_element(vb), sizeof(arr)), (arr), sizeof(arr))
#define vb_copy_any_slice(vb, slice) memcpy(vb_generic_add(vb, vb_size_of_element(vb), sizeof(*((slice).pointer)) * (slice).length), (slice).pointer, sizeof(*((slice).pointer)) * (slice).length)
void vb_generic_ensure_capacity(VirtualBuffer(u8)* vb, u32 item_size, u32 item_count);
u8* vb_generic_add_assume_capacity(VirtualBuffer(u8)* vb, u32 item_size, u32 item_count);
u8* vb_generic_add(VirtualBuffer(u8)* vb, u32 item_size, u32 item_count);
u8* vb_append_bytes(VirtualBuffer(u8*) vb, Slice(u8) bytes);
void vb_copy_string(VirtualBuffer(u8)* buffer, String string);
u64 vb_copy_string_zero_terminated(VirtualBuffer(u8)* buffer, String string);

3926
bootstrap/lib.h
View File

File diff suppressed because it is too large Load Diff

355
bootstrap/runner/runner.c Normal file
View File

@ -0,0 +1,355 @@
#include <std/base.h>
#include <std/os.h>
#include <std/entry_point.h>
#include <std/virtual_buffer.h>
#include <std/string.h>
#define nest_dir "nest"
typedef enum CompilerBackend
{
COMPILER_BACKEND_INTERPRETER,
COMPILER_BACKEND_C,
COMPILER_BACKEND_MACHINE,
COMPILER_BACKEND_COUNT,
} CompilerBackend;
declare_slice(CompilerBackend);
typedef enum CMakeBuildType
{
CMAKE_BUILD_TYPE_DEBUG,
CMAKE_BUILD_TYPE_MIN_SIZE_RELEASE,
CMAKE_BUILD_TYPE_RELEASE_WITH_DEBUG_INFO,
CMAKE_BUILD_TYPE_RELEASE,
CMAKE_BUILD_TYPE_COUNT,
} CMakeBuildType;
fn void run(Arena* arena, char** envp, String compiler_path, CompilerBackend compiler_backend, u8 debug, char* nest_source_path)
{
CStringSlice args = {};
char* compiler_backend_string;
switch (compiler_backend)
{
case COMPILER_BACKEND_C:
compiler_backend_string = "c";
break;
case COMPILER_BACKEND_INTERPRETER:
compiler_backend_string = "i";
break;
case COMPILER_BACKEND_MACHINE:
compiler_backend_string = "m";
break;
case COMPILER_BACKEND_COUNT:
unreachable();
}
#define common_compile_and_run_args \
string_to_c(compiler_path), \
nest_source_path, \
compiler_backend_string, \
0,
if (debug)
{
#if _WIN32
args = (CStringSlice) array_to_slice(((char*[]){
"C:\\Users\\David\\Downloads\\remedybg_0_4_0_7\\remedybg.exe",
"-g",
common_compile_and_run_args
}));
#elif defined(__linux__)
args = (CStringSlice) array_to_slice(((char*[]){
"/home/david/source/gf/gf2",
"-ex",
"set auto-solib-add off",
"-ex",
"r",
"--args",
common_compile_and_run_args
}));
#elif defined(__APPLE__)
args = (CStringSlice) array_to_slice(((char*[]){
"/usr/bin/lldb",
"-o",
"run",
"--",
common_compile_and_run_args
}));
#endif
}
else
{
args = (CStringSlice) array_to_slice(((char*[]){
common_compile_and_run_args
}));
}
run_command(arena, args, envp);
}
typedef enum Command : u8
{
COMMAND_DEBUG,
COMMAND_RUN_TESTS,
COMMAND_COUNT,
} Command;
STRUCT(TestOptions)
{
Slice(String) test_paths;
Slice(CompilerBackend) compiler_backends;
};
fn void run_tests(Arena* arena, String compiler_path, TestOptions const * const test_options, char** envp)
{
print("\n===========================\n");
print("COMPILER BUILD [OK]\n");
print("===========================\n\n");
for (u32 test_i = 0; test_i < test_options->test_paths.length; test_i += 1)
{
String test_path = test_options->test_paths.pointer[test_i];
char* test_path_c = string_to_c(test_path);
auto test_dir = path_no_extension(test_path);
auto test_name = path_base(test_dir);
for (u32 engine_i = 0; engine_i < test_options->compiler_backends.length; engine_i += 1)
{
CompilerBackend compiler_backend = test_options->compiler_backends.pointer[engine_i];
char* compiler_backend_string;
switch (compiler_backend)
{
case COMPILER_BACKEND_C:
compiler_backend_string = "c";
break;
case COMPILER_BACKEND_INTERPRETER:
compiler_backend_string = "i";
break;
case COMPILER_BACKEND_MACHINE:
compiler_backend_string = "m";
break;
case COMPILER_BACKEND_COUNT:
unreachable();
}
char* arguments[] = {
string_to_c(compiler_path),
test_path_c,
compiler_backend_string,
0,
};
run_command(arena, (CStringSlice) array_to_slice(arguments), envp);
if (compiler_backend != COMPILER_BACKEND_INTERPRETER)
{
String path_split[] = {
strlit("./" nest_dir "/"),
test_name,
#if _WIN32
strlit(".exe"),
#endif
};
String out_program = arena_join_string(arena, ((Slice(String)) array_to_slice(path_split)));
char* run_arguments[] = {
string_to_c(out_program),
0,
};
run_command(arena, (CStringSlice) array_to_slice(run_arguments), envp);
}
}
}
}
void entry_point(int argc, char* argv[], char* envp[])
{
if (argc < 2)
{
print("Expected some arguments\n");
fail();
}
Arena* arena = arena_init_default(KB(64));
CompilerBackend preferred_compiler_backend = COMPILER_BACKEND_COUNT;
Command command = COMMAND_COUNT;
u8 test_every_config = 0;
String source_file_path = {};
CMakeBuildType build_type = CMAKE_BUILD_TYPE_COUNT;
String release_strings[CMAKE_BUILD_TYPE_COUNT] = {
[CMAKE_BUILD_TYPE_DEBUG] = strlit("Debug"),
[CMAKE_BUILD_TYPE_MIN_SIZE_RELEASE] = strlit("MinSizeRel"),
[CMAKE_BUILD_TYPE_RELEASE_WITH_DEBUG_INFO] = strlit("RelWithDebInfo"),
[CMAKE_BUILD_TYPE_RELEASE] = strlit("Release"),
};
for (int i = 1; i < argc; i += 1)
{
char* c_argument = argv[i];
auto argument = cstr(c_argument);
if (string_starts_with(argument, strlit("build_type=")))
{
auto release_start = cast(u32, s32, string_first_ch(argument, '=') + 1);
auto release_string = s_get_slice(u8, argument, release_start, argument.length);
for (u64 i = 0; i < array_length(release_strings); i += 1)
{
if (s_equal(release_string, release_strings[i]))
{
build_type = (CMakeBuildType)i;
break;
}
}
assert(build_type != CMAKE_BUILD_TYPE_COUNT);
}
else if (s_equal(argument, strlit("i")))
{
preferred_compiler_backend = COMPILER_BACKEND_INTERPRETER;
}
else if (s_equal(argument, strlit("c")))
{
preferred_compiler_backend = COMPILER_BACKEND_C;
}
else if (s_equal(argument, strlit("m")))
{
preferred_compiler_backend = COMPILER_BACKEND_MACHINE;
}
else if (s_equal(argument, strlit("test")))
{
command = COMMAND_RUN_TESTS;
}
else if (s_equal(argument, strlit("debug")))
{
command = COMMAND_DEBUG;
}
else if (s_equal(argument, strlit("all")))
{
test_every_config = 1;
}
}
auto index = 2 - (command == COMMAND_COUNT);
if (argc > index)
{
auto* c_argument = argv[index];
auto argument = cstr(c_argument);
String expected_starts[] = {
strlit("tests/"),
strlit("tests\\"),
strlit("./tests/"),
strlit(".\\tests\\"),
strlit("src/"),
strlit("src\\"),
strlit("./src/"),
strlit(".\\src\\"),
};
for (u32 i = 0; i < array_length(expected_starts); i += 1)
{
auto expected_start = expected_starts[i];
if (expected_start.length < argument.length)
{
// TODO: make our own function
if (strncmp(c_argument, string_to_c(expected_start), expected_start.length) == 0)
{
source_file_path = argument;
break;
}
}
}
}
if (command == COMMAND_COUNT && !source_file_path.pointer)
{
print("Expected a command\n");
fail();
}
if (command == COMMAND_COUNT)
{
command = COMMAND_RUN_TESTS;
test_every_config = 1;
}
if ((command == COMMAND_DEBUG) | ((command == COMMAND_RUN_TESTS) & (test_every_config == 0)))
{
if (preferred_compiler_backend == COMPILER_BACKEND_COUNT)
{
preferred_compiler_backend = COMPILER_BACKEND_MACHINE;
}
}
if (build_type == CMAKE_BUILD_TYPE_COUNT)
{
build_type = CMAKE_BUILD_TYPE_DEBUG;
}
auto build_type_string = release_strings[build_type];
String compiler_path = strlit("build/nest");
switch (command)
{
case COMMAND_DEBUG:
if (!source_file_path.pointer)
{
fail();
}
run(arena, envp, compiler_path, preferred_compiler_backend, 1, string_to_c(source_file_path));
break;
case COMMAND_RUN_TESTS:
{
String every_single_test[] = {
strlit("tests/first.nat"),
// strlit("tests/add_sub.nat"),
// strlit("tests/mul.nat"),
// strlit("tests/div.nat"),
// strlit("tests/and.nat"),
// strlit("tests/or.nat"),
// strlit("tests/xor.nat"),
// strlit("tests/return_var.nat"),
// strlit("tests/return_mod_scope.nat"),
// strlit("tests/shift_left.nat"),
// strlit("tests/shift_right.nat"),
// strlit("tests/thousand_simple_functions.nat"),
// strlit("tests/simple_arg.nat"),
// strlit("tests/comparison.nat"),
};
CompilerBackend all_compiler_backends[] = {
// COMPILER_BACKEND_INTERPRETER,
// COMPILER_BACKEND_C,
COMPILER_BACKEND_MACHINE,
};
Slice(CompilerBackend) compiler_backend_selection;
if (test_every_config)
{
compiler_backend_selection = (Slice(CompilerBackend)) array_to_slice(all_compiler_backends);
}
else
{
compiler_backend_selection = (Slice(CompilerBackend)) { .pointer = &preferred_compiler_backend, .length = 1 };
}
Slice(String) test_selection;
if (source_file_path.pointer)
{
test_selection = (Slice(String)) { .pointer = &source_file_path, .length = 1 };
}
else
{
test_selection = (Slice(String)) array_to_slice(every_single_test);
}
run_tests(arena, compiler_path, &(TestOptions) {
.test_paths = test_selection,
.compiler_backends = compiler_backend_selection,
}, envp);
} break;
case COMMAND_COUNT:
unreachable();
}
}

64
bootstrap/main.c → bootstrap/src/main.c
View File

@ -1,4 +1,10 @@
#include "lib.h"
#include <std/base.h>
#include <std/os.h>
#include <std/entry_point.h>
#include <std/virtual_buffer.h>
#include <std/md5.h>
#include <std/string.h>
#ifdef __APPLE__
#define clang_path "/opt/homebrew/opt/llvm/bin/clang"
#else
@ -32,7 +38,7 @@ fn void print_string(String message)
{
#ifndef SILENT
// TODO: check writes
os_file_write(stdout_get(), message);
os_file_write(os_stdout_get(), message);
// assert(result >= 0);
// assert((u64)result == message.length);
#else
@ -9798,9 +9804,7 @@ may_be_unused fn String write_elf(Thread* thread, ObjectOptions options)
};
// MD5Result md5_hash = { { 0x05, 0xAB, 0x89, 0xF5, 0x48, 0x1B, 0xC9, 0xF2, 0xD0, 0x37, 0xE7, 0x88, 0x66, 0x41, 0xE9, 0x19 } };
String dummy_file = file_read(thread->arena, strlit("/home/david/dev/nest/tests/first.nat"));
auto md5 = md5_init();
md5_update(&md5, dummy_file);
auto md5_hash = md5_end(&md5);
auto md5_hash = md5_string(dummy_file);
auto filename_string_offset = debug_line_str.length;
{
@ -11535,7 +11539,7 @@ fn void pdb_print_sizes(PDBFile pdb, PDBDBIStream dbi)
}
}
u8 pdb_image[] = {
global u8 pdb_image[] = {
0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66, 0x74, 0x20, 0x43, 0x2F, 0x43, 0x2B, 0x2B, 0x20,
0x4D, 0x53, 0x46, 0x20, 0x37, 0x2E, 0x30, 0x30, 0x0D, 0x0A, 0x1A, 0x44, 0x53, 0x00, 0x00, 0x00,
0x00, 0x10, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0xB8, 0x00, 0x00, 0x00,
@ -29783,7 +29787,7 @@ may_be_unused fn String write_pe(Thread* thread, ObjectOptions options)
auto pdb = pdb_build(thread);
// TODO:
// #if _WIN32
#if _WIN32
auto fd = os_file_open(strlit("mydbg.pdb"), (OSFileOpenFlags) {
.write = 1,
.truncate = 1,
@ -29796,7 +29800,7 @@ may_be_unused fn String write_pe(Thread* thread, ObjectOptions options)
os_file_write(fd, pdb);
os_file_close(fd);
// #endif
#endif
// Check if file matches
#define CHECK_PE_MATCH 0
@ -33385,25 +33389,25 @@ fn void code_generation(Thread* restrict thread, CodegenOptions options)
.writable = 1,
.executable = 1,
});
#if _WIN32
if (!os_file_descriptor_is_valid(fd))
{
auto err = GetLastError();
LPSTR lpMsgBuf;
DWORD bufSize = FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
err,
LANG_NEUTRAL, // Use default language
(LPSTR)&lpMsgBuf,
0,
NULL
);
unused(bufSize);
print("Error opening file \"{s}\": {cstr}\n", object_options.exe_path, lpMsgBuf);
fail();
}
#endif
// #if _WIN32
// if (!os_file_descriptor_is_valid(fd))
// {
// auto err = GetLastError();
// LPSTR lpMsgBuf;
// DWORD bufSize = FormatMessageA(
// FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
// NULL,
// err,
// LANG_NEUTRAL, // Use default language
// (LPSTR)&lpMsgBuf,
// 0,
// NULL
// );
// unused(bufSize);
// print("Error opening file \"{s}\": {cstr}\n", object_options.exe_path, lpMsgBuf);
// fail();
// }
// #endif
assert(os_file_descriptor_is_valid(fd));
os_file_write(fd, (String) { executable.pointer, executable.length });
@ -33793,7 +33797,7 @@ fn void print_ir(Thread* restrict thread)
}
}
fn void entry_point(int argc, char* argv[], char* envp[])
void entry_point(int argc, char* argv[], char* envp[])
{
unused(envp);
#if DO_UNIT_TESTS
@ -33860,9 +33864,9 @@ fn void entry_point(int argc, char* argv[], char* envp[])
}
print("File path: {s}\n", source_file_path);
auto test_dir = string_no_extension(file.path);
auto test_dir = path_no_extension(file.path);
print("Test dir path: {s}\n", test_dir);
auto test_name = string_base(test_dir);
auto test_name = path_base(test_dir);
print("Test name: {s}\n", test_name);
if (emit_ir)

8964
bootstrap/src/pdb_image.c Normal file
View File

File diff suppressed because it is too large Load Diff

1672
bootstrap/std/base.c Normal file
View File

File diff suppressed because it is too large Load Diff

35
bootstrap/std/entry_point.c Normal file
View File

@ -0,0 +1,35 @@
#include <std/entry_point.h>
#include <std/os.h>
#if LINK_LIBC == 0
[[gnu::naked]] [[noreturn]] void _start()
{
__asm__ __volatile__(
"\nxor %ebp, %ebp"
"\npopq %rdi"
"\nmov %rsp, %rsi"
"\nand $~0xf, %rsp"
"\npushq %rsp"
"\npushq $0"
"\ncallq static_entry_point"
"\nud2\n"
);
}
#endif
#if LINK_LIBC == 0
void static_entry_point(int argc, char* argv[])
{
char** envp = (char**)&argv[argc + 1];
#else
int main(int argc, char* argv[], char* envp[])
{
#endif
calibrate_cpu_timer();
entry_point(argc, argv, envp);
#if LINK_LIBC
return 0;
#else
syscall_exit(0);
#endif
}

178
bootstrap/std/md5.c Normal file
View File

@ -0,0 +1,178 @@
#include <std/md5.h>
STRUCT(MD5Context)
{
u32 buffer[4];
u8 input[64];
u64 size;
};
// Took from: https://github.com/Zunawe/md5-c
#define MD5_A 0x67452301
#define MD5_B 0xefcdab89
#define MD5_C 0x98badcfe
#define MD5_D 0x10325476
#define MD5_F(X, Y, Z) ((X & Y) | (~X & Z))
#define MD5_G(X, Y, Z) ((X & Z) | (Y & ~Z))
#define MD5_H(X, Y, Z) (X ^ Y ^ Z)
#define MD5_I(X, Y, Z) (Y ^ (X | ~Z))
global u32 md5_s[] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21};
global u32 md5_k[] = {0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};
/*
* Padding used to make the size (in bits) of the input congruent to 448 mod 512
*/
global u8 md5_padding[] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
may_be_unused fn MD5Context md5_init()
{
return (MD5Context) {
.buffer = { MD5_A, MD5_B, MD5_C, MD5_D },
};
}
fn u32 rotate_left_u32(u32 x, u32 n)
{
return (x << n) | (x >> (32 - n));
}
may_be_unused fn void md5_step(u32* buffer, u32* input)
{
u32 aa = buffer[0];
u32 bb = buffer[1];
u32 cc = buffer[2];
u32 dd = buffer[3];
for (u32 i = 0; i < 64; i += 1)
{
u32 j;
u32 e;
switch (i / 16)
{
case 0:
{
e = MD5_F(bb, cc, dd);
j = i;
} break;
case 1:
{
e = MD5_G(bb, cc, dd);
j = ((i * 5) + 1) % 16;
} break;
case 2:
{
e = MD5_H(bb, cc, dd);
j = ((i * 3) + 5) % 16;
} break;
default:
{
e = MD5_I(bb, cc, dd);
j = (i * 7) % 16;
} break;
}
u32 old_dd = dd;
dd = cc;
cc = bb;
bb = bb + rotate_left_u32(aa + e + md5_k[i] + input[j], md5_s[i]);
aa = old_dd;
}
buffer[0] += aa;
buffer[1] += bb;
buffer[2] += cc;
buffer[3] += dd;
}
may_be_unused fn void md5_update(MD5Context* context, String input_argument)
{
u32 input_local[16];
auto offset = context->size % 64;
context->size += input_argument.length;
for (u64 i = 0; i < input_argument.length; i += 1)
{
context->input[offset] = input_argument.pointer[i];
offset += 1;
if (offset % 64 == 0)
{
// TODO: convert to little-endian in case we are big-endian?
for (u16 i = 0; i < 16; i += 1)
{
auto existing = *(u32*)&input_argument.pointer[i * 4];
input_local[i] = existing;
}
md5_step(context->buffer, input_local);
offset = 0;
}
}
}
may_be_unused fn MD5Result md5_end(MD5Context* context)
{
u32 input[16];
auto offset = context->size % 64;
auto padding_length = offset < 56 ? 56 - offset : (56 + 64) - offset;
md5_update(context, (String) { .pointer = md5_padding, .length = padding_length });
context->size -= (u64)padding_length;
for (u32 i = 0; i < 14; i += 1)
{
input[i] = *(u32*)&context->input[i * 4];
}
input[14] = (u32)(context->size * 8);
input[15] = (u32)((context->size * 8) >> 32);
md5_step(context->buffer, input);
MD5Result result;
for (u32 i = 0; i < 4; i += 1)
{
result.hash[(i * 4) + 0] = (u8)((context->buffer[i] & 0x000000ff) >> 0);
result.hash[(i * 4) + 1] = (u8)((context->buffer[i] & 0x0000ff00) >> 8);
result.hash[(i * 4) + 2] = (u8)((context->buffer[i] & 0x00ff0000) >> 16);
result.hash[(i * 4) + 3] = (u8)((context->buffer[i] & 0xff000000) >> 24);
}
return result;
}
MD5Result md5_string(String string)
{
auto context = md5_init();
md5_update(&context, string);
auto result = md5_end(&context);
return result;
}

1527
bootstrap/std/os.c Normal file
View File

File diff suppressed because it is too large Load Diff

163
bootstrap/std/sha1.c Normal file
View File

@ -0,0 +1,163 @@
#include <std/sha1.h>
// https://github.com/jasinb/sha1.git
// STRUCT(Sha1Digest)
// {
// u32 digest[5];
// };
// static uint32_t rotl32(uint32_t x, int b)
// {
// return (x << b) | (x >> (32-b));
// }
//
// switch endianness
// fn u32 sha1_get32(u8* p)
// {
// return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
// }
// fn u32 sha1_f(int t, u32 b, u32 c, u32 d)
// {
// assert(0 <= t && t < 80);
//
// if (t < 20)
// {
// return (b & c) | ((~b) & d);
// }
// else if (t < 40)
// {
// return b ^ c ^ d;
// }
// else if (t < 60)
// {
// return (b & c) | (b & d) | (c & d);
// }
// else
// //if (t < 80)
// {
// return b ^ c ^ d;
// }
// }
// STRUCT(Sha1Context)
// {
// u8 block[64];
// u32 h[5];
// u64 bytes;
// u32 cur;
// };
// fn void sha1_reset(Sha1Context* ctx)
// {
// ctx->h[0] = 0x67452301;
// ctx->h[1] = 0xefcdab89;
// ctx->h[2] = 0x98badcfe;
// ctx->h[3] = 0x10325476;
// ctx->h[4] = 0xc3d2e1f0;
// ctx->bytes = 0;
// ctx->cur = 0;
// }
// fn void sha1_process_block(Sha1Context* ctx)
// {
// global const u32 k[4] =
// {
// 0x5A827999,
// 0x6ED9EBA1,
// 0x8F1BBCDC,
// 0xCA62C1D6
// };
//
// u32 w[16];
// u32 a = ctx->h[0];
// u32 b = ctx->h[1];
// u32 c = ctx->h[2];
// u32 d = ctx->h[3];
// u32 e = ctx->h[4];
// u32 t;
//
// for (t = 0; t < 16; t++)
// w[t] = sha1_get32((u8*)(&((uint32_t*)ctx->block)[t]));
//
// for (t = 0; t < 80; t++)
// {
// auto s = t & 0xf;
// u32 temp;
// if (t >= 16)
// w[s] = rotate_left_u32(w[(s + 13) & 0xf] ^ w[(s + 8) & 0xf] ^ w[(s + 2) & 0xf] ^ w[s], 1);
//
// temp = rotate_left_u32(a, 5) + sha1_f(t, b,c,d) + e + w[s] + k[t/20];
//
// e = d; d = c; c = rotate_left_u32(b, 30); b = a; a = temp;
// }
//
// ctx->h[0] += a;
// ctx->h[1] += b;
// ctx->h[2] += c;
// ctx->h[3] += d;
// ctx->h[4] += e;
// }
// fn void sha1_write(Sha1Context* ctx, String bytes)
// {
// auto length = bytes.length;
// ctx->bytes += length;
//
// const uint8_t* src = bytes.pointer;
// while (length--)
// {
// // TODO: could optimize the first and last few bytes, and then copy
// // 128 bit blocks with SIMD in between
// ctx->block[ctx->cur++] = *src++;
// if (ctx->cur == 64)
// {
// sha1_process_block(ctx);
// ctx->cur = 0;
// }
// }
// }
// fn Sha1Digest sha1_get_digest(Sha1Context* ctx)
// {
// // append separator
// ctx->block[ctx->cur++] = 0x80;
// if (ctx->cur > 56)
// {
// // no space in block for the 64-bit message length, flush
// memset(&ctx->block[ctx->cur], 0, 64 - ctx->cur);
// sha1_process_block(ctx);
// ctx->cur = 0;
// }
//
// memset(&ctx->block[ctx->cur], 0, 56 - ctx->cur);
// uint64_t bits = ctx->bytes * 8;
//
// // TODO a few instructions could be shaven
// ctx->block[56] = (uint8_t)(bits >> 56 & 0xff);
// ctx->block[57] = (uint8_t)(bits >> 48 & 0xff);
// ctx->block[58] = (uint8_t)(bits >> 40 & 0xff);
// ctx->block[59] = (uint8_t)(bits >> 32 & 0xff);
// ctx->block[60] = (uint8_t)(bits >> 24 & 0xff);
// ctx->block[61] = (uint8_t)(bits >> 16 & 0xff);
// ctx->block[62] = (uint8_t)(bits >> 8 & 0xff);
// ctx->block[63] = (uint8_t)(bits >> 0 & 0xff);
// sha1_process_block(ctx);
//
// {
// Sha1Digest ret;
// int i;
// for (i = 0; i < 5; i++)
// ret.digest[i] = sha1_get32((u8*)&ctx->h[i]);
// sha1_reset(ctx);
// return ret;
// }
// }
// fn Sha1Digest sha1_compute(String bytes)
// {
// Sha1Context ctx;
// sha1_reset(&ctx);
// sha1_write(&ctx, bytes);
// return sha1_get_digest(&ctx);
// }

63
bootstrap/std/string.c Normal file
View File

@ -0,0 +1,63 @@
#include <std/string.h>
s32 string_first_ch(String string, u8 ch)
{
s32 result = -1;
for (u64 i = 0; i < string.length; i += 1)
{
if (string.pointer[i] == ch)
{
result = i;
break;
}
}
return result;
}
s64 string_last_ch(String string, u8 ch)
{
s64 result = -1;
u64 i = string.length;
while (i > 0)
{
i -= 1;
if (string.pointer[i] == ch)
{
result = cast(s64, u64, i);
break;
}
}
return result;
}
u8 string_starts_with(String string, String start)
{
u8 result = 0;
if (likely(start.length <= string.length))
{
if (unlikely(start.pointer == string.pointer))
{
result = 1;
}
else
{
u64 i;
for (i = 0; i < start.length; i += 1)
{
auto start_ch = start.pointer[i];
auto string_ch = string.pointer[i];
if (unlikely(string_ch != start_ch))
{
break;
}
}
result = i == start.length;
}
}
return result;
}

67
bootstrap/std/virtual_buffer.c Normal file
View File

@ -0,0 +1,67 @@
#include <std/virtual_buffer.h>
#include <std/os.h>
void vb_generic_ensure_capacity(VirtualBuffer(u8)* vb, u32 item_size, u32 item_count)
{
u32 old_capacity = vb->capacity;
u32 wanted_capacity = vb->length + item_count;
if (old_capacity < wanted_capacity)
{
if (old_capacity == 0)
{
vb->pointer = os_reserve(0, item_size * UINT32_MAX, (OSReserveProtectionFlags) {}, (OSReserveMapFlags) { .priv = 1, .anon = 1, .noreserve = 1 });
}
u32 old_page_capacity = cast(u32, u64, align_forward(old_capacity * item_size, minimum_granularity));
u32 new_page_capacity = cast(u32, u64, align_forward(wanted_capacity * item_size, minimum_granularity));
u32 commit_size = new_page_capacity - old_page_capacity;
void* commit_pointer = vb->pointer + old_page_capacity;
os_commit(commit_pointer, commit_size);
u32 new_capacity = new_page_capacity / item_size;
vb->capacity = new_capacity;
}
}
u8* vb_generic_add_assume_capacity(VirtualBuffer(u8)* vb, u32 item_size, u32 item_count)
{
u32 index = vb->length;
assert(vb->capacity >= index + item_count);
vb->length = index + item_count;
return vb->pointer + (index * item_size);
}
u8* vb_generic_add(VirtualBuffer(u8)* vb, u32 item_size, u32 item_count)
{
vb_generic_ensure_capacity(vb, item_size, item_count);
return vb_generic_add_assume_capacity(vb, item_size, item_count);
}
u8* vb_append_bytes(VirtualBuffer(u8*) vb, Slice(u8) bytes)
{
auto len = cast(u32, u64, bytes.length);
vb_generic_ensure_capacity(vb, sizeof(u8), len);
auto* pointer = vb_generic_add_assume_capacity(vb, sizeof(u8), len);
memcpy(pointer, bytes.pointer, len);
return pointer;
}
void vb_copy_string(VirtualBuffer(u8)* buffer, String string)
{
auto length = cast(u32, u64, string.length);
auto* pointer = vb_add(buffer, length);
memcpy(pointer, string.pointer, length);
}
u64 vb_copy_string_zero_terminated(VirtualBuffer(u8)* buffer, String string)
{
assert(string.pointer[string.length] == 0);
string.length += 1;
vb_copy_string(buffer, string);
return string.length;
}

9
project.bat
View File

@ -1,9 +0,0 @@
mkdir build
clang -o build/build.exe bootstrap/build.c -g -march=native -std=gnu2x -Wall -Wextra -Wpedantic -Wno-nested-anon-types -Wno-keyword-macro -Wno-gnu-auto-type -Wno-auto-decl-extensions -Wno-gnu-empty-initializer -Wno-fixed-enum-extension -pedantic -fno-exceptions -fno-stack-protector -Wl,/INCREMENTAL:no
SET clang_exit_code=%errorlevel%
echo Clang exit code: %clang_exit_code%
if %clang_exit_code% neq 0 exit /b %clang_exit_code%
.\build\build.exe %*
SET builder_exit_code=%errorlevel%
echo Builder exit code: %builder_exit_code%
if %builder_exit_code% neq 0 exit /b %builder_exit_code%

40
project.ps1 Normal file
View File

@ -0,0 +1,40 @@
Set-StrictMode -Version Latest
Set-PSDebug -Trace 2
$previous_error_action_preference = $global:ErrorActionPreference
$myargs=$args
$build_dir="build"
$release_mode="Debug"
$build_type_prefix="build_type="
& {
try
{
$global:ErrorActionPreference = 'Stop'
if ($($myargs.Length) -ne 0 -and $myargs[0].StartsWith($build_type_prefix))
{
$release_mode = $myargs[0].Substring($build_type_prefix.Length)
}
Write-Output "Build type: $release_mode"
New-Item -Path $build_dir -ItemType Directory -Force
cmake . "-B$build_dir" -G Ninja "-DCMAKE_BUILD_TYPE=$release_mode" -DCMAKE_C_COMPILER="clang" -DCMAKE_CXX_COMPILER="clang++"
pushd $build_dir
ninja
popd
if ($($myargs.Length) -ne 0)
{
& ".\$build_dir\runner" $myargs
}
}
catch
{
throw
}
finally
{
$global:ErrorActionPreference = $previous_error_action_preference
}
}

26
project.sh
View File

@ -1,10 +1,18 @@
#!/bin/bash
#!/usr/bin/env bash
set -ex
mkdir -p build
case "$OSTYPE" in
linux*) CLANG_PATH="clang" ;;
darwin*) CLANG_PATH="/opt/homebrew/opt/llvm/bin/clang" ;;
*) exit 1 ;;
esac
time $CLANG_PATH -o build/build bootstrap/build.c -g -march=native -std=gnu2x -Wall -Wextra -Wpedantic -Wno-nested-anon-types -Wno-keyword-macro -Wno-gnu-auto-type -Wno-auto-decl-extensions -Wno-gnu-empty-initializer -Wno-fixed-enum-extension -pedantic -fno-exceptions -fno-stack-protector
build/build $@
release_mode="Debug"
if [[ "$1" =~ ^build_type=.* ]]; then
release_mode=${1#build_type=}
fi
echo "Build type: $release_mode"
build_dir=build
mkdir -p $build_dir
cmake . -B$build_dir -G Ninja -DCMAKE_BUILD_TYPE="$release_mode" -DCMAKE_C_COMPILER="clang" -DCMAKE_CXX_COMPILER="clang++"
original_dir=$PWD
cd $build_dir
ninja
cd $original_dir
if [ "$#" -ne 0 ]; then
$build_dir/runner $@
fi