move pre-normalized IR passes in the frontends

Hugobros3 · Hugobros3 · commit 90127fa32391 · 2024-04-15T15:08:15.000+02:00
diff --git a/include/shady/driver.h b/include/shady/driver.h
@@ -26,8 +26,8 @@ typedef enum {
 } SourceLanguage;
 
 SourceLanguage guess_source_language(const char* filename);
-ShadyErrorCodes driver_load_source_file(const CompilerConfig* config, SourceLanguage lang, size_t, const char* file_contents, Module* mod);
-ShadyErrorCodes driver_load_source_file_from_filename(const CompilerConfig* config, const char* filename, Module* mod);
+ShadyErrorCodes driver_load_source_file(const CompilerConfig* config, SourceLanguage lang, size_t, const char* file_contents, String, Module** mod);
+ShadyErrorCodes driver_load_source_file_from_filename(const CompilerConfig* config, const char* filename, String, Module** mod);
 
 typedef enum {
     TgtAuto,
diff --git a/include/shady/ir.h b/include/shady/ir.h
@@ -326,6 +326,7 @@ typedef enum CompilationResult_ {
 } CompilationResult;
 
 CompilationResult run_compiler_passes(CompilerConfig* config, Module** mod);
+void link_module(Module* dst, Module* src);
 
 //////////////////////////////// Emission ////////////////////////////////
 
diff --git a/include/shady/runtime.h b/include/shady/runtime.h
@@ -29,8 +29,6 @@ typedef struct CompilerConfig_ CompilerConfig;
 typedef struct Module_ Module;
 
 Program* new_program_from_module(Runtime*, const CompilerConfig*, Module*);
-Program* load_program(Runtime*, const CompilerConfig*, const char* program_src);
-Program* load_program_from_disk(Runtime*, const CompilerConfig*, const char* path);
 
 Command* launch_kernel(Program*, Device*, const char* entry_point, int dimx, int dimy, int dimz, int args_count, void** args);
 bool wait_completion(Command*);
diff --git a/samples/aobench/ao_main.c b/samples/aobench/ao_main.c
@@ -127,7 +127,9 @@ void render_device(Args* args, TEXEL_T *img, int w, int h, int nsubsamples, Stri
 
     info_print("Device-side address is: %zu\n", buf_addr);
 
-    Program* program = load_program_from_disk(runtime, &args->compiler_config, path);
+    Module* m;
+    CHECK(driver_load_source_file_from_filename(&args->compiler_config, path, "aobench", &m) == NoError, return);
+    Program* program = new_program_from_module(runtime, &args->compiler_config, m);
 
     // run it twice to compile everything and benefit from caches
     wait_completion(launch_kernel(program, device, "aobench_kernel", WIDTH / BLOCK_SIZE, HEIGHT / BLOCK_SIZE, 1, 1, (void*[]) { &buf_addr }));
diff --git a/samples/checkerboard/checkerboard.c b/samples/checkerboard/checkerboard.c
@@ -68,8 +68,9 @@ int main(int argc, char **argv)
     info_print("Device-side address is: %zu\n", buf_addr);
 
     IrArena* a = new_ir_arena(default_arena_config());
-    Module* m = new_module(a, "checkerboard");
-    driver_load_source_file(&compiler_config, SrcSlim, sizeof(checkerboard_kernel_src), checkerboard_kernel_src, m);
+    Module* m;
+    if (driver_load_source_file(&compiler_config, SrcSlim, sizeof(checkerboard_kernel_src), checkerboard_kernel_src, "checkerboard", &m) != NoError)
+        error("Failed to load checkerboard module");
     Program* program = new_program_from_module(runtime, &compiler_config, m);
 
     wait_completion(launch_kernel(program, device, "main", 16, 16, 1, 1, (void*[]) { &buf_addr }));
diff --git a/src/common/log.h b/src/common/log.h
@@ -20,7 +20,7 @@ void set_log_level(LogLevel);
 void log_string(LogLevel level, const char* format, ...);
 void log_node(LogLevel level, const Node* node);
 typedef struct CompilerConfig_ CompilerConfig;
-void log_module(LogLevel level, CompilerConfig*, Module*);
+void log_module(LogLevel level, const CompilerConfig*, Module*);
 
 #define debugvv_print(...) log_string(DEBUGVV, __VA_ARGS__)
 #define debugv_print(...) log_string(DEBUGV, __VA_ARGS__)
diff --git a/src/driver/driver.c b/src/driver/driver.c
@@ -37,19 +37,20 @@ SourceLanguage guess_source_language(const char* filename) {
     return SrcSlim;
 }
 
-ShadyErrorCodes driver_load_source_file(const CompilerConfig* config, SourceLanguage lang, size_t len, const char* file_contents, Module* mod) {
+ShadyErrorCodes driver_load_source_file(const CompilerConfig* config, SourceLanguage lang, size_t len, const char* file_contents, String name, Module** mod) {
     switch (lang) {
         case SrcLLVM: {
 #ifdef LLVM_PARSER_PRESENT
-            parse_llvm_into_shady(config, mod, len, file_contents);
+            bool ok = parse_llvm_into_shady(config, len, file_contents, name, mod);
+            assert(ok);
 #else
             assert(false && "LLVM front-end missing in this version");
 #endif
             break;
         }
         case SrcSPIRV: {
 #ifdef SPV_PARSER_PRESENT
-            parse_spirv_into_shady(mod, len, file_contents);
+            parse_spirv_into_shady(len, file_contents, name, mod);
 #else
             assert(false && "SPIR-V front-end missing in this version");
 #endif
@@ -58,16 +59,16 @@ ShadyErrorCodes driver_load_source_file(const CompilerConfig* config, SourceLang
         case SrcShadyIR:
         case SrcSlim: {
             ParserConfig pconfig = {
-                    .front_end = lang == SrcSlim,
+                .front_end = lang == SrcSlim,
             };
             debugv_print("Parsing: \n%s\n", file_contents);
-            parse_shady_ir(pconfig, (const char*) file_contents, mod);
+            *mod = parse_slim_module(config, pconfig, (const char*) file_contents, name);
         }
     }
     return NoError;
 }
 
-ShadyErrorCodes driver_load_source_file_from_filename(const CompilerConfig* config, const char* filename, Module* mod) {
+ShadyErrorCodes driver_load_source_file_from_filename(const CompilerConfig* config, const char* filename, String name, Module** mod) {
     ShadyErrorCodes err;
     SourceLanguage lang = guess_source_language(filename);
     size_t len;
@@ -84,7 +85,7 @@ ShadyErrorCodes driver_load_source_file_from_filename(const CompilerConfig* conf
         err = InputFileDoesNotExist;
         goto exit;
     }
-    err = driver_load_source_file(config, lang, len, contents, mod);
+    err = driver_load_source_file(config, lang, len, contents, name, mod);
     exit:
     free((void*) contents);
     return err;
@@ -98,9 +99,11 @@ ShadyErrorCodes driver_load_source_files(DriverConfig* args, Module* mod) {
 
     size_t num_source_files = entries_count_list(args->input_filenames);
     for (size_t i = 0; i < num_source_files; i++) {
-        int err = driver_load_source_file_from_filename(&args->config, read_list(const char*, args->input_filenames)[i], mod);
+        Module* m;
+        int err = driver_load_source_file_from_filename(&args->config, read_list(const char*, args->input_filenames)[i], read_list(const char*, args->input_filenames)[i], &m);
         if (err)
             return err;
+        link_module(mod, m);
     }
 
     return NoError;
diff --git a/src/driver/vcc.c b/src/driver/vcc.c
@@ -70,7 +70,6 @@ int main(int argc, char** argv) {
 
     ArenaConfig aconfig = default_arena_config();
     IrArena* arena = new_ir_arena(aconfig);
-    Module* mod = new_module(arena, "my_module"); // TODO name module after first filename, or perhaps the last one
 
     int clang_retval = system("clang --version");
     if (clang_retval != 0)
@@ -140,12 +139,13 @@ int main(int argc, char** argv) {
     if (clang_returned)
         exit(ClangInvocationFailed);
 
+    Module* mod;
     if (!vcc_options.only_run_clang) {
         size_t len;
         char* llvm_ir;
         if (!read_file(vcc_options.tmp_filename, &len, &llvm_ir))
             exit(InputFileIOError);
-        driver_load_source_file(&args.config, SrcLLVM, len, llvm_ir, mod);
+        driver_load_source_file(&args.config, SrcLLVM, len, llvm_ir, "my_module", &mod); // TODO name module after first filename, or perhaps the last one
         free(llvm_ir);
 
         if (vcc_options.delete_tmp_file)
diff --git a/src/frontends/llvm/l2s.c b/src/frontends/llvm/l2s.c
@@ -230,7 +230,7 @@ const Node* convert_global(Parser* p, LLVMValueRef global) {
     return r;
 }
 
-bool parse_llvm_into_shady(const CompilerConfig* config, Module* dst, size_t len, const char* data) {
+bool parse_llvm_into_shady(const CompilerConfig* config, size_t len, const char* data, String name, Module** dst) {
     LLVMContextRef context = LLVMContextCreate();
     LLVMModuleRef src;
     LLVMMemoryBufferRef mem = LLVMCreateMemoryBufferWithMemoryRange(data, len, "my_great_buffer", false);
@@ -245,7 +245,12 @@ bool parse_llvm_into_shady(const CompilerConfig* config, Module* dst, size_t len
     get_module_arena(dst)->config.untyped_ptrs = true; // tolerate untyped ptrs...
 #endif
 
-    Module* dirty = new_module(get_module_arena(dst), "dirty");
+    ArenaConfig aconfig = default_arena_config();
+    aconfig.check_types = false;
+    aconfig.allow_fold = false;
+
+    IrArena* arena = new_ir_arena(aconfig);
+    Module* dirty = new_module(arena, "dirty");
     Parser p = {
         .ctx = context,
         .config = config,
@@ -274,7 +279,14 @@ bool parse_llvm_into_shady(const CompilerConfig* config, Module* dst, size_t len
         global = LLVMGetNextGlobal(global);
     }
 
-    postprocess(&p, dirty, dst);
+    aconfig.check_types = true;
+    aconfig.allow_fold = true;
+    IrArena* arena2 = new_ir_arena(aconfig);
+    *dst = new_module(arena2, name);
+    postprocess(&p, dirty, *dst);
+    log_module(DEBUG, config, *dst);
+    verify_module(config, *dst);
+    destroy_ir_arena(arena);
 
     destroy_dict(p.map);
     destroy_dict(p.annotations);
diff --git a/src/frontends/llvm/l2s.h b/src/frontends/llvm/l2s.h
@@ -4,6 +4,6 @@
 #include "shady/ir.h"
 #include <stdbool.h>
 
-bool parse_llvm_into_shady(const CompilerConfig*, Module* dst, size_t len, const char* data);
+bool parse_llvm_into_shady(const CompilerConfig*, size_t len, const char* data, String name, Module** dst);
 
 #endif
diff --git a/src/frontends/slim/parser.c b/src/frontends/slim/parser.c
@@ -1074,7 +1074,7 @@ static const Node* accept_nominal_type_decl(ctxparams, Nodes annotations) {
     return nom;
 }
 
-void parse_shady_ir(ParserConfig config, const char* contents, Module* mod) {
+static void parse_shady_ir(ParserConfig config, const char* contents, Module* mod) {
     IrArena* arena = get_module_arena(mod);
     Tokenizer* tokenizer = new_tokenizer(contents);
 
@@ -1103,3 +1103,31 @@ void parse_shady_ir(ParserConfig config, const char* contents, Module* mod) {
 
     destroy_tokenizer(tokenizer);
 }
+
+#include "compile.h"
+#include "transform/internal_constants.h"
+
+Module* parse_slim_module(const CompilerConfig* config, ParserConfig pconfig, const char* contents, String name) {
+    ArenaConfig aconfig = default_arena_config();
+    aconfig.name_bound = false;
+    aconfig.check_op_classes = false;
+    aconfig.check_types = false;
+    aconfig.validate_builtin_types = false;
+    aconfig.allow_fold = false;
+    IrArena* initial_arena = new_ir_arena(aconfig);
+    Module* m = new_module(initial_arena, name);
+    parse_shady_ir(pconfig, contents, m);
+    Module** pmod = &m;
+    Module* old_mod = NULL;
+
+    generate_dummy_constants(config, *pmod);
+
+    RUN_PASS(bind_program)
+    RUN_PASS(normalize)
+
+    RUN_PASS(normalize_builtins)
+    RUN_PASS(infer_program)
+
+    destroy_ir_arena(initial_arena);
+    return *pmod;
+}
diff --git a/src/frontends/slim/parser.h b/src/frontends/slim/parser.h
@@ -36,6 +36,6 @@ INFIX_OPERATORS()
     InfixOperatorsCount
 } InfixOperators;
 
-void parse_shady_ir(ParserConfig config, const char* contents, Module* mod);
+Module* parse_slim_module(const CompilerConfig* config, ParserConfig pconfig, const char* contents, String name);
 
 #endif
diff --git a/src/frontends/spirv/s2s.c b/src/frontends/spirv/s2s.c
@@ -1356,13 +1356,16 @@ bool compare_spvid(SpvId* pa, SpvId* pb) {
     return *pa == *pb;
 }
 
-S2SError parse_spirv_into_shady(Module* dst, size_t len, const char* data) {
+S2SError parse_spirv_into_shady(size_t len, const char* data, String name, Module** dst) {
+    IrArena* a = new_ir_arena(default_arena_config());
+    *dst = new_module(a, name);
+
     SpvParser parser = {
         .cursor = 0,
         .len = len / sizeof(uint32_t),
         .words = (uint32_t*) data,
-        .mod = dst,
-        .arena = get_module_arena(dst),
+        .mod = *dst,
+        .arena = get_module_arena(*dst),
 
         .decorations_arena = new_arena(),
         .phi_arguments = new_dict(SpvId, SpvPhiArgs*, (HashFn) hash_spvid, (CmpFn) compare_spvid),
diff --git a/src/frontends/spirv/s2s.h b/src/frontends/spirv/s2s.h
@@ -8,6 +8,6 @@ typedef enum {
     S2S_FailedParsingGeneric,
 } S2SError;
 
-S2SError parse_spirv_into_shady(Module* dst, size_t len, const char* data);
+S2SError parse_spirv_into_shady(size_t len, const char* data, String name, Module**);
 
 #endif
diff --git a/src/runtime/runtime_program.c b/src/runtime/runtime_program.c
@@ -25,30 +25,28 @@ Program* new_program_from_module(Runtime* runtime, const CompilerConfig* base_co
 }
 
 Program* load_program(Runtime* runtime, const CompilerConfig* base_config, const char* program_src) {
-    IrArena* arena = new_ir_arena(default_arena_config());
-    Module* module = new_module(arena, "my_module");
+    Module* module;
 
-    int err = driver_load_source_file(base_config, SrcShadyIR, strlen(program_src), program_src, module);
+    int err = driver_load_source_file(base_config, SrcShadyIR, strlen(program_src), program_src, "my_module", &module);
     if (err != NoError) {
         return NULL;
     }
 
     Program* program = new_program_from_module(runtime, base_config, module);
-    program->arena = arena;
+    program->arena = get_module_arena(module);
     return program;
 }
 
 Program* load_program_from_disk(Runtime* runtime, const CompilerConfig* base_config, const char* path) {
-    IrArena* arena = new_ir_arena(default_arena_config());
-    Module* module = new_module(arena, "my_module");
+    Module* module;
 
-    int err = driver_load_source_file_from_filename(base_config, path, module);
+    int err = driver_load_source_file_from_filename(base_config, path, "my_module", &module);
     if (err != NoError) {
         return NULL;
     }
 
     Program* program = new_program_from_module(runtime, base_config, module);
-    program->arena = arena;
+    program->arena = get_module_arena(module);
     return program;
 }
 
diff --git a/src/runtime/runtime_test.c b/src/runtime/runtime_test.c
@@ -50,12 +50,13 @@ int main(int argc, char* argv[]) {
 
     Program* program;
     IrArena* arena = NULL;
+    arena = new_ir_arena(default_arena_config());
     if (entries_count_list(args.driver_config.input_filenames) == 0) {
-        program = load_program(runtime, &args.driver_config.config, default_shader);
+        Module* module;
+        driver_load_source_file(&args.driver_config.config, SrcSlim, strlen(default_shader), default_shader, "runtime_test", &module);
+        program = new_program_from_module(runtime, &args.driver_config.config, module);
     } else {
-        arena = new_ir_arena(default_arena_config());
         Module* module = new_module(arena, "my_module");
-
         int err = driver_load_source_files(&args.driver_config, module);
         if (err)
             return err;
diff --git a/src/shady/compile.c b/src/shady/compile.c
@@ -51,7 +51,11 @@ CompilerConfig default_compiler_config() {
 ArenaConfig default_arena_config() {
     ArenaConfig config = {
         .is_simt = true,
-        .validate_builtin_types = false,
+        .name_bound = true,
+        .allow_fold = true,
+        .check_types = true,
+        .validate_builtin_types = true,
+        .check_op_classes = true,
 
         .memory = {
             .word_size = IntTy8,
@@ -72,27 +76,23 @@ ArenaConfig default_arena_config() {
     return config;
 }
 
+void add_scheduler_source(const CompilerConfig* config, Module* dst) {
+    ParserConfig pconfig = {
+        .front_end = true,
+    };
+    Module* builtin_scheduler_mod = parse_slim_module(config, pconfig, shady_scheduler_src, "builtin_scheduler");
+    debug_print("Adding builtin scheduler code");
+    link_module(dst, builtin_scheduler_mod);
+}
+
 CompilationResult run_compiler_passes(CompilerConfig* config, Module** pmod) {
     if (config->dynamic_scheduling) {
-        debugv_print("Parsing builtin scheduler code");
-        ParserConfig pconfig = {
-            .front_end = true,
-        };
-        parse_shady_ir(pconfig, shady_scheduler_src, *pmod);
+        add_scheduler_source(config, *pmod);
     }
 
     IrArena* initial_arena = (*pmod)->arena;
     Module* old_mod = NULL;
 
-    generate_dummy_constants(config, *pmod);
-
-    if (!get_module_arena(*pmod)->config.name_bound)
-        RUN_PASS(bind_program)
-    RUN_PASS(normalize)
-
-    RUN_PASS(normalize_builtins)
-    RUN_PASS(infer_program)
-
     RUN_PASS(reconvergence_heuristics)
 
     RUN_PASS(lower_cf_instrs)
diff --git a/src/shady/passes/import.c b/src/shady/passes/import.c
diff --git a/src/shady/print.c b/src/shady/print.c
diff --git a/src/shady/transform/internal_constants.c b/src/shady/transform/internal_constants.c
diff --git a/src/shady/transform/internal_constants.h b/src/shady/transform/internal_constants.h
