From 2a6339a25e7f336e91a20087ace1c1188c6d2f21 Mon Sep 17 00:00:00 2001 From: Christoffer Lerno Date: Thu, 23 Feb 2023 17:35:34 +0100 Subject: [PATCH] Updated native variants of file handling. Fixed $if folding chain. --- lib/std/core/env.c3 | 8 +- lib/std/io/dir.c3 | 11 +- lib/std/io/io.c3 | 11 +- lib/std/io/io_file.c3 | 68 ++--- lib/std/io/os/file.c3 | 188 ++++++++++++ lib/std/libc/libc.c3 | 5 +- src/compiler/sema_expr.c | 1 - src/compiler/sema_stmts.c | 14 +- src/version.h | 2 +- test/test_suite/bitstruct/bitstruct_be.c3t | 161 +++++------ .../compile_time/ct_builtin_time_date.c3t | 54 ++-- test/test_suite/compile_time/ct_memberof.c3t | 267 +++++++++--------- .../errors/general_error_regression.c3t | 18 +- test/test_suite/errors/or_and_rethrow.c3t | 45 +-- test/test_suite/from_docs/examples_defer.c3t | 73 ++--- .../from_docs/examples_forswitch.c3t | 84 +++--- .../initializer_lists/subarrays.c3t | 88 +++--- 17 files changed, 653 insertions(+), 445 deletions(-) create mode 100644 lib/std/io/os/file.c3 diff --git a/lib/std/core/env.c3 b/lib/std/core/env.c3 index bf86e3545..131b7230f 100644 --- a/lib/std/core/env.c3 +++ b/lib/std/core/env.c3 @@ -128,6 +128,11 @@ const bool BENCHMARKING = $$BENCHMARKING; const bool TESTING = $$TESTING; const MemoryEnvironment MEMORY_ENV = (MemoryEnvironment)$$MEMORY_ENVIRONMENT; +macro bool os_is_win32() +{ + return OS_TYPE == OsType.WIN32; +} + macro bool os_is_posix() { $switch (OS_TYPE): @@ -204,4 +209,5 @@ $if (COMPILER_LIBC_AVAILABLE && OS_TYPE != OsType.WIN32): } }; $endif; -} \ No newline at end of file +} + diff --git a/lib/std/io/dir.c3 b/lib/std/io/dir.c3 index 4d33d4afa..30420bcf3 100644 --- a/lib/std/io/dir.c3 +++ b/lib/std/io/dir.c3 @@ -3,8 +3,7 @@ import std::io::os; // In progress. typedef Path = distinct String; -const PREFERRED_SEPARATOR = USE_WIN32_FILESYSTEM ? '\\' : '/'; -const USE_WIN32_FILESYSTEM @private = env::OS_TYPE != OsType.WIN32; +const PREFERRED_SEPARATOR = env::os_is_win32() ? '\\' : '/'; fault PathResult { @@ -23,7 +22,7 @@ fn String! tgetcwd() macro bool is_separator(char c) { - $if (USE_WIN32_FILESYSTEM): + $if (env::os_is_win32()): return c == '/' || c == '\\'; $else: return c == '/'; @@ -49,7 +48,7 @@ const bool[256] RESERVED_PATH_CHAR_WIN32 = { macro bool is_reserved_path_char(char c) { -$if (USE_WIN32_FILESYSTEM): +$if (env::os_is_win32()): return RESERVED_PATH_CHAR_WIN32[c]; $else: return RESERVED_PATH_CHAR_POSIX[c]; @@ -60,7 +59,7 @@ fn usz! root_name_len(String path) @private { usz len = path.len; if (!len) return 0; - $if (USE_WIN32_FILESYSTEM): + $if (env::os_is_win32()): switch (path[0]) { case '\\': @@ -157,7 +156,7 @@ fn Path Path.root_directory(Path path) String path_str = (String)path; usz len = path_str.len; if (!len) return (Path)""; - $if (USE_WIN32_FILESYSTEM): + $if (env::os_is_win32()): usz root_len = root_name_len(path_str)!!; if (root_len == len || !is_separator(path_str[root_len])) return (Path)""; return (Path)path_str[root_len..root_len]; diff --git a/lib/std/io/io.c3 b/lib/std/io/io.c3 index 952b55574..00951e431 100644 --- a/lib/std/io/io.c3 +++ b/lib/std/io/io.c3 @@ -21,16 +21,23 @@ fault IoError FILE_NOT_FOUND, FILE_NOT_VALID, INVALID_POSITION, - FILE_OVERFLOW, + OVERFLOW, FILE_IS_PIPE, FILE_EOF, INCOMPLETE_WRITE, - FILE_NOT_DIR, NO_PERMISSION, + OUT_OF_DISK, INVALID_PUSHBACK, EOF, + TOO_MANY_DESCRIPTORS, + FILE_IS_DIR, + READ_ONLY, + FILE_NOT_DIR, + SYMLINK_FAILED, + ALREADY_EXISTS, NOT_SEEKABLE, NAME_TOO_LONG, + WOULD_BLOCK, INTERRUPTED, GENERAL_ERROR, UNKNOWN_ERROR, diff --git a/lib/std/io/io_file.c3 b/lib/std/io/io_file.c3 index d50fc62f1..be8f77756 100644 --- a/lib/std/io/io_file.c3 +++ b/lib/std/io/io_file.c3 @@ -2,23 +2,11 @@ module std::io; import libc; -$if (env::OS_TYPE == OsType.WIN32): -extern fn void* _wfopen(Char16*, Char16*) @local; -$endif; + fn void! File.open(File* file, String filename, String mode) { - @pool() - { -$if (env::OS_TYPE == OsType.WIN32): - file.file = (CFile)_wfopen( - str::utf8to16(filename, mem::temp_allocator())!!, - str::utf8to16(mode, mem::temp_allocator())!!); -$else: - file.file = libc::fopen(filename.zstrtcopy(), mode.zstrtcopy()); -$endif; - if (!file.file) return IoError.FILE_NOT_FOUND!; - }; + file.file = os::native_fopen(filename, mode)?; } /** @@ -26,24 +14,19 @@ $endif; **/ fn void! File.reopen(File* file, String filename, String mode) { - @pool() - { - file.file = libc::freopen(filename.zstrtcopy(), mode.zstrtcopy(), file.file); - if (!file.file) return IoError.FILE_NOT_FOUND!; - }; + file.file = os::native_freopen(file.file, filename, mode)?; } /** * @require file.file != null **/ -fn void! File.chmode(File* file, String filename, String mode) +fn usz! File.seek(File file, isz offset, Seek seek_mode = Seek.SET) { - @pool() - { - file.file = libc::freopen(null, mode.zstrtcopy(), file.file); - if (!file.file) return IoError.FILE_NOT_FOUND!; - }; + os::native_fseek(file.file, offset, seek_mode)?; + return os::native_ftell(file.file); } + + /* Implement later /** @@ -59,25 +42,6 @@ fn void! File.memopen(File* file, char[] data, String mode) } */ -/** - * @require file.file != null - **/ -fn usz! File.seek(File *file, isz offset, Seek seekMode = Seek.SET) -{ - if (libc::fseek(file.file, (SeekIndex)(offset), (int)(seekMode))) - { - switch (libc::errno()) - { - case errno::EBADF: return IoError.NOT_SEEKABLE!; - case errno::EINVAL: return IoError.INVALID_POSITION!; - case errno::EOVERFLOW: return IoError.FILE_OVERFLOW!; - case errno::ESPIPE: return IoError.FILE_IS_PIPE!; - default: return IoError.UNKNOWN_ERROR!; - } - } - if (seekMode == Seek.SET) return offset; - return libc::ftell(file.file); -} /** * @require file && file.file != null @@ -124,9 +88,9 @@ fn bool File.eof(File* file) @inline /** * @param [in] buffer */ -fn usz File.read(File* file, char[] buffer) +fn usz! File.read(File* file, char[] buffer) { - return libc::fread(buffer.ptr, 1, buffer.len, file.file); + return os::native_fread(file.file, buffer); } /** @@ -134,16 +98,16 @@ fn usz File.read(File* file, char[] buffer) * @param [&out] buffer * @require file.file `File must be initialized` */ -fn usz File.write(File* file, char[] buffer) +fn usz! File.write(File file, char[] buffer) { - return libc::fwrite(buffer.ptr, 1, buffer.len, file.file); + return os::native_fwrite(file.file, buffer); } /** * @param [&in] file * @require file.file `File must be initialized` */ -fn usz! File.printn(File* file, String string) +fn usz! File.printn(File file, String string) { usz len = file.print(string)?; if (!libc::putc('\n', file.file)) return IoError.UNKNOWN_ERROR!; @@ -154,14 +118,14 @@ fn usz! File.printn(File* file, String string) * @param [&in] file * @require file.file `File must be initialized` */ -fn usz! File.print(File* file, String string) +fn usz! File.print(File file, String string) { usz len = string.len; - if (len != libc::fwrite(string.ptr, 1, len, file.file)) return IoError.UNKNOWN_ERROR!; + if (len != file.write((char[])string)?) return IoError.UNKNOWN_ERROR!; return len; } -fn usz! File.println(File* file, String string) => file.printn(string); +fn usz! File.println(File file, String string) => file.printn(string); /** * @param [&in] file diff --git a/lib/std/io/os/file.c3 b/lib/std/io/os/file.c3 new file mode 100644 index 000000000..26555e495 --- /dev/null +++ b/lib/std/io/os/file.c3 @@ -0,0 +1,188 @@ +module std::io::os; +import libc; + +define FopenFn = fn CFile!(String, String); +define FreopenFn = fn CFile!(CFile, String, String); +define FcloseFn = fn void!(CFile); +define FseekFn = fn void!(CFile, isz, Seek); +define FtellFn = fn usz!(CFile); +define FwriteFn = fn usz!(CFile, char[] buffer); +define FreadFn = fn usz!(CFile, char[] buffer); + +$if (!$defined(native_fopen_fn)): +FopenFn native_fopen_fn @weak; +$endif; +$if (!$defined(native_fclose_fn)): +FcloseFn native_fclose_fn @weak; +$endif; +$if (!$defined(native_freopen_fn)): +FreopenFn native_freopen_fn @weak; +$endif; +$if (!$defined(native_fseek_fn)): +FseekFn native_fseek_fn @weak; +$endif; +$if (!$defined(native_ftell_fn)): +FtellFn native_ftell_fn @weak; +$endif; +$if (!$defined(native_fwrite_fn)): +FwriteFn native_fwrite_fn @weak; +$endif; +$if (!$defined(native_fread_fn)): +FreadFn native_fread_fn @weak; +$endif; + + +/** + * @require mode.len > 0 + * @require filename.len > 0 + **/ +fn CFile! native_fopen(String filename, String mode) @inline +{ +$if (!env::COMPILER_LIBC_AVAILABLE): + if (native_fopen_fn) return native_fopen_fn(filename, mode); + unreachable("Tried to call fopen without support."); +$else: + @pool() + { + $if (env::os_is_win32()): + CFile file = (CFile)_wfopen( + str::utf8to16(filename, mem::temp_allocator())!!, + str::utf8to16(mode, mem::temp_allocator())!!); + $else: + CFile file = libc::fopen(filename.zstrtcopy(), mode.zstrtcopy()); + $endif; + return file ?: file_open_errno()!; + }; +$endif; +} + +/** + * @require mode.len > 0 + * @require filename.len > 0 + **/ +fn CFile! native_freopen(CFile file, String filename, String mode) @inline +{ +$if (!env::COMPILER_LIBC_AVAILABLE): + if (native_freopen_fn) return native_freopen_fn(file, filename, mode); + unreachable("Tried to call freopen without support."); +$else: + @pool() + { + $if (env::os_is_win32()): + file = (CFile)_wfreopen( + str::utf8to16(filename, mem::temp_allocator())!!, + str::utf8to16(mode, mem::temp_allocator())!!, + file); + $else: + file = libc::freopen(filename.zstrtcopy(), mode.zstrtcopy(), file); + $endif; + return file ?: file_open_errno()!; + }; +$endif; +} + +fn void! native_fseek(CFile file, isz offset, Seek seek_mode) @inline +{ +$if (!env::COMPILER_LIBC_AVAILABLE): + if (native_fseek_fn) return native_fseek_fn(file, offset, seek_mode); + unreachable("Tried to call fseek without support."); +$else: + $if (env::os_is_win32()): + bool success = _fseeki64(file, (long)offset, (int)seek_mode) == 0; + $else: + bool success = libc::fseek(file, (SeekIndex)offset, (CInt)seek_mode) == 0; + $endif; + if (!success) return file_seek_errno()!; +$endif; +} + +fn usz! native_ftell(CFile file) @inline +{ +$if (!env::COMPILER_LIBC_AVAILABLE): + if (native_ftell_fn) return native_ftell_fn(file); + unreachable("Tried to call ftell without support."); +$else: + $if (env::os_is_win32()): + long index = _ftelli64(file); + return index >= 0 ? index : file_seek_errno()!; + $else: + SeekIndex index = libc::ftell(file); + return index >= 0 ? index : file_seek_errno()!; + $endif; +$endif; +} + +fn usz! native_fwrite(CFile file, char[] buffer) @inline +{ +$if (!env::COMPILER_LIBC_AVAILABLE): + if (native_fwrite_fn) return native_fwrite_fn(file, buffer); + unreachable("Tried to call fwrite without support."); +$else: + return libc::fwrite(buffer.ptr, 1, buffer.len, file); +$endif; +} + +fn usz! native_fread(CFile file, char[] buffer) @inline +{ +$if (!env::COMPILER_LIBC_AVAILABLE): + if (native_fread_fn) return native_fread_fn(file, buffer); + unreachable("Tried to call fread without support."); +$else: + return libc::fread(buffer.ptr, 1, buffer.len, file); +$endif; +} + +macro anyerr file_open_errno() @local +{ + switch (libc::errno()) + { + case errno::EACCES: return IoError.NO_PERMISSION; + case errno::EDQUOT: return IoError.OUT_OF_DISK; + case errno::EBADF: return IoError.FILE_NOT_VALID; + case errno::EEXIST: return IoError.ALREADY_EXISTS; + case errno::EINTR: return IoError.INTERRUPTED; + case errno::EFAULT: return IoError.GENERAL_ERROR; + case errno::EISDIR: return IoError.FILE_IS_DIR; + case errno::ELOOP: return IoError.SYMLINK_FAILED; + case errno::EMFILE: return IoError.TOO_MANY_DESCRIPTORS; + case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG; + case errno::ENFILE: return IoError.OUT_OF_DISK; + case errno::ENOTDIR: return IoError.FILE_NOT_DIR; + case errno::ENOENT: return IoError.FILE_NOT_FOUND; + case errno::ENOSPC: return IoError.OUT_OF_DISK; + case errno::ENXIO: return IoError.FILE_NOT_FOUND; + case errno::EOVERFLOW: return IoError.OVERFLOW; + case errno::EROFS: return IoError.READ_ONLY; + case errno::EOPNOTSUPP: return IoError.UNSUPPORTED_OPERATION; + case errno::EIO: return IoError.INCOMPLETE_WRITE; + case errno::EWOULDBLOCK: return IoError.WOULD_BLOCK; + default: return IoError.UNKNOWN_ERROR; + } +} + +macro anyerr file_seek_errno() @local +{ + switch (libc::errno()) + { + case errno::ESPIPE: return IoError.FILE_IS_PIPE; + case errno::EPIPE: return IoError.FILE_IS_PIPE; + case errno::EOVERFLOW: return IoError.OVERFLOW; + case errno::ENXIO: return IoError.FILE_NOT_FOUND; + case errno::ENOSPC: return IoError.OUT_OF_DISK; + case errno::EIO: return IoError.INCOMPLETE_WRITE; + case errno::EINVAL: return IoError.INVALID_POSITION; + case errno::EINTR: return IoError.INTERRUPTED; + case errno::EFBIG: return IoError.OUT_OF_DISK; + case errno::EBADF: return IoError.FILE_NOT_VALID; + case errno::EAGAIN: return IoError.WOULD_BLOCK; + default: return IoError.UNKNOWN_ERROR; + } +} + +// Win functions +$if (env::os_is_win32()): +extern fn void* _wfopen(Char16*, Char16*) @local; +extern fn void* _wfreopen(Char16*, Char16*, CFile) @local; +extern fn int _fseeki64(CFile, long, int) @local; +extern fn long _ftelli64(CFile) @local; +$endif; \ No newline at end of file diff --git a/lib/std/libc/libc.c3 b/lib/std/libc/libc.c3 index 193662d74..a1ef07d4b 100644 --- a/lib/std/libc/libc.c3 +++ b/lib/std/libc/libc.c3 @@ -425,6 +425,7 @@ const Errno ECONNRESET = 54; // Connection reset by peer Macos const Errno ENETDOWN = 50; // Network is down MacOS const Errno ENETUNREACH = 51; // Network is unreachable MacOS const Errno ENETRESET = 52; // Network dropped connection because of reset MacOS +const Errno EOPNOTSUPP = 45; // Operation not supported on transport endpoint $elif (env::OS_TYPE == OsType.WIN32): const Errno EDEADLK = 36; // Resource deadlock would occur Win32 @@ -435,6 +436,7 @@ const Errno ENETDOWN = 116; // Network is down const Errno ECONNRESET = 108; // Connection reset by peer const Errno ENETUNREACH = 118; // Network is unreachable const Errno ENETRESET = 117; // Network dropped connection because of reset +const Errno EOPNOTSUPP = 130; // Operation not supported on transport endpoint $else: const Errno EDEADLK = 35; // Resource deadlock would occur Linux (others?) @@ -445,10 +447,12 @@ const Errno ENETDOWN = 100; // Network is down const Errno ECONNRESET = 104; // Connection reset by peer const Errno ENETUNREACH = 101; // Network is unreachable const Errno ENETRESET = 102; // Network dropped connection because of reset +const Errno EOPNOTSUPP = 95; // Operation not supported on transport endpoint $endif; + /* const Errno ENOLCK = 37; /* No record locks available */ const Errno ENOSYS = 38; /* Function not implemented */ @@ -506,7 +510,6 @@ const Errno EPROTOTYPE = 91; /* Protocol wrong type for socket */ const Errno ENOPROTOOPT = 92; /* Protocol not available */ const Errno EPROTONOSUPPORT = 93; /* Protocol not supported */ const Errno ESOCKTNOSUPPORT = 94; /* Socket type not supported */ -const Errno EOPNOTSUPP = 95; /* Operation not supported on transport endpoint */ const Errno EPFNOSUPPORT = 96; /* Protocol family not supported */ const Errno EAFNOSUPPORT = 97; /* Address family not supported by protocol */ const Errno EADDRINUSE = 98; /* Address already in use */ diff --git a/src/compiler/sema_expr.c b/src/compiler/sema_expr.c index 5f93d1542..c7d95ed62 100644 --- a/src/compiler/sema_expr.c +++ b/src/compiler/sema_expr.c @@ -1715,7 +1715,6 @@ bool sema_expr_analyse_macro_call(SemaContext *context, Expr *call_expr, Expr *s } } param->var.init_expr = args[i]; - VarDeclKind kind = param->var.kind; } Decl **body_params = call_expr->call_expr.body_arguments; diff --git a/src/compiler/sema_stmts.c b/src/compiler/sema_stmts.c index 680f06b42..bf79633cd 100644 --- a/src/compiler/sema_stmts.c +++ b/src/compiler/sema_stmts.c @@ -1881,27 +1881,27 @@ static bool sema_analyse_nextcase_stmt(SemaContext *context, Ast *statement) static inline bool sema_analyse_then_overwrite(SemaContext *context, Ast *statement, AstId replacement) { - statement->ast_kind = AST_NOP_STMT; if (!replacement) { + statement->ast_kind = AST_NOP_STMT; return true; } - AstId current = replacement; Ast *last; + AstId next = statement->next; + *statement = *astptr(replacement); + AstId current = astid(statement); while (1) { Ast *curr_ast = astptr(current); if (!sema_analyse_statement(context, curr_ast)) return false; - current = curr_ast->next; - if (!current) + if (!curr_ast->next) { last = curr_ast; break; } + current = curr_ast->next; } - // NOP and insert after. - last->next = statement->next; - statement->next = replacement; + last->next = next; return true; } diff --git a/src/version.h b/src/version.h index 88abf286c..d03d5a478 100644 --- a/src/version.h +++ b/src/version.h @@ -1 +1 @@ -#define COMPILER_VERSION "0.4.81" \ No newline at end of file +#define COMPILER_VERSION "0.4.82" \ No newline at end of file diff --git a/test/test_suite/bitstruct/bitstruct_be.c3t b/test/test_suite/bitstruct/bitstruct_be.c3t index a960abe75..f6d51af72 100644 --- a/test/test_suite/bitstruct/bitstruct_be.c3t +++ b/test/test_suite/bitstruct/bitstruct_be.c3t @@ -92,114 +92,117 @@ loop.exit: ; preds = %loop.cond store ptr @.str.2, ptr %x4, align 8 %22 = call ptr @std.io.stdout() store ptr %22, ptr %result, align 8 - %23 = call i64 @std.io.File.printn(ptr %retparam5, ptr %result, ptr null, i64 0) - %24 = load ptr, ptr %z, align 8 - store ptr %24, ptr %.anon6, align 8 + %23 = load ptr, ptr %result, align 8 + %24 = call i64 @std.io.File.printn(ptr %retparam5, ptr %23, ptr null, i64 0) + %25 = load ptr, ptr %z, align 8 + store ptr %25, ptr %.anon6, align 8 store i64 0, ptr %.anon7, align 8 br label %loop.cond8 loop.cond8: ; preds = %loop.body10, %loop.exit - %25 = load i64, ptr %.anon7, align 8 - %gt9 = icmp ugt i64 4, %25 + %26 = load i64, ptr %.anon7, align 8 + %gt9 = icmp ugt i64 4, %26 br i1 %gt9, label %loop.body10, label %loop.exit15 loop.body10: ; preds = %loop.cond8 - %26 = load ptr, ptr %.anon6, align 8 - %27 = load i64, ptr %.anon7, align 8 - %28 = getelementptr inbounds [4 x i8], ptr %26, i64 0, i64 %27 - %29 = load i8, ptr %28, align 1 - store i8 %29, ptr %d11, align 1 - %30 = insertvalue %variant undef, ptr %d11, 0 - %31 = insertvalue %variant %30, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %32 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0 - store %variant %31, ptr %32, align 16 - %33 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1) - %34 = load i64, ptr %.anon7, align 8 - %add14 = add i64 %34, 1 + %27 = load ptr, ptr %.anon6, align 8 + %28 = load i64, ptr %.anon7, align 8 + %29 = getelementptr inbounds [4 x i8], ptr %27, i64 0, i64 %28 + %30 = load i8, ptr %29, align 1 + store i8 %30, ptr %d11, align 1 + %31 = insertvalue %variant undef, ptr %d11, 0 + %32 = insertvalue %variant %31, i64 ptrtoint (ptr @"$ct.char" to i64), 1 + %33 = getelementptr inbounds [1 x %variant], ptr %varargslots13, i64 0, i64 0 + store %variant %32, ptr %33, align 16 + %34 = call i64 @std.io.printf(ptr %retparam12, ptr @.str.3, i64 3, ptr %varargslots13, i64 1) + %35 = load i64, ptr %.anon7, align 8 + %add14 = add i64 %35, 1 store i64 %add14, ptr %.anon7, align 8 br label %loop.cond8 loop.exit15: ; preds = %loop.cond8 store ptr @.str.4, ptr %x16, align 8 - %35 = call ptr @std.io.stdout() - store ptr %35, ptr %result18, align 8 - %36 = call i64 @std.io.File.printn(ptr %retparam17, ptr %result18, ptr null, i64 0) - %37 = load i32, ptr %abc, align 4 - %38 = call i32 @llvm.bswap.i32(i32 %37) - %39 = and i32 65535, %38 - %ztrunc = trunc i32 %39 to i16 + %36 = call ptr @std.io.stdout() + store ptr %36, ptr %result18, align 8 + %37 = load ptr, ptr %result18, align 8 + %38 = call i64 @std.io.File.printn(ptr %retparam17, ptr %37, ptr null, i64 0) + %39 = load i32, ptr %abc, align 4 + %40 = call i32 @llvm.bswap.i32(i32 %39) + %41 = and i32 65535, %40 + %ztrunc = trunc i32 %41 to i16 store i16 %ztrunc, ptr %taddr21, align 2 - %40 = insertvalue %variant undef, ptr %taddr21, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 - %42 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0 - store %variant %41, ptr %42, align 16 - %43 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1) - %44 = load i32, ptr %abc, align 4 - %45 = call i32 @llvm.bswap.i32(i32 %44) - %46 = and i32 %45, -65536 - %47 = or i32 %46, 4660 - %48 = call i32 @llvm.bswap.i32(i32 %47) - store i32 %48, ptr %abc, align 4 - %49 = load i32, ptr %abc, align 4 + %42 = insertvalue %variant undef, ptr %taddr21, 0 + %43 = insertvalue %variant %42, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 + %44 = getelementptr inbounds [1 x %variant], ptr %varargslots20, i64 0, i64 0 + store %variant %43, ptr %44, align 16 + %45 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.5, i64 10, ptr %varargslots20, i64 1) + %46 = load i32, ptr %abc, align 4 + %47 = call i32 @llvm.bswap.i32(i32 %46) + %48 = and i32 %47, -65536 + %49 = or i32 %48, 4660 %50 = call i32 @llvm.bswap.i32(i32 %49) - %51 = and i32 %50, 65535 - %52 = or i32 %51, 1450704896 - %53 = call i32 @llvm.bswap.i32(i32 %52) - store i32 %53, ptr %abc, align 4 - %54 = load i32, ptr %abc, align 4 + store i32 %50, ptr %abc, align 4 + %51 = load i32, ptr %abc, align 4 + %52 = call i32 @llvm.bswap.i32(i32 %51) + %53 = and i32 %52, 65535 + %54 = or i32 %53, 1450704896 %55 = call i32 @llvm.bswap.i32(i32 %54) - %56 = and i32 65535, %55 - %ztrunc24 = trunc i32 %56 to i16 + store i32 %55, ptr %abc, align 4 + %56 = load i32, ptr %abc, align 4 + %57 = call i32 @llvm.bswap.i32(i32 %56) + %58 = and i32 65535, %57 + %ztrunc24 = trunc i32 %58 to i16 store i16 %ztrunc24, ptr %taddr25, align 2 - %57 = insertvalue %variant undef, ptr %taddr25, 0 - %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 - %59 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0 - store %variant %58, ptr %59, align 16 - %60 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1) - %61 = load ptr, ptr %z, align 8 - store ptr %61, ptr %.anon26, align 8 + %59 = insertvalue %variant undef, ptr %taddr25, 0 + %60 = insertvalue %variant %59, i64 ptrtoint (ptr @"$ct.ushort" to i64), 1 + %61 = getelementptr inbounds [1 x %variant], ptr %varargslots23, i64 0, i64 0 + store %variant %60, ptr %61, align 16 + %62 = call i64 @std.io.printfn(ptr %retparam22, ptr @.str.6, i64 12, ptr %varargslots23, i64 1) + %63 = load ptr, ptr %z, align 8 + store ptr %63, ptr %.anon26, align 8 store i64 0, ptr %.anon27, align 8 br label %loop.cond28 loop.cond28: ; preds = %loop.body30, %loop.exit15 - %62 = load i64, ptr %.anon27, align 8 - %gt29 = icmp ugt i64 4, %62 + %64 = load i64, ptr %.anon27, align 8 + %gt29 = icmp ugt i64 4, %64 br i1 %gt29, label %loop.body30, label %loop.exit35 loop.body30: ; preds = %loop.cond28 - %63 = load ptr, ptr %.anon26, align 8 - %64 = load i64, ptr %.anon27, align 8 - %65 = getelementptr inbounds [4 x i8], ptr %63, i64 0, i64 %64 - %66 = load i8, ptr %65, align 1 - store i8 %66, ptr %d31, align 1 - %67 = insertvalue %variant undef, ptr %d31, 0 - %68 = insertvalue %variant %67, i64 ptrtoint (ptr @"$ct.char" to i64), 1 - %69 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0 - store %variant %68, ptr %69, align 16 - %70 = call i64 @std.io.printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1) - %71 = load i64, ptr %.anon27, align 8 - %add34 = add i64 %71, 1 + %65 = load ptr, ptr %.anon26, align 8 + %66 = load i64, ptr %.anon27, align 8 + %67 = getelementptr inbounds [4 x i8], ptr %65, i64 0, i64 %66 + %68 = load i8, ptr %67, align 1 + store i8 %68, ptr %d31, align 1 + %69 = insertvalue %variant undef, ptr %d31, 0 + %70 = insertvalue %variant %69, i64 ptrtoint (ptr @"$ct.char" to i64), 1 + %71 = getelementptr inbounds [1 x %variant], ptr %varargslots33, i64 0, i64 0 + store %variant %70, ptr %71, align 16 + %72 = call i64 @std.io.printf(ptr %retparam32, ptr @.str.7, i64 3, ptr %varargslots33, i64 1) + %73 = load i64, ptr %.anon27, align 8 + %add34 = add i64 %73, 1 store i64 %add34, ptr %.anon27, align 8 br label %loop.cond28 loop.exit35: ; preds = %loop.cond28 store ptr @.str.8, ptr %x36, align 8 - %72 = call ptr @std.io.stdout() - store ptr %72, ptr %result38, align 8 - %73 = call i64 @std.io.File.printn(ptr %retparam37, ptr %result38, ptr null, i64 0) + %74 = call ptr @std.io.stdout() + store ptr %74, ptr %result38, align 8 + %75 = load ptr, ptr %result38, align 8 + %76 = call i64 @std.io.File.printn(ptr %retparam37, ptr %75, ptr null, i64 0) store i32 0, ptr %y, align 4 - %74 = load i32, ptr %y, align 4 + %77 = load i32, ptr %y, align 4 store i32 123, ptr %y, align 4 - %75 = insertvalue %variant undef, ptr %y, 0 - %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %77 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0 - store %variant %76, ptr %77, align 16 - %78 = load i32, ptr %y, align 4 - store i32 %78, ptr %taddr41, align 4 - %79 = insertvalue %variant undef, ptr %taddr41, 0 - %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - %81 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1 - store %variant %80, ptr %81, align 16 - %82 = call i64 @std.io.printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2) + %78 = insertvalue %variant undef, ptr %y, 0 + %79 = insertvalue %variant %78, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %80 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0 + store %variant %79, ptr %80, align 16 + %81 = load i32, ptr %y, align 4 + store i32 %81, ptr %taddr41, align 4 + %82 = insertvalue %variant undef, ptr %taddr41, 0 + %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + %84 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1 + store %variant %83, ptr %84, align 16 + %85 = call i64 @std.io.printf(ptr %retparam39, ptr @.str.9, i64 18, ptr %varargslots40, i64 2) ret void } \ No newline at end of file diff --git a/test/test_suite/compile_time/ct_builtin_time_date.c3t b/test/test_suite/compile_time/ct_builtin_time_date.c3t index ae04e40d5..3b9d49b5d 100644 --- a/test/test_suite/compile_time/ct_builtin_time_date.c3t +++ b/test/test_suite/compile_time/ct_builtin_time_date.c3t @@ -58,44 +58,46 @@ entry: %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 2, ptr %varargslots, i64 1) %gt = icmp sgt i32 %0, 0 br i1 %gt, label %if.then, label %if.exit - if.then: ; preds = %entry %sub = sub i32 %0, 1 call void @test.test(i32 %sub) br label %if.exit - if.exit: ; preds = %if.then, %entry store ptr @.str.1, ptr %x, align 8 %5 = call ptr @std.io.stdout() store ptr %5, ptr %result, align 8 - %6 = load ptr, ptr %x, align 8 - %7 = call i64 @std.io.File.printn(ptr %retparam1, ptr %result, ptr %6, i64 8) + %6 = load ptr, ptr %result, align 8 + %7 = load ptr, ptr %x, align 8 + %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %6, ptr %7, i64 8) store ptr @.str.2, ptr %x2, align 8 - %8 = call ptr @std.io.stdout() - store ptr %8, ptr %result4, align 8 - %9 = load ptr, ptr %x2, align 8 - %10 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %9, i64 10) + %9 = call ptr @std.io.stdout() + store ptr %9, ptr %result4, align 8 + %10 = load ptr, ptr %result4, align 8 + %11 = load ptr, ptr %x2, align 8 + %12 = call i64 @std.io.File.printn(ptr %retparam3, ptr %10, ptr %11, i64 10) store i64 14, ptr %taddr7, align 8 - %11 = insertvalue %variant undef, ptr %taddr7, 0 - %12 = insertvalue %variant %11, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %13 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0 - store %variant %12, ptr %13, align 16 - %14 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1) + %13 = insertvalue %variant undef, ptr %taddr7, 0 + %14 = insertvalue %variant %13, i64 ptrtoint (ptr @"$ct.long" to i64), 1 + %15 = getelementptr inbounds [1 x %variant], ptr %varargslots6, i64 0, i64 0 + store %variant %14, ptr %15, align 16 + %16 = call i64 @std.io.printfn(ptr %retparam5, ptr @.str.3, i64 2, ptr %varargslots6, i64 1) store i64 6, ptr %taddr10, align 8 - %15 = insertvalue %variant undef, ptr %taddr10, 0 - %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"$ct.long" to i64), 1 - %17 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0 - store %variant %16, ptr %17, align 16 - %18 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1) + %17 = insertvalue %variant undef, ptr %taddr10, 0 + %18 = insertvalue %variant %17, i64 ptrtoint (ptr @"$ct.long" to i64), 1 + %19 = getelementptr inbounds [1 x %variant], ptr %varargslots9, i64 0, i64 0 + store %variant %18, ptr %19, align 16 + %20 = call i64 @std.io.printfn(ptr %retparam8, ptr @.str.4, i64 2, ptr %varargslots9, i64 1) store ptr @.str.5, ptr %x11, align 8 - %19 = call ptr @std.io.stdout() - store ptr %19, ptr %result13, align 8 - %20 = load ptr, ptr %x11, align 8 - %21 = call i64 @std.io.File.printn(ptr %retparam12, ptr %result13, ptr %20, i64 23) + %21 = call ptr @std.io.stdout() + store ptr %21, ptr %result13, align 8 + %22 = load ptr, ptr %result13, align 8 + %23 = load ptr, ptr %x11, align 8 + %24 = call i64 @std.io.File.printn(ptr %retparam12, ptr %22, ptr %23, i64 23) store ptr @.str.6, ptr %x14, align 8 - %22 = call ptr @std.io.stdout() - store ptr %22, ptr %result16, align 8 - %23 = load ptr, ptr %x14, align 8 - %24 = call i64 @std.io.File.printn(ptr %retparam15, ptr %result16, ptr %23, i64 4) + %25 = call ptr @std.io.stdout() + store ptr %25, ptr %result16, align 8 + %26 = load ptr, ptr %result16, align 8 + %27 = load ptr, ptr %x14, align 8 + %28 = call i64 @std.io.File.printn(ptr %retparam15, ptr %26, ptr %27, i64 4) ret void } \ No newline at end of file diff --git a/test/test_suite/compile_time/ct_memberof.c3t b/test/test_suite/compile_time/ct_memberof.c3t index 71d1995f7..a06e136e8 100644 --- a/test/test_suite/compile_time/ct_memberof.c3t +++ b/test/test_suite/compile_time/ct_memberof.c3t @@ -190,166 +190,173 @@ entry: store ptr @.str, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 - %2 = load ptr, ptr %x, align 8 - %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %2, i64 3) + %2 = load ptr, ptr %result, align 8 + %3 = load ptr, ptr %x, align 8 + %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 3) store ptr @.str.10, ptr %x1, align 8 - %4 = call ptr @std.io.stdout() - store ptr %4, ptr %result3, align 8 - %5 = load ptr, ptr %x1, align 8 - %6 = call i64 @std.io.File.printn(ptr %retparam2, ptr %result3, ptr %5, i64 3) + %5 = call ptr @std.io.stdout() + store ptr %5, ptr %result3, align 8 + %6 = load ptr, ptr %result3, align 8 + %7 = load ptr, ptr %x1, align 8 + %8 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr %7, i64 3) store ptr @.str.11, ptr %x4, align 8 - %7 = call ptr @std.io.stdout() - store ptr %7, ptr %result6, align 8 - %8 = load ptr, ptr %x4, align 8 - %9 = call i64 @std.io.File.printn(ptr %retparam5, ptr %result6, ptr %8, i64 6) + %9 = call ptr @std.io.stdout() + store ptr %9, ptr %result6, align 8 + %10 = load ptr, ptr %result6, align 8 + %11 = load ptr, ptr %x4, align 8 + %12 = call i64 @std.io.File.printn(ptr %retparam5, ptr %10, ptr %11, i64 6) store ptr @.str.12, ptr %x7, align 8 - %10 = call ptr @std.io.stdout() - store ptr %10, ptr %result9, align 8 - %11 = load ptr, ptr %x7, align 8 - %12 = call i64 @std.io.File.printn(ptr %retparam8, ptr %result9, ptr %11, i64 6) - store ptr @.str.13, ptr %x10, align 8 %13 = call ptr @std.io.stdout() - store ptr %13, ptr %result12, align 8 - %14 = load ptr, ptr %x10, align 8 - %15 = call i64 @std.io.File.printn(ptr %retparam11, ptr %result12, ptr %14, i64 9) + store ptr %13, ptr %result9, align 8 + %14 = load ptr, ptr %result9, align 8 + %15 = load ptr, ptr %x7, align 8 + %16 = call i64 @std.io.File.printn(ptr %retparam8, ptr %14, ptr %15, i64 6) + store ptr @.str.13, ptr %x10, align 8 + %17 = call ptr @std.io.stdout() + store ptr %17, ptr %result12, align 8 + %18 = load ptr, ptr %result12, align 8 + %19 = load ptr, ptr %x10, align 8 + %20 = call i64 @std.io.File.printn(ptr %retparam11, ptr %18, ptr %19, i64 9) store ptr @.str.14, ptr %x13, align 8 - %16 = call ptr @std.io.stdout() - store ptr %16, ptr %result15, align 8 - %17 = load ptr, ptr %x13, align 8 - %18 = call i64 @std.io.File.printn(ptr %retparam14, ptr %result15, ptr %17, i64 4) + %21 = call ptr @std.io.stdout() + store ptr %21, ptr %result15, align 8 + %22 = load ptr, ptr %result15, align 8 + %23 = load ptr, ptr %x13, align 8 + %24 = call i64 @std.io.File.printn(ptr %retparam14, ptr %22, ptr %23, i64 4) store ptr @.str.15, ptr %x16, align 8 - %19 = call ptr @std.io.stdout() - store ptr %19, ptr %result18, align 8 - %20 = load ptr, ptr %x16, align 8 - %21 = call i64 @std.io.File.printn(ptr %retparam17, ptr %result18, ptr %20, i64 3) + %25 = call ptr @std.io.stdout() + store ptr %25, ptr %result18, align 8 + %26 = load ptr, ptr %result18, align 8 + %27 = load ptr, ptr %x16, align 8 + %28 = call i64 @std.io.File.printn(ptr %retparam17, ptr %26, ptr %27, i64 3) store ptr @.str.17, ptr %taddr, align 8 - %22 = insertvalue %variant undef, ptr %taddr, 0 - %23 = insertvalue %variant %22, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 - %24 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %23, ptr %24, align 16 - %25 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1) - store ptr @.str.19, ptr %taddr22, align 8 - %26 = insertvalue %variant undef, ptr %taddr22, 0 - %27 = insertvalue %variant %26, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 - %28 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0 - store %variant %27, ptr %28, align 16 - store ptr @.str.20, ptr %taddr23, align 8 - %29 = insertvalue %variant undef, ptr %taddr23, 0 + %29 = insertvalue %variant undef, ptr %taddr, 0 %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 - %31 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1 + %31 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 store %variant %30, ptr %31, align 16 - %32 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2) - store ptr @.str.22, ptr %taddr26, align 8 - %33 = insertvalue %variant undef, ptr %taddr26, 0 - %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1 - %35 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0 + %32 = call i64 @std.io.printfn(ptr %retparam19, ptr @.str.16, i64 8, ptr %varargslots, i64 1) + store ptr @.str.19, ptr %taddr22, align 8 + %33 = insertvalue %variant undef, ptr %taddr22, 0 + %34 = insertvalue %variant %33, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 + %35 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 0 store %variant %34, ptr %35, align 16 - store ptr @.str.23, ptr %taddr27, align 8 - %36 = insertvalue %variant undef, ptr %taddr27, 0 - %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1 - %38 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1 + store ptr @.str.20, ptr %taddr23, align 8 + %36 = insertvalue %variant undef, ptr %taddr23, 0 + %37 = insertvalue %variant %36, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 + %38 = getelementptr inbounds [2 x %variant], ptr %varargslots21, i64 0, i64 1 store %variant %37, ptr %38, align 16 - %39 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2) - store ptr @.str.25, ptr %taddr30, align 8 - %40 = insertvalue %variant undef, ptr %taddr30, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1 - %42 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0 + %39 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.18, i64 6, ptr %varargslots21, i64 2) + store ptr @.str.22, ptr %taddr26, align 8 + %40 = insertvalue %variant undef, ptr %taddr26, 0 + %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1 + %42 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 0 store %variant %41, ptr %42, align 16 - store ptr @.str.26, ptr %taddr31, align 8 - %43 = insertvalue %variant undef, ptr %taddr31, 0 - %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1 - %45 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1 + store ptr @.str.23, ptr %taddr27, align 8 + %43 = insertvalue %variant undef, ptr %taddr27, 0 + %44 = insertvalue %variant %43, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1 + %45 = getelementptr inbounds [2 x %variant], ptr %varargslots25, i64 0, i64 1 store %variant %44, ptr %45, align 16 - %46 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2) - store ptr @.str.28, ptr %taddr34, align 8 - %47 = insertvalue %variant undef, ptr %taddr34, 0 - %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 - %49 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0 + %46 = call i64 @std.io.printfn(ptr %retparam24, ptr @.str.21, i64 6, ptr %varargslots25, i64 2) + store ptr @.str.25, ptr %taddr30, align 8 + %47 = insertvalue %variant undef, ptr %taddr30, 0 + %48 = insertvalue %variant %47, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1 + %49 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 0 store %variant %48, ptr %49, align 16 - store ptr @.str.29, ptr %taddr35, align 8 - %50 = insertvalue %variant undef, ptr %taddr35, 0 - %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1 - %52 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1 + store ptr @.str.26, ptr %taddr31, align 8 + %50 = insertvalue %variant undef, ptr %taddr31, 0 + %51 = insertvalue %variant %50, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1 + %52 = getelementptr inbounds [2 x %variant], ptr %varargslots29, i64 0, i64 1 store %variant %51, ptr %52, align 16 - %53 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2) - store ptr @.str.31, ptr %taddr38, align 8 - %54 = insertvalue %variant undef, ptr %taddr38, 0 - %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 - %56 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0 + %53 = call i64 @std.io.printfn(ptr %retparam28, ptr @.str.24, i64 6, ptr %varargslots29, i64 2) + store ptr @.str.28, ptr %taddr34, align 8 + %54 = insertvalue %variant undef, ptr %taddr34, 0 + %55 = insertvalue %variant %54, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 + %56 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 0 store %variant %55, ptr %56, align 16 - %57 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1) - store ptr @.str.33, ptr %taddr41, align 8 - %58 = insertvalue %variant undef, ptr %taddr41, 0 - %59 = insertvalue %variant %58, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 - %60 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0 - store %variant %59, ptr %60, align 16 - store ptr @.str.34, ptr %taddr42, align 8 - %61 = insertvalue %variant undef, ptr %taddr42, 0 - %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1 - %63 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1 + store ptr @.str.29, ptr %taddr35, align 8 + %57 = insertvalue %variant undef, ptr %taddr35, 0 + %58 = insertvalue %variant %57, i64 ptrtoint (ptr @"$ct.p$a6$char" to i64), 1 + %59 = getelementptr inbounds [2 x %variant], ptr %varargslots33, i64 0, i64 1 + store %variant %58, ptr %59, align 16 + %60 = call i64 @std.io.printfn(ptr %retparam32, ptr @.str.27, i64 6, ptr %varargslots33, i64 2) + store ptr @.str.31, ptr %taddr38, align 8 + %61 = insertvalue %variant undef, ptr %taddr38, 0 + %62 = insertvalue %variant %61, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 + %63 = getelementptr inbounds [1 x %variant], ptr %varargslots37, i64 0, i64 0 store %variant %62, ptr %63, align 16 - %64 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2) - store ptr @.str.36, ptr %taddr45, align 8 - %65 = insertvalue %variant undef, ptr %taddr45, 0 + %64 = call i64 @std.io.printfn(ptr %retparam36, ptr @.str.30, i64 8, ptr %varargslots37, i64 1) + store ptr @.str.33, ptr %taddr41, align 8 + %65 = insertvalue %variant undef, ptr %taddr41, 0 %66 = insertvalue %variant %65, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 - %67 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0 + %67 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 0 store %variant %66, ptr %67, align 16 - store ptr @.str.37, ptr %taddr46, align 8 - %68 = insertvalue %variant undef, ptr %taddr46, 0 - %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1 - %70 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1 + store ptr @.str.34, ptr %taddr42, align 8 + %68 = insertvalue %variant undef, ptr %taddr42, 0 + %69 = insertvalue %variant %68, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1 + %70 = getelementptr inbounds [2 x %variant], ptr %varargslots40, i64 0, i64 1 store %variant %69, ptr %70, align 16 - %71 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2) - store ptr @.str.39, ptr %taddr49, align 8 - %72 = insertvalue %variant undef, ptr %taddr49, 0 - %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1 - %74 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0 + %71 = call i64 @std.io.printfn(ptr %retparam39, ptr @.str.32, i64 6, ptr %varargslots40, i64 2) + store ptr @.str.36, ptr %taddr45, align 8 + %72 = insertvalue %variant undef, ptr %taddr45, 0 + %73 = insertvalue %variant %72, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 + %74 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 0 store %variant %73, ptr %74, align 16 - store ptr @.str.40, ptr %taddr50, align 8 - %75 = insertvalue %variant undef, ptr %taddr50, 0 + store ptr @.str.37, ptr %taddr46, align 8 + %75 = insertvalue %variant undef, ptr %taddr46, 0 %76 = insertvalue %variant %75, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1 - %77 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1 + %77 = getelementptr inbounds [2 x %variant], ptr %varargslots44, i64 0, i64 1 store %variant %76, ptr %77, align 16 - %78 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2) - store ptr @.str.42, ptr %taddr53, align 8 - %79 = insertvalue %variant undef, ptr %taddr53, 0 - %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 - %81 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0 + %78 = call i64 @std.io.printfn(ptr %retparam43, ptr @.str.35, i64 6, ptr %varargslots44, i64 2) + store ptr @.str.39, ptr %taddr49, align 8 + %79 = insertvalue %variant undef, ptr %taddr49, 0 + %80 = insertvalue %variant %79, i64 ptrtoint (ptr @"$ct.p$a0$char" to i64), 1 + %81 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 0 store %variant %80, ptr %81, align 16 - store ptr @.str.43, ptr %taddr54, align 8 - %82 = insertvalue %variant undef, ptr %taddr54, 0 - %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 - %84 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1 + store ptr @.str.40, ptr %taddr50, align 8 + %82 = insertvalue %variant undef, ptr %taddr50, 0 + %83 = insertvalue %variant %82, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1 + %84 = getelementptr inbounds [2 x %variant], ptr %varargslots48, i64 0, i64 1 store %variant %83, ptr %84, align 16 - %85 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2) - store ptr @.str.45, ptr %taddr57, align 8 - %86 = insertvalue %variant undef, ptr %taddr57, 0 - %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1 - %88 = getelementptr inbounds [1 x %variant], ptr %varargslots56, i64 0, i64 0 + %85 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.38, i64 6, ptr %varargslots48, i64 2) + store ptr @.str.42, ptr %taddr53, align 8 + %86 = insertvalue %variant undef, ptr %taddr53, 0 + %87 = insertvalue %variant %86, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 + %88 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 0 store %variant %87, ptr %88, align 16 - %89 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1) - store ptr @.str.47, ptr %taddr60, align 8 - %90 = insertvalue %variant undef, ptr %taddr60, 0 - %91 = insertvalue %variant %90, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 - %92 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 0 - store %variant %91, ptr %92, align 16 - store ptr @.str.48, ptr %taddr61, align 8 - %93 = insertvalue %variant undef, ptr %taddr61, 0 - %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 - %95 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 1 + store ptr @.str.43, ptr %taddr54, align 8 + %89 = insertvalue %variant undef, ptr %taddr54, 0 + %90 = insertvalue %variant %89, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 + %91 = getelementptr inbounds [2 x %variant], ptr %varargslots52, i64 0, i64 1 + store %variant %90, ptr %91, align 16 + %92 = call i64 @std.io.printfn(ptr %retparam51, ptr @.str.41, i64 6, ptr %varargslots52, i64 2) + store ptr @.str.45, ptr %taddr57, align 8 + %93 = insertvalue %variant undef, ptr %taddr57, 0 + %94 = insertvalue %variant %93, i64 ptrtoint (ptr @"$ct.p$a4$char" to i64), 1 + %95 = getelementptr inbounds [1 x %variant], ptr %varargslots56, i64 0, i64 0 store %variant %94, ptr %95, align 16 - %96 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2) - store ptr @.str.50, ptr %taddr64, align 8 - %97 = insertvalue %variant undef, ptr %taddr64, 0 + %96 = call i64 @std.io.printfn(ptr %retparam55, ptr @.str.44, i64 8, ptr %varargslots56, i64 1) + store ptr @.str.47, ptr %taddr60, align 8 + %97 = insertvalue %variant undef, ptr %taddr60, 0 %98 = insertvalue %variant %97, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 - %99 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0 + %99 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 0 store %variant %98, ptr %99, align 16 - store ptr @.str.51, ptr %taddr65, align 8 - %100 = insertvalue %variant undef, ptr %taddr65, 0 - %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1 - %102 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1 + store ptr @.str.48, ptr %taddr61, align 8 + %100 = insertvalue %variant undef, ptr %taddr61, 0 + %101 = insertvalue %variant %100, i64 ptrtoint (ptr @"$ct.p$a3$char" to i64), 1 + %102 = getelementptr inbounds [2 x %variant], ptr %varargslots59, i64 0, i64 1 store %variant %101, ptr %102, align 16 - %103 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2) + %103 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.46, i64 6, ptr %varargslots59, i64 2) + store ptr @.str.50, ptr %taddr64, align 8 + %104 = insertvalue %variant undef, ptr %taddr64, 0 + %105 = insertvalue %variant %104, i64 ptrtoint (ptr @"$ct.p$a1$char" to i64), 1 + %106 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 0 + store %variant %105, ptr %106, align 16 + store ptr @.str.51, ptr %taddr65, align 8 + %107 = insertvalue %variant undef, ptr %taddr65, 0 + %108 = insertvalue %variant %107, i64 ptrtoint (ptr @"$ct.p$a5$char" to i64), 1 + %109 = getelementptr inbounds [2 x %variant], ptr %varargslots63, i64 0, i64 1 + store %variant %108, ptr %109, align 16 + %110 = call i64 @std.io.printfn(ptr %retparam62, ptr @.str.49, i64 6, ptr %varargslots63, i64 2) ret void } diff --git a/test/test_suite/errors/general_error_regression.c3t b/test/test_suite/errors/general_error_regression.c3t index d9a167ba4..cdaa4fb54 100644 --- a/test/test_suite/errors/general_error_regression.c3t +++ b/test/test_suite/errors/general_error_regression.c3t @@ -80,11 +80,13 @@ entry: store ptr @.str.12, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 - %2 = load ptr, ptr %x, align 8 - %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %2, i64 14) + %2 = load ptr, ptr %result, align 8 + %3 = load ptr, ptr %x, align 8 + %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 14) ret void } +; Function Attrs: nounwind define void @foo.Bar.hello(ptr %0) #0 { entry: %x = alloca ptr, align 8 @@ -93,11 +95,13 @@ entry: store ptr @.str.13, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 - %2 = load ptr, ptr %x, align 8 - %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %2, i64 14) + %2 = load ptr, ptr %result, align 8 + %3 = load ptr, ptr %x, align 8 + %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 14) ret void } +; Function Attrs: nounwind define void @foo.MyEnum.hello(ptr %0) #0 { entry: %x = alloca ptr, align 8 @@ -106,11 +110,13 @@ entry: store ptr @.str.14, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 - %2 = load ptr, ptr %x, align 8 - %3 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %2, i64 17) + %2 = load ptr, ptr %result, align 8 + %3 = load ptr, ptr %x, align 8 + %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %2, ptr %3, i64 17) ret void } +; Function Attrs: nounwind define void @foo.main() #0 { entry: %f = alloca i64, align 8 diff --git a/test/test_suite/errors/or_and_rethrow.c3t b/test/test_suite/errors/or_and_rethrow.c3t index 339011243..8b018ef46 100644 --- a/test/test_suite/errors/or_and_rethrow.c3t +++ b/test/test_suite/errors/or_and_rethrow.c3t @@ -89,16 +89,18 @@ if.then: ; preds = %or.phi store ptr @.str.2, ptr %x, align 8 %6 = call ptr @std.io.stdout() store ptr %6, ptr %result, align 8 - %7 = load ptr, ptr %x, align 8 - %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %result, ptr %7, i64 3) + %7 = load ptr, ptr %result, align 8 + %8 = load ptr, ptr %x, align 8 + %9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %8, i64 3) br label %if.exit if.exit: ; preds = %if.then store ptr @.str.3, ptr %x2, align 8 - %9 = call ptr @std.io.stdout() - store ptr %9, ptr %result4, align 8 - %10 = load ptr, ptr %x2, align 8 - %11 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %10, i64 9) + %10 = call ptr @std.io.stdout() + store ptr %10, ptr %result4, align 8 + %11 = load ptr, ptr %result4, align 8 + %12 = load ptr, ptr %x2, align 8 + %13 = call i64 @std.io.File.printn(ptr %retparam3, ptr %11, ptr %12, i64 9) store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var5, align 8 br label %opt_block_cleanup7 @@ -107,15 +109,16 @@ opt_block_cleanup7: ; preds = %if.exit br label %guard_block8 guard_block8: ; preds = %opt_block_cleanup7 - %12 = load i64, ptr %error_var5, align 8 - ret i64 %12 + %14 = load i64, ptr %error_var5, align 8 + ret i64 %14 if.exit13: ; No predecessors! store ptr @.str.5, ptr %x14, align 8 - %13 = call ptr @std.io.stdout() - store ptr %13, ptr %result16, align 8 - %14 = load ptr, ptr %x14, align 8 - %15 = call i64 @std.io.File.printn(ptr %retparam15, ptr %result16, ptr %14, i64 7) + %15 = call ptr @std.io.stdout() + store ptr %15, ptr %result16, align 8 + %16 = load ptr, ptr %result16, align 8 + %17 = load ptr, ptr %x14, align 8 + %18 = call i64 @std.io.File.printn(ptr %retparam15, ptr %16, ptr %17, i64 7) ret i64 0 } @@ -164,8 +167,9 @@ if.exit: ; preds = %and.phi store ptr @.str.7, ptr %x, align 8 %6 = call ptr @std.io.stdout() store ptr %6, ptr %result, align 8 - %7 = load ptr, ptr %x, align 8 - %8 = call i64 @std.io.File.printn(ptr %retparam1, ptr %result, ptr %7, i64 9) + %7 = load ptr, ptr %result, align 8 + %8 = load ptr, ptr %x, align 8 + %9 = call i64 @std.io.File.printn(ptr %retparam1, ptr %7, ptr %8, i64 9) store i64 ptrtoint (ptr @"foo.Foo$ABC" to i64), ptr %error_var2, align 8 br label %opt_block_cleanup4 @@ -174,15 +178,16 @@ opt_block_cleanup4: ; preds = %if.exit br label %guard_block5 guard_block5: ; preds = %opt_block_cleanup4 - %9 = load i64, ptr %error_var2, align 8 - ret i64 %9 + %10 = load i64, ptr %error_var2, align 8 + ret i64 %10 if.exit6: ; No predecessors! store ptr @.str.8, ptr %x7, align 8 - %10 = call ptr @std.io.stdout() - store ptr %10, ptr %result9, align 8 - %11 = load ptr, ptr %x7, align 8 - %12 = call i64 @std.io.File.printn(ptr %retparam8, ptr %result9, ptr %11, i64 7) + %11 = call ptr @std.io.stdout() + store ptr %11, ptr %result9, align 8 + %12 = load ptr, ptr %result9, align 8 + %13 = load ptr, ptr %x7, align 8 + %14 = call i64 @std.io.File.printn(ptr %retparam8, ptr %12, ptr %13, i64 7) ret i64 0 } diff --git a/test/test_suite/from_docs/examples_defer.c3t b/test/test_suite/from_docs/examples_defer.c3t index 11144d03a..fc7845a37 100644 --- a/test/test_suite/from_docs/examples_defer.c3t +++ b/test/test_suite/from_docs/examples_defer.c3t @@ -32,12 +32,14 @@ if.then: ; preds = %entry store ptr @.str, ptr %x, align 8 %1 = call ptr @std.io.stdout() store ptr %1, ptr %result, align 8 - %2 = load ptr, ptr %x, align 8 - %3 = call i64 @std.io.File.print(ptr %retparam, ptr %result, ptr %2, i64 1) + %2 = load ptr, ptr %result, align 8 + %3 = load ptr, ptr %x, align 8 + %4 = call i64 @std.io.File.print(ptr %retparam, ptr %2, ptr %3, i64 1) store ptr @.str.1, ptr %x1, align 8 - %4 = call ptr @std.io.stdout() - store ptr %4, ptr %result3, align 8 - %5 = call i64 @std.io.File.printn(ptr %retparam2, ptr %result3, ptr null, i64 0) + %5 = call ptr @std.io.stdout() + store ptr %5, ptr %result3, align 8 + %6 = load ptr, ptr %result3, align 8 + %7 = call i64 @std.io.File.printn(ptr %retparam2, ptr %6, ptr null, i64 0) ret void if.exit: ; preds = %entry @@ -46,41 +48,48 @@ if.exit: ; preds = %entry if.then5: ; preds = %if.exit store ptr @.str.2, ptr %x6, align 8 - %6 = call ptr @std.io.stdout() - store ptr %6, ptr %result8, align 8 - %7 = load ptr, ptr %x6, align 8 - %8 = call i64 @std.io.File.print(ptr %retparam7, ptr %result8, ptr %7, i64 1) + %8 = call ptr @std.io.stdout() + store ptr %8, ptr %result8, align 8 + %9 = load ptr, ptr %result8, align 8 + %10 = load ptr, ptr %x6, align 8 + %11 = call i64 @std.io.File.print(ptr %retparam7, ptr %9, ptr %10, i64 1) store ptr @.str.3, ptr %x9, align 8 - %9 = call ptr @std.io.stdout() - store ptr %9, ptr %result11, align 8 - %10 = load ptr, ptr %x9, align 8 - %11 = call i64 @std.io.File.print(ptr %retparam10, ptr %result11, ptr %10, i64 1) - store ptr @.str.4, ptr %x12, align 8 %12 = call ptr @std.io.stdout() - store ptr %12, ptr %result14, align 8 - %13 = call i64 @std.io.File.printn(ptr %retparam13, ptr %result14, ptr null, i64 0) + store ptr %12, ptr %result11, align 8 + %13 = load ptr, ptr %result11, align 8 + %14 = load ptr, ptr %x9, align 8 + %15 = call i64 @std.io.File.print(ptr %retparam10, ptr %13, ptr %14, i64 1) + store ptr @.str.4, ptr %x12, align 8 + %16 = call ptr @std.io.stdout() + store ptr %16, ptr %result14, align 8 + %17 = load ptr, ptr %result14, align 8 + %18 = call i64 @std.io.File.printn(ptr %retparam13, ptr %17, ptr null, i64 0) ret void if.exit15: ; preds = %if.exit store ptr @.str.5, ptr %x16, align 8 - %14 = call ptr @std.io.stdout() - store ptr %14, ptr %result18, align 8 - %15 = load ptr, ptr %x16, align 8 - %16 = call i64 @std.io.File.print(ptr %retparam17, ptr %result18, ptr %15, i64 1) + %19 = call ptr @std.io.stdout() + store ptr %19, ptr %result18, align 8 + %20 = load ptr, ptr %result18, align 8 + %21 = load ptr, ptr %x16, align 8 + %22 = call i64 @std.io.File.print(ptr %retparam17, ptr %20, ptr %21, i64 1) store ptr @.str.6, ptr %x19, align 8 - %17 = call ptr @std.io.stdout() - store ptr %17, ptr %result21, align 8 - %18 = load ptr, ptr %x19, align 8 - %19 = call i64 @std.io.File.print(ptr %retparam20, ptr %result21, ptr %18, i64 1) - store ptr @.str.7, ptr %x22, align 8 - %20 = call ptr @std.io.stdout() - store ptr %20, ptr %result24, align 8 - %21 = load ptr, ptr %x22, align 8 - %22 = call i64 @std.io.File.print(ptr %retparam23, ptr %result24, ptr %21, i64 1) - store ptr @.str.8, ptr %x25, align 8 %23 = call ptr @std.io.stdout() - store ptr %23, ptr %result27, align 8 - %24 = call i64 @std.io.File.printn(ptr %retparam26, ptr %result27, ptr null, i64 0) + store ptr %23, ptr %result21, align 8 + %24 = load ptr, ptr %result21, align 8 + %25 = load ptr, ptr %x19, align 8 + %26 = call i64 @std.io.File.print(ptr %retparam20, ptr %24, ptr %25, i64 1) + store ptr @.str.7, ptr %x22, align 8 + %27 = call ptr @std.io.stdout() + store ptr %27, ptr %result24, align 8 + %28 = load ptr, ptr %result24, align 8 + %29 = load ptr, ptr %x22, align 8 + %30 = call i64 @std.io.File.print(ptr %retparam23, ptr %28, ptr %29, i64 1) + store ptr @.str.8, ptr %x25, align 8 + %31 = call ptr @std.io.stdout() + store ptr %31, ptr %result27, align 8 + %32 = load ptr, ptr %result27, align 8 + %33 = call i64 @std.io.File.printn(ptr %retparam26, ptr %32, ptr null, i64 0) ret void } diff --git a/test/test_suite/from_docs/examples_forswitch.c3t b/test/test_suite/from_docs/examples_forswitch.c3t index b0d978066..7c13c1a83 100644 --- a/test/test_suite/from_docs/examples_forswitch.c3t +++ b/test/test_suite/from_docs/examples_forswitch.c3t @@ -166,16 +166,18 @@ switch.case: ; preds = %switch.entry, %swit store ptr @.str.1, ptr %x, align 8 %2 = call ptr @std.io.stdout() store ptr %2, ptr %result, align 8 - %3 = load ptr, ptr %x, align 8 - %4 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %3, i64 8) + %3 = load ptr, ptr %result, align 8 + %4 = load ptr, ptr %x, align 8 + %5 = call i64 @std.io.File.printn(ptr %retparam, ptr %3, ptr %4, i64 8) br label %switch.exit switch.case1: ; preds = %switch.entry store ptr @.str.2, ptr %x2, align 8 - %5 = call ptr @std.io.stdout() - store ptr %5, ptr %result4, align 8 - %6 = load ptr, ptr %x2, align 8 - %7 = call i64 @std.io.File.printn(ptr %retparam3, ptr %result4, ptr %6, i64 4) + %6 = call ptr @std.io.stdout() + store ptr %6, ptr %result4, align 8 + %7 = load ptr, ptr %result4, align 8 + %8 = load ptr, ptr %x2, align 8 + %9 = call i64 @std.io.File.printn(ptr %retparam3, ptr %7, ptr %8, i64 4) br label %switch.exit switch.exit: ; preds = %switch.case1, %switch.case, %switch.entry @@ -183,8 +185,8 @@ switch.exit: ; preds = %switch.case1, %swit br label %switch.entry6 switch.entry6: ; preds = %switch.exit - %8 = load i32, ptr %switch5, align 4 - switch i32 %8, label %switch.exit15 [ + %10 = load i32, ptr %switch5, align 4 + switch i32 %10, label %switch.exit15 [ i32 0, label %switch.case7 i32 1, label %switch.case7 i32 2, label %switch.case11 @@ -192,18 +194,20 @@ switch.entry6: ; preds = %switch.exit switch.case7: ; preds = %switch.entry6, %switch.entry6 store ptr @.str.3, ptr %x8, align 8 - %9 = call ptr @std.io.stdout() - store ptr %9, ptr %result10, align 8 - %10 = load ptr, ptr %x8, align 8 - %11 = call i64 @std.io.File.printn(ptr %retparam9, ptr %result10, ptr %10, i64 8) + %11 = call ptr @std.io.stdout() + store ptr %11, ptr %result10, align 8 + %12 = load ptr, ptr %result10, align 8 + %13 = load ptr, ptr %x8, align 8 + %14 = call i64 @std.io.File.printn(ptr %retparam9, ptr %12, ptr %13, i64 8) br label %switch.exit15 switch.case11: ; preds = %switch.entry6 store ptr @.str.4, ptr %x12, align 8 - %12 = call ptr @std.io.stdout() - store ptr %12, ptr %result14, align 8 - %13 = load ptr, ptr %x12, align 8 - %14 = call i64 @std.io.File.printn(ptr %retparam13, ptr %result14, ptr %13, i64 4) + %15 = call ptr @std.io.stdout() + store ptr %15, ptr %result14, align 8 + %16 = load ptr, ptr %result14, align 8 + %17 = load ptr, ptr %x12, align 8 + %18 = call i64 @std.io.File.printn(ptr %retparam13, ptr %16, ptr %17, i64 4) br label %switch.exit15 switch.exit15: ; preds = %switch.case11, %switch.case7, %switch.entry6 @@ -211,8 +215,8 @@ switch.exit15: ; preds = %switch.case11, %swi br label %switch.entry17 switch.entry17: ; preds = %switch.exit15 - %15 = load i32, ptr %switch16, align 4 - switch i32 %15, label %switch.exit24 [ + %19 = load i32, ptr %switch16, align 4 + switch i32 %19, label %switch.exit24 [ i32 0, label %switch.case18 i32 1, label %switch.case19 i32 2, label %switch.case23 @@ -223,10 +227,11 @@ switch.case18: ; preds = %switch.entry17 switch.case19: ; preds = %switch.entry17 store ptr @.str.5, ptr %x20, align 8 - %16 = call ptr @std.io.stdout() - store ptr %16, ptr %result22, align 8 - %17 = load ptr, ptr %x20, align 8 - %18 = call i64 @std.io.File.printn(ptr %retparam21, ptr %result22, ptr %17, i64 6) + %20 = call ptr @std.io.stdout() + store ptr %20, ptr %result22, align 8 + %21 = load ptr, ptr %result22, align 8 + %22 = load ptr, ptr %x20, align 8 + %23 = call i64 @std.io.File.printn(ptr %retparam21, ptr %21, ptr %22, i64 6) br label %switch.exit24 switch.case23: ; preds = %switch.entry17 @@ -237,8 +242,8 @@ switch.exit24: ; preds = %switch.case23, %swi br label %switch.entry26 switch.entry26: ; preds = %switch.exit24 - %19 = load i32, ptr %switch25, align 4 - switch i32 %19, label %switch.default [ + %24 = load i32, ptr %switch25, align 4 + switch i32 %24, label %switch.default [ i32 0, label %switch.case27 i32 1, label %switch.case27 i32 2, label %switch.case27 @@ -255,8 +260,8 @@ switch.exit28: ; preds = %switch.default, %sw br label %switch.entry30 switch.entry30: ; preds = %switch.exit28 - %20 = load i32, ptr %switch29, align 4 - switch i32 %20, label %switch.exit44 [ + %25 = load i32, ptr %switch29, align 4 + switch i32 %25, label %switch.exit44 [ i32 0, label %switch.case31 i32 1, label %switch.case35 i32 2, label %switch.case40 @@ -265,27 +270,30 @@ switch.entry30: ; preds = %switch.exit28 switch.case31: ; preds = %switch.entry30 store i32 1, ptr %a, align 4 store ptr @.str.6, ptr %x32, align 8 - %21 = call ptr @std.io.stdout() - store ptr %21, ptr %result34, align 8 - %22 = load ptr, ptr %x32, align 8 - %23 = call i64 @std.io.File.printn(ptr %retparam33, ptr %result34, ptr %22, i64 1) + %26 = call ptr @std.io.stdout() + store ptr %26, ptr %result34, align 8 + %27 = load ptr, ptr %result34, align 8 + %28 = load ptr, ptr %x32, align 8 + %29 = call i64 @std.io.File.printn(ptr %retparam33, ptr %27, ptr %28, i64 1) br label %switch.case35 switch.case35: ; preds = %switch.entry30, %switch.case31 store i32 2, ptr %a36, align 4 store ptr @.str.7, ptr %x37, align 8 - %24 = call ptr @std.io.stdout() - store ptr %24, ptr %result39, align 8 - %25 = load ptr, ptr %x37, align 8 - %26 = call i64 @std.io.File.printn(ptr %retparam38, ptr %result39, ptr %25, i64 1) + %30 = call ptr @std.io.stdout() + store ptr %30, ptr %result39, align 8 + %31 = load ptr, ptr %result39, align 8 + %32 = load ptr, ptr %x37, align 8 + %33 = call i64 @std.io.File.printn(ptr %retparam38, ptr %31, ptr %32, i64 1) br label %switch.case40 switch.case40: ; preds = %switch.entry30, %switch.case35 store ptr @.str.8, ptr %x41, align 8 - %27 = call ptr @std.io.stdout() - store ptr %27, ptr %result43, align 8 - %28 = load ptr, ptr %x41, align 8 - %29 = call i64 @std.io.File.printn(ptr %retparam42, ptr %result43, ptr %28, i64 1) + %34 = call ptr @std.io.stdout() + store ptr %34, ptr %result43, align 8 + %35 = load ptr, ptr %result43, align 8 + %36 = load ptr, ptr %x41, align 8 + %37 = call i64 @std.io.File.printn(ptr %retparam42, ptr %35, ptr %36, i64 1) br label %switch.exit44 switch.exit44: ; preds = %switch.case40, %switch.entry30 diff --git a/test/test_suite/initializer_lists/subarrays.c3t b/test/test_suite/initializer_lists/subarrays.c3t index 33a2aa340..fb645c626 100644 --- a/test/test_suite/initializer_lists/subarrays.c3t +++ b/test/test_suite/initializer_lists/subarrays.c3t @@ -114,57 +114,59 @@ entry: store ptr @.str.5, ptr %x3, align 8 %13 = call ptr @std.io.stdout() store ptr %13, ptr %result, align 8 - %14 = load ptr, ptr %x3, align 8 - %15 = call i64 @std.io.File.printn(ptr %retparam, ptr %result, ptr %14, i64 6) - %16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1 - %17 = load i64, ptr %16, align 8 - %uisitrunc = trunc i64 %17 to i32 - %18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0 - %19 = load ptr, ptr %18, align 8 - %ptroffset4 = getelementptr inbounds i32, ptr %19, i64 1 - %20 = load i32, ptr %ptroffset4, align 4 - %21 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %uisitrunc, i32 %20) - %22 = load ptr, ptr %y, align 8 - %ptroffset5 = getelementptr inbounds i32, ptr %22, i64 1 - %23 = load i32, ptr %ptroffset5, align 4 - %24 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %23) - %25 = load ptr, ptr @subarrays.fofeo, align 8 - %ptroffset6 = getelementptr inbounds i32, ptr %25, i64 1 - %26 = load i32, ptr %ptroffset6, align 4 - %27 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %26) + %14 = load ptr, ptr %result, align 8 + %15 = load ptr, ptr %x3, align 8 + %16 = call i64 @std.io.File.printn(ptr %retparam, ptr %14, ptr %15, i64 6) + %17 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1 + %18 = load i64, ptr %17, align 8 + %uisitrunc = trunc i64 %18 to i32 + %19 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0 + %20 = load ptr, ptr %19, align 8 + %ptroffset4 = getelementptr inbounds i32, ptr %20, i64 1 + %21 = load i32, ptr %ptroffset4, align 4 + %22 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %uisitrunc, i32 %21) + %23 = load ptr, ptr %y, align 8 + %ptroffset5 = getelementptr inbounds i32, ptr %23, i64 1 + %24 = load i32, ptr %ptroffset5, align 4 + %25 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %24) + %26 = load ptr, ptr @subarrays.fofeo, align 8 + %ptroffset6 = getelementptr inbounds i32, ptr %26, i64 1 + %27 = load i32, ptr %ptroffset6, align 4 + %28 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %27) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const, i32 8, i1 false) - %28 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0 - store i32 0, ptr %28, align 4 - %29 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0 - store i32 1, ptr %29, align 4 - %30 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1 - store i32 2, ptr %30, align 4 - %31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2 - store i32 3, ptr %31, align 4 - %32 = insertvalue %"int[]" undef, ptr %literal7, 0 - %33 = insertvalue %"int[]" %32, i64 3, 1 - %34 = extractvalue %"int[]" %33, 1 - %not = icmp eq i64 %34, 0 - %35 = zext i1 %not to i8 - store i8 %35, ptr %xy, align 1 - %36 = load i8, ptr %xy, align 1 - %37 = trunc i8 %36 to i1 - %not8 = xor i1 %37, true + %29 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0 + store i32 0, ptr %29, align 4 + %30 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0 + store i32 1, ptr %30, align 4 + %31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1 + store i32 2, ptr %31, align 4 + %32 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2 + store i32 3, ptr %32, align 4 + %33 = insertvalue %"int[]" undef, ptr %literal7, 0 + %34 = insertvalue %"int[]" %33, i64 3, 1 + %35 = extractvalue %"int[]" %34, 1 + %not = icmp eq i64 %35, 0 + %36 = zext i1 %not to i8 + store i8 %36, ptr %xy, align 1 + %37 = load i8, ptr %xy, align 1 + %38 = trunc i8 %37 to i1 + %not8 = xor i1 %38, true br i1 %not8, label %if.then, label %if.exit if.then: ; preds = %entry store ptr @.str.9, ptr %x9, align 8 - %38 = call ptr @std.io.stdout() - store ptr %38, ptr %result11, align 8 - %39 = load ptr, ptr %x9, align 8 - %40 = call i64 @std.io.File.printn(ptr %retparam10, ptr %result11, ptr %39, i64 2) + %39 = call ptr @std.io.stdout() + store ptr %39, ptr %result11, align 8 + %40 = load ptr, ptr %result11, align 8 + %41 = load ptr, ptr %x9, align 8 + %42 = call i64 @std.io.File.printn(ptr %retparam10, ptr %40, ptr %41, i64 2) br label %if.exit if.exit: ; preds = %if.then, %entry - %41 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0 - store i32 0, ptr %41, align 4 - %42 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1 - store i32 0, ptr %42, align 4 + %43 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0 + store i32 0, ptr %43, align 4 + %44 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1 + store i32 0, ptr %44, align 4 call void @llvm.memset.p0.i64(ptr align 8 %z, i8 0, i64 8, i1 false) store %"int[]" zeroinitializer, ptr %sub, align 8 store %"Bar[]" zeroinitializer, ptr %foo, align 8