diff --git a/build.bat b/build.bat index 9758c2515..8c5330227 100644 --- a/build.bat +++ b/build.bat @@ -17,10 +17,13 @@ if %release_mode% EQU 0 ( rem Debug set compiler_warnings= ^ -W4 -WX ^ -wd4100 -wd4101 -wd4127 -wd4189 ^ - -wd4201 -wd4204 -wd4244 ^ - -wd4306 ^ - -wd4456 -wd4457 -wd4480 ^ - -wd4505 -wd4512 -wd4550 + -wd4201 ^ + -wd4512 + rem -wd4100 -wd4101 -wd4127 -wd4189 ^ + rem -wd4201 -wd4204 -wd4244 ^ + rem -wd4306 ^ + rem -wd4456 -wd4457 -wd4480 ^ + rem -wd4505 -wd4512 -wd4550 set compiler_includes= set libs= ^ @@ -38,7 +41,6 @@ if %release_mode% EQU 0 ( rem Debug set compiler_settings=%compiler_includes% %compiler_flags% %compiler_warnings% set linker_settings=%libs% %linker_flags% - del *.pdb > NUL 2> NUL del *.ilk > NUL 2> NUL diff --git a/core/os_x.odin b/core/os_x.odin index 4d5d90435..1bf594e00 100644 --- a/core/os_x.odin +++ b/core/os_x.odin @@ -108,13 +108,13 @@ S_ISUID :: 0004000; // Set user id on execution S_ISGID :: 0002000; // Set group id on execution S_ISVTX :: 0001000; // Directory restrcted delete -S_ISLNK :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFLNK; } -S_ISREG :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFREG; } -S_ISDIR :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFDIR; } -S_ISCHR :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFCHR; } -S_ISBLK :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFBLK; } -S_ISFIFO :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFIFO; } -S_ISSOCK :: proc(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFSOCK;} +S_ISLNK :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFLNK; +S_ISREG :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFREG; +S_ISDIR :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFDIR; +S_ISCHR :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFCHR; +S_ISBLK :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFBLK; +S_ISFIFO :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFIFO; +S_ISSOCK :: proc(m: u32) -> bool #inline do return (m & S_IFMT) == S_IFSOCK; R_OK :: 4; // Test for read permission W_OK :: 2; // Test for write permission @@ -122,28 +122,28 @@ X_OK :: 1; // Test for execute permission F_OK :: 0; // Test for file existance foreign libc { - unix_open :: proc(path: ^u8, mode: int) -> Handle #link_name "open" ---; - unix_close :: proc(handle: Handle) #link_name "close" ---; - unix_read :: proc(handle: Handle, buffer: rawptr, count: int) -> int #link_name "read" ---; - unix_write :: proc(handle: Handle, buffer: rawptr, count: int) -> int #link_name "write" ---; - unix_lseek :: proc(fs: Handle, offset: int, whence: int) -> int #link_name "lseek" ---; - unix_gettid :: proc() -> u64 #link_name "gettid" ---; - unix_stat :: proc(path: ^u8, stat: ^Stat) -> int #link_name "stat" ---; - unix_access :: proc(path: ^u8, mask: int) -> int #link_name "access" ---; + unix_open :: proc(path: ^u8, mode: int) -> Handle #link_name "open" ---; + unix_close :: proc(handle: Handle) #link_name "close" ---; + unix_read :: proc(handle: Handle, buffer: rawptr, count: int) -> int #link_name "read" ---; + unix_write :: proc(handle: Handle, buffer: rawptr, count: int) -> int #link_name "write" ---; + unix_lseek :: proc(fs: Handle, offset: int, whence: int) -> int #link_name "lseek" ---; + unix_gettid :: proc() -> u64 #link_name "gettid" ---; + unix_stat :: proc(path: ^u8, stat: ^Stat) -> int #link_name "stat" ---; + unix_access :: proc(path: ^u8, mask: int) -> int #link_name "access" ---; - unix_malloc :: proc(size: int) -> rawptr #link_name "malloc" ---; - unix_free :: proc(ptr: rawptr) #link_name "free" ---; - unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr #link_name "realloc" ---; - unix_getenv :: proc(^u8) -> ^u8 #link_name "getenv" ---; + unix_malloc :: proc(size: int) -> rawptr #link_name "malloc" ---; + unix_free :: proc(ptr: rawptr) #link_name "free" ---; + unix_realloc :: proc(ptr: rawptr, size: int) -> rawptr #link_name "realloc" ---; + unix_getenv :: proc(^u8) -> ^u8 #link_name "getenv" ---; - unix_exit :: proc(status: int) #link_name "exit" ---; + unix_exit :: proc(status: int) #link_name "exit" ---; } foreign dl { - unix_dlopen :: proc(filename: ^u8, flags: int) -> rawptr #link_name "dlopen" ---; - unix_dlsym :: proc(handle: rawptr, symbol: ^u8) -> (proc() #cc_c) #link_name "dlsym" ---; - unix_dlclose :: proc(handle: rawptr) -> int #link_name "dlclose" ---; - unix_dlerror :: proc() -> ^u8 #link_name "dlerror" ---; + unix_dlopen :: proc(filename: ^u8, flags: int) -> rawptr #link_name "dlopen" ---; + unix_dlsym :: proc(handle: rawptr, symbol: ^u8) -> (proc() #cc_c) #link_name "dlsym" ---; + unix_dlclose :: proc(handle: rawptr) -> int #link_name "dlclose" ---; + unix_dlerror :: proc() -> ^u8 #link_name "dlerror" ---; } // TODO(zangent): Change this to just `open` when Bill fixes overloading. @@ -187,10 +187,10 @@ read :: proc(fd: Handle, data: []u8) -> (int, Errno) { return bytes_read, 0; } -seek :: proc(fd: Handle, offset: int, whence: int) -> (int, Errno) { +seek :: proc(fd: Handle, offset: i64, whence: int) -> (i64, Errno) { assert(fd != -1); - final_offset := unix_lseek(fd, offset, whence); + final_offset := i64(unix_lseek(fd, offset, whence)); if(final_offset == -1) { return 0, 1; } @@ -201,7 +201,7 @@ file_size :: proc(fd: Handle) -> (i64, Errno) { prev, _ := seek(fd, 0, SEEK_CUR); size, err := seek(fd, 0, SEEK_END); seek(fd, prev, SEEK_SET); - return size, err; + return i64(size), err; } diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 07b7a8e3e..b34e906c6 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -57,7 +57,7 @@ String odin_root_dir(void) { len = 0; for (;;) { - len = GetModuleFileNameW(nullptr, &path_buf[0], path_buf.count); + len = GetModuleFileNameW(nullptr, &path_buf[0], cast(int)path_buf.count); if (len == 0) { return make_string(nullptr, 0); } @@ -73,7 +73,7 @@ String odin_root_dir(void) { text = gb_alloc_array(string_buffer_allocator, wchar_t, len+1); - GetModuleFileNameW(nullptr, text, len); + GetModuleFileNameW(nullptr, text, cast(int)len); path = string16_to_string(heap_allocator(), make_string16(text, len)); for (i = path.len-1; i >= 0; i--) { diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 60da0dd08..df2fe185e 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -494,7 +494,7 @@ i64 check_distance_between_types(Checker *c, Operand *operand, Type *type) { Type *bfv = base_type(operand->type); i32 bits = bfv->BitFieldValue.bits; i32 size = next_pow2((bits+7)/8); - i32 dst_size = type_size_of(c->allocator, type); + i32 dst_size = cast(i32)type_size_of(c->allocator, type); i32 diff = gb_abs(dst_size - size); // TODO(bill): figure out a decent rule here return 1; @@ -1279,7 +1279,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node, ArrayVariable.field_index = i; + reordered_fields[i]->Variable.field_index = cast(i32)i; } struct_type->Struct.fields = reordered_fields; @@ -1564,7 +1564,7 @@ void check_enum_type(Checker *c, Type *enum_type, Type *named_type, AstNode *nod enum_type->Enum.fields = fields.data; - enum_type->Enum.field_count = fields.count; + enum_type->Enum.field_count = cast(i32)fields.count; enum_type->Enum.count = make_entity_constant(c->allocator, c->context.scope, make_token_ident(str_lit("count")), t_int, exact_value_i64(fields.count)); @@ -1622,7 +1622,7 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, Type *named_type, As continue; } - Type *value_type = make_type_bit_field_value(c->allocator, bits); + Type *value_type = make_type_bit_field_value(c->allocator, cast(i32)bits); Entity *e = make_entity_variable(c->allocator, bit_field_type->BitField.scope, ident->Ident.token, value_type, false); e->identifier = ident; e->flags |= EntityFlag_BitFieldValue; @@ -1638,16 +1638,16 @@ void check_bit_field_type(Checker *c, Type *bit_field_type, Type *named_type, As fields [field_count] = e; offsets[field_count] = curr_offset; - sizes [field_count] = bits; + sizes [field_count] = cast(i32)bits; field_count++; - curr_offset += bits; + curr_offset += cast(i32)bits; } } GB_ASSERT(field_count <= bft->fields.count); bit_field_type->BitField.fields = fields; - bit_field_type->BitField.field_count = field_count; + bit_field_type->BitField.field_count = cast(i32)field_count; bit_field_type->BitField.sizes = sizes; bit_field_type->BitField.offsets = offsets; @@ -2180,7 +2180,7 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *_params, bool *is_vari if (scope != nullptr) { for_array(i, scope->elements.entries) { Entity *e = scope->elements.entries[i].value; - if (e->kind == Type_Named) { + if (e->kind == Entity_TypeName) { Type *t = e->type; if (t->kind == Type_Generic && t->Generic.specialized != nullptr) { @@ -2523,9 +2523,9 @@ bool check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node, Array type->Proc.node = proc_type_node; type->Proc.scope = c->context.scope; type->Proc.params = params; - type->Proc.param_count = param_count; + type->Proc.param_count = cast(i32)param_count; type->Proc.results = results; - type->Proc.result_count = result_count; + type->Proc.result_count = cast(i32)result_count; type->Proc.variadic = variadic; type->Proc.calling_convention = pt->calling_convention; type->Proc.is_polymorphic = pt->generic; @@ -3341,12 +3341,12 @@ bool check_representable_as_constant(Checker *c, ExactValue in_value, Type *type i64 s = 8*type_size_of(c->allocator, type); u128 umax = U128_NEG_ONE; if (s < 128) { - umax = u128_sub(u128_shl(U128_ONE, s), U128_ONE); + umax = u128_sub(u128_shl(U128_ONE, cast(u32)s), U128_ONE); } else { // IMPORTANT TODO(bill): I NEED A PROPER BIG NUMBER LIBRARY THAT CAN SUPPORT 128 bit floats s = 128; } - i128 imax = i128_shl(I128_ONE, s-1ll); + i128 imax = i128_shl(I128_ONE, cast(u32)s-1); switch (type->Basic.kind) { case Basic_rune: @@ -4399,8 +4399,8 @@ void convert_to_typed(Checker *c, Operand *operand, Type *target_type, i32 level defer (gb_temp_arena_memory_end(tmp)); isize count = t->Union.variants.count; ValidIndexAndScore *valids = gb_alloc_array(c->tmp_allocator, ValidIndexAndScore, count); - i32 valid_count = 0; - i32 first_success_index = -1; + isize valid_count = 0; + isize first_success_index = -1; for_array(i, t->Union.variants) { Type *vt = t->Union.variants[i]; i64 score = 0; @@ -5693,7 +5693,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id gbAllocator a = c->allocator; Type *tuple = make_type_tuple(a); - i32 variable_count = type->Struct.fields.count; + isize variable_count = type->Struct.fields.count; array_init_count(&tuple->Tuple.variables, a, variable_count); // TODO(bill): Should I copy each of the entities or is this good enough? gb_memcopy_array(tuple->Tuple.variables.data, type->Struct.fields_in_src_order.data, variable_count); diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 189bff7fd..8d74c4f17 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -4,7 +4,7 @@ void check_stmt_list(Checker *c, Array stmts, u32 flags) { } if (flags&Stmt_CheckScopeDecls) { - check_scope_decls(c, stmts, 1.2*stmts.count); + check_scope_decls(c, stmts, cast(isize)(1.2*stmts.count)); } bool ft_ok = (flags & Stmt_FallthroughAllowed) != 0; @@ -265,9 +265,9 @@ Type *check_assignment_variable(Checker *c, Operand *rhs, AstNode *lhs_node) { u128 u = *cast(u128 *)&i; u128 umax = U128_NEG_ONE; if (lhs_bits < 128) { - umax = u128_sub(u128_shl(U128_ONE, lhs_bits), U128_ONE); + umax = u128_sub(u128_shl(U128_ONE, cast(u32)lhs_bits), U128_ONE); } - i128 imax = i128_shl(I128_ONE, lhs_bits-1ll); + i128 imax = i128_shl(I128_ONE, cast(u32)lhs_bits-1); bool ok = false; ok = !(u128_lt(u, U128_ZERO) || u128_gt(u, umax)); diff --git a/src/checker.cpp b/src/checker.cpp index e0ba73875..73539a214 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -267,7 +267,7 @@ struct DelayedDecl { }; struct CheckerFileNode { - i32 id; + isize id; Array wheres; Array whats; i32 score; // Higher the score, the better diff --git a/src/common.cpp b/src/common.cpp index 97a848ffa..ec8d3049b 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -199,7 +199,19 @@ gbAllocator pool_allocator(Pool *pool) { - +i32 next_pow2(i32 n) { + if (n <= 0) { + return 0; + } + n--; + n |= n >> 1; + n |= n >> 2; + n |= n >> 4; + n |= n >> 8; + n |= n >> 16; + n++; + return n; +} i64 next_pow2(i64 n) { if (n <= 0) { return 0; @@ -215,6 +227,17 @@ i64 next_pow2(i64 n) { return n; } +i32 prev_pow2(i32 n) { + if (n <= 0) { + return 0; + } + n |= n >> 1; + n |= n >> 2; + n |= n >> 4; + n |= n >> 8; + n |= n >> 16; + return n - (n >> 1); +} i64 prev_pow2(i64 n) { if (n <= 0) { return 0; @@ -310,7 +333,7 @@ f64 gb_sqrt(f64 x) { wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) { u32 i, j; - u32 len = string16_len(cmd_line); + u32 len = cast(u32)string16_len(cmd_line); i = ((len+2)/2)*gb_size_of(void *) + gb_size_of(void *); wchar_t **argv = cast(wchar_t **)GlobalAlloc(GMEM_FIXED, i + (len+2)*gb_size_of(wchar_t)); diff --git a/src/exact_value.cpp b/src/exact_value.cpp index 6966dbf73..070dffc6a 100644 --- a/src/exact_value.cpp +++ b/src/exact_value.cpp @@ -504,19 +504,19 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) i128 b = y.value_integer; i128 c = I128_ZERO; switch (op) { - case Token_Add: c = a + b; break; - case Token_Sub: c = a - b; break; - case Token_Mul: c = a * b; break; + case Token_Add: c = a + b; break; + case Token_Sub: c = a - b; break; + case Token_Mul: c = a * b; break; case Token_Quo: return exact_value_float(fmod(i128_to_f64(a), i128_to_f64(b))); - case Token_QuoEq: c = a / b; break; // NOTE(bill): Integer division - case Token_Mod: c = a % b; break; - case Token_ModMod: c = ((a % b) + b) % b; break; - case Token_And: c = a & b; break; - case Token_Or: c = a | b; break; - case Token_Xor: c = a ^ b; break; - case Token_AndNot: c = i128_and_not(a, b); break; - case Token_Shl: c = a << i128_to_u64(b); break; - case Token_Shr: c = a >> i128_to_u64(b); break; + case Token_QuoEq: c = a / b; break; // NOTE(bill): Integer division + case Token_Mod: c = a % b; break; + case Token_ModMod: c = ((a % b) + b) % b; break; + case Token_And: c = a & b; break; + case Token_Or: c = a | b; break; + case Token_Xor: c = a ^ b; break; + case Token_AndNot: c = i128_and_not(a, b); break; + case Token_Shl: c = a << cast(u32)i128_to_u64(b); break; + case Token_Shr: c = a >> cast(u32)i128_to_u64(b); break; default: goto error; } diff --git a/src/gb/gb.h b/src/gb/gb.h index eeab9d8fa..e2a605666 100644 --- a/src/gb/gb.h +++ b/src/gb/gb.h @@ -985,7 +985,7 @@ typedef struct gbThread { } gbThread; GB_DEF void gb_thread_init (gbThread *t); -GB_DEF void gb_thread_destory (gbThread *t); +GB_DEF void gb_thread_destroy (gbThread *t); GB_DEF void gb_thread_start (gbThread *t, gbThreadProc *proc, void *data); GB_DEF void gb_thread_start_with_stack(gbThread *t, gbThreadProc *proc, void *data, isize stack_size); GB_DEF void gb_thread_join (gbThread *t); @@ -4698,7 +4698,7 @@ void gb_thread_init(gbThread *t) { gb_semaphore_init(&t->semaphore); } -void gb_thread_destory(gbThread *t) { +void gb_thread_destroy(gbThread *t) { if (t->is_running) gb_thread_join(t); gb_semaphore_destroy(&t->semaphore); } @@ -7472,13 +7472,13 @@ u64 gb_murmur64_seed(void const *data_, isize len, u64 seed) { if (w_len_) *w_len_ = w_len; return NULL; } - w_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, len, NULL, 0); + w_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, cast(int)len, NULL, 0); if (w_len == 0) { if (w_len_) *w_len_ = w_len; return NULL; } w_text = gb_alloc_array(a, wchar_t, w_len+1); - w_len1 = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, len, w_text, w_len); + w_len1 = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text, cast(int)len, w_text, cast(int)w_len); if (w_len1 == 0) { gb_free(a, w_text); if (w_len_) *w_len_ = 0; @@ -8126,17 +8126,17 @@ char *gb_path_get_full_name(gbAllocator a, char const *path) { return NULL; } w_fullpath = gb_alloc_array(gb_heap_allocator(), wchar_t, w_len+1); - GetFullPathNameW(w_path, w_len, w_fullpath, NULL); + GetFullPathNameW(w_path, cast(int)w_len, w_fullpath, NULL); w_fullpath[w_len] = 0; gb_free(gb_heap_allocator(), w_path); - new_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, w_len, NULL, 0, NULL, NULL); + new_len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, cast(int)w_len, NULL, 0, NULL, NULL); if (new_len == 0) { gb_free(gb_heap_allocator(), w_fullpath); return NULL; } new_path = gb_alloc_array(a, char, new_len+1); - new_len1 = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, w_len, new_path, new_len, NULL, NULL); + new_len1 = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, w_fullpath, cast(int)w_len, new_path, cast(int)new_len, NULL, NULL); if (new_len1 == 0) { gb_free(gb_heap_allocator(), w_fullpath); gb_free(a, new_path); diff --git a/src/ir.cpp b/src/ir.cpp index f40266d86..4bb48aa5e 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -13,7 +13,7 @@ struct irModule { gbAllocator tmp_allocator; // bool generate_debug_info; - u32 stmt_state_flags; + u64 stmt_state_flags; // String source_filename; String layout; @@ -442,7 +442,7 @@ irAddr ir_addr_map(irValue *addr, irValue *map_key, Type *map_type, Type *map_re return v; } -irAddr ir_addr_bit_field(irValue *addr, isize bit_field_value_index) { +irAddr ir_addr_bit_field(irValue *addr, i32 bit_field_value_index) { irAddr v = {irAddr_BitField, addr}; v.bit_field_value_index = bit_field_value_index; return v; @@ -3435,7 +3435,7 @@ irValue *ir_type_info(irProcedure *proc, Type *type) { type = default_type(type); - i32 entry_index = type_info_index(info, type); + i32 entry_index = cast(i32)type_info_index(info, type); // gb_printf_err("%d %s\n", entry_index, type_to_string(type)); @@ -4454,7 +4454,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv Entity *field = t->Struct.fields_in_src_order[src_index]; i32 field_index = field->Variable.field_index; irValue *f = ir_emit_struct_ev(proc, s, field_index); - irValue *ep = ir_emit_struct_ep(proc, tuple, src_index); + irValue *ep = ir_emit_struct_ep(proc, tuple, cast(i32)src_index); ir_emit_store(proc, ep, f); } return ir_emit_load(proc, tuple); @@ -4901,7 +4901,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { if (at->kind == Type_Tuple) { for_array(i, at->Tuple.variables) { Entity *e = at->Tuple.variables[i]; - irValue *v = ir_emit_struct_ev(proc, a, i); + irValue *v = ir_emit_struct_ev(proc, a, cast(i32)i); args[arg_index++] = v; } } else { @@ -5001,7 +5001,7 @@ irValue *ir_build_expr(irProcedure *proc, AstNode *expr) { irValue *base_array = ir_add_local_generated(proc, make_type_array(allocator, elem_type, slice_len)); for (isize i = type->param_count-1, j = 0; i < arg_count; i++, j++) { - irValue *addr = ir_emit_array_epi(proc, base_array, j); + irValue *addr = ir_emit_array_epi(proc, base_array, cast(i32)j); ir_emit_store(proc, addr, args[i]); } @@ -5497,7 +5497,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { isize index_count = bt->Vector.count; irValue *elem_val = ir_build_expr(proc, cl->elems[0]); for (isize i = 0; i < index_count; i++) { - ir_emit_store(proc, ir_emit_array_epi(proc, v, i), elem_val); + ir_emit_store(proc, ir_emit_array_epi(proc, v, cast(i32)i), elem_val); } } else if (cl->elems.count > 0) { ir_emit_store(proc, v, ir_add_module_constant(proc->module, type, exact_value_compound(expr))); @@ -5510,7 +5510,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { Type *t = ir_type(field_expr); GB_ASSERT(t->kind != Type_Tuple); irValue *ev = ir_emit_conv(proc, field_expr, et); - irValue *gep = ir_emit_array_epi(proc, v, i); + irValue *gep = ir_emit_array_epi(proc, v, cast(i32)i); ir_emit_store(proc, gep, ev); } } @@ -5556,7 +5556,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { GB_ASSERT(ir_type(field_expr)->kind != Type_Tuple); irValue *fv = ir_emit_conv(proc, field_expr, ft); - irValue *gep = ir_emit_struct_ep(proc, v, index); + irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index); ir_emit_store(proc, gep, fv); } } @@ -5585,7 +5585,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { for_array(field_index, cl->elems) { AstNode *f = cl->elems[field_index]; irValue *value = ir_emit_conv(proc, ir_build_expr(proc, f), elem); - irValue *ep = ir_emit_array_epi(proc, items, field_index); + irValue *ep = ir_emit_array_epi(proc, items, cast(i32)field_index); ir_emit_store(proc, ep, value); } @@ -5633,7 +5633,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { Type *t = ir_type(field_expr); GB_ASSERT(t->kind != Type_Tuple); irValue *ev = ir_emit_conv(proc, field_expr, et); - irValue *gep = ir_emit_array_epi(proc, v, i); + irValue *gep = ir_emit_array_epi(proc, v, cast(i32)i); ir_emit_store(proc, gep, ev); } } @@ -5703,7 +5703,7 @@ irAddr ir_build_addr(irProcedure *proc, AstNode *expr) { Type *ft = field_types[index]; irValue *fv = ir_emit_conv(proc, field_expr, ft); - irValue *gep = ir_emit_struct_ep(proc, v, index); + irValue *gep = ir_emit_struct_ep(proc, v, cast(i32)index); ir_emit_store(proc, gep, fv); } } @@ -5936,11 +5936,11 @@ void ir_build_stmt_list(irProcedure *proc, Array stmts) { void ir_build_stmt_internal(irProcedure *proc, AstNode *node); void ir_build_stmt(irProcedure *proc, AstNode *node) { - u32 prev_stmt_state_flags = proc->module->stmt_state_flags; + u64 prev_stmt_state_flags = proc->module->stmt_state_flags; if (node->stmt_state_flags != 0) { - u32 in = node->stmt_state_flags; - u32 out = proc->module->stmt_state_flags; + u64 in = node->stmt_state_flags; + u64 out = proc->module->stmt_state_flags; if (in & StmtStateFlag_bounds_check) { out |= StmtStateFlag_bounds_check; @@ -6285,7 +6285,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { if (t->kind == Type_Tuple) { for_array(i, t->Tuple.variables) { Entity *e = t->Tuple.variables[i]; - irValue *v = ir_emit_struct_ev(proc, init, i); + irValue *v = ir_emit_struct_ev(proc, init, cast(i32)i); array_add(&inits, v); } } else { @@ -6350,7 +6350,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { if (t->kind == Type_Tuple) { for_array(i, t->Tuple.variables) { Entity *e = t->Tuple.variables[i]; - irValue *v = ir_emit_struct_ev(proc, init, i); + irValue *v = ir_emit_struct_ev(proc, init, cast(i32)i); array_add(&inits, v); } } else { @@ -6445,7 +6445,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { Type *ret_type = proc->type->Proc.results; v = ir_add_local_generated(proc, ret_type); for_array(i, results) { - irValue *field = ir_emit_struct_ep(proc, v, i); + irValue *field = ir_emit_struct_ep(proc, v, cast(i32)i); irValue *res = results[i]; ir_emit_store(proc, field, res); } @@ -6481,7 +6481,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { if (t->kind == Type_Tuple) { for_array(i, t->Tuple.variables) { Entity *e = t->Tuple.variables[i]; - irValue *v = ir_emit_struct_ev(proc, res, i); + irValue *v = ir_emit_struct_ev(proc, res, cast(i32)i); array_add(&results, v); total_index++; } @@ -6509,7 +6509,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { for_array(i, results) { Entity *e = tuple->variables[i]; irValue *res = ir_emit_conv(proc, results[i], e->type); - irValue *field = ir_emit_struct_ep(proc, v, i); + irValue *field = ir_emit_struct_ep(proc, v, cast(i32)i); ir_emit_store(proc, field, res); } @@ -7111,7 +7111,7 @@ void ir_number_proc_registers(irProcedure *proc) { i32 reg_index = 0; for_array(i, proc->blocks) { irBlock *b = proc->blocks[i]; - b->index = i; + b->index = cast(i32)i; for_array(j, b->instrs) { irValue *value = b->instrs[j]; GB_ASSERT_MSG(value->kind == irValue_Instr, "%.*s", LIT(proc->name)); @@ -7255,11 +7255,11 @@ void ir_build_proc(irValue *value, irProcedure *parent) { } if (proc->body != nullptr) { - u32 prev_stmt_state_flags = proc->module->stmt_state_flags; + u64 prev_stmt_state_flags = proc->module->stmt_state_flags; if (proc->tags != 0) { - u32 in = proc->tags; - u32 out = proc->module->stmt_state_flags; + u64 in = proc->tags; + u64 out = proc->module->stmt_state_flags; if (in & ProcTag_bounds_check) { out |= StmtStateFlag_bounds_check; out &= ~StmtStateFlag_no_bounds_check; @@ -7483,22 +7483,22 @@ irValue *ir_get_type_info_ptr(irProcedure *proc, Type *type) { irValue *ir_type_info_member_types_offset(irProcedure *proc, isize count) { irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_types, ir_global_type_info_member_types_index); - ir_global_type_info_member_types_index += count; + ir_global_type_info_member_types_index += cast(i32)count; return offset; } irValue *ir_type_info_member_names_offset(irProcedure *proc, isize count) { irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_names, ir_global_type_info_member_names_index); - ir_global_type_info_member_names_index += count; + ir_global_type_info_member_names_index += cast(i32)count; return offset; } irValue *ir_type_info_member_offsets_offset(irProcedure *proc, isize count) { irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_offsets, ir_global_type_info_member_offsets_index); - ir_global_type_info_member_offsets_index += count; + ir_global_type_info_member_offsets_index += cast(i32)count; return offset; } irValue *ir_type_info_member_usings_offset(irProcedure *proc, isize count) { irValue *offset = ir_emit_array_epi(proc, ir_global_type_info_member_usings, ir_global_type_info_member_usings_index); - ir_global_type_info_member_usings_index += count; + ir_global_type_info_member_usings_index += cast(i32)count; return offset; } @@ -7706,7 +7706,7 @@ void ir_gen_tree(irGen *s) { for_array(i, m->debug_info.entries) { auto *entry = &m->debug_info.entries[i]; irDebugInfo *di = entry->value; - di->id = i; + di->id = cast(i32)i; if (di->kind == irDebugInfo_Proc) { all_proc_max_count++; } @@ -7942,7 +7942,7 @@ void ir_gen_tree(irGen *s) { isize entry_index = type_info_index(info, t); irValue *tag = nullptr; - irValue *ti_ptr = ir_emit_array_epi(proc, ir_global_type_info_data, entry_index); + irValue *ti_ptr = ir_emit_array_epi(proc, ir_global_type_info_data, cast(i32)entry_index); irValue *variant_ptr = ir_emit_struct_ep(proc, ti_ptr, 2); ir_emit_store(proc, ir_emit_struct_ep(proc, ti_ptr, 0), ir_const_int(a, type_size_of(a, t))); @@ -8134,8 +8134,8 @@ void ir_gen_tree(irGen *s) { } for (isize i = 0; i < count; i++) { - irValue *name_ep = ir_emit_array_epi(proc, name_array, i); - irValue *value_ep = ir_emit_array_epi(proc, value_array, i); + irValue *name_ep = ir_emit_array_epi(proc, name_array, cast(i32)i); + irValue *value_ep = ir_emit_array_epi(proc, value_array, cast(i32)i); ExactValue value = fields[i]->Constant.value; irValue *v = ir_value_constant(a, t->Enum.base_type, value); @@ -8202,7 +8202,7 @@ void ir_gen_tree(irGen *s) { ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 7), is_custom_align); } - i32 count = t->Struct.fields.count; + isize count = t->Struct.fields.count; irValue *memory_types = ir_type_info_member_types_offset (proc, count); irValue *memory_names = ir_type_info_member_names_offset (proc, count); @@ -8271,9 +8271,9 @@ void ir_gen_tree(irGen *s) { Entity *f = fields[i]; GB_ASSERT(f->type != nullptr); GB_ASSERT(f->type->kind == Type_BitFieldValue); - irValue *name_ep = ir_emit_array_epi(proc, name_array, i); - irValue *bit_ep = ir_emit_array_epi(proc, bit_array, i); - irValue *offset_ep = ir_emit_array_epi(proc, offset_array, i); + irValue *name_ep = ir_emit_array_epi(proc, name_array, cast(i32)i); + irValue *bit_ep = ir_emit_array_epi(proc, bit_array, cast(i32)i); + irValue *offset_ep = ir_emit_array_epi(proc, offset_array, cast(i32)i); ir_emit_store(proc, name_ep, ir_const_string(a, f->token.string)); ir_emit_store(proc, bit_ep, ir_const_u32(a, f->type->BitFieldValue.bits)); @@ -8336,7 +8336,7 @@ void ir_gen_tree(irGen *s) { for_array(i, m->debug_info.entries) { auto *entry = &m->debug_info.entries[i]; irDebugInfo *di = entry->value; - di->id = i; + di->id = cast(i32)i; } diff --git a/src/ir_opt.cpp b/src/ir_opt.cpp index 756eed856..af7189efc 100644 --- a/src/ir_opt.cpp +++ b/src/ir_opt.cpp @@ -172,7 +172,7 @@ void ir_remove_dead_blocks(irProcedure *proc) { continue; } // NOTE(bill): Swap order - b->index = j; + b->index = cast(i32)j; proc->blocks[j++] = b; } proc->blocks.count = j; @@ -373,7 +373,7 @@ void ir_opt_build_dom_tree(irProcedure *proc) { gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&proc->module->tmp_arena); - isize n = proc->blocks.count; + i32 n = cast(i32)proc->blocks.count; irBlock **buf = gb_alloc_array(proc->module->tmp_allocator, irBlock *, 5*n); irLTState lt = {0}; diff --git a/src/ir_print.cpp b/src/ir_print.cpp index 1d6d85886..c7dc9e2d0 100644 --- a/src/ir_print.cpp +++ b/src/ir_print.cpp @@ -686,7 +686,7 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type * ir_write_string(f, "zeroinitializer"); } else { if (is_type_struct(type)) { - i32 value_count = type->Struct.fields.count; + i32 value_count = cast(i32)type->Struct.fields.count; if (type->Struct.is_packed) ir_write_byte(f, '<'); ir_write_byte(f, '{'); if (type->Struct.custom_align > 0) { diff --git a/src/main.cpp b/src/main.cpp index aa2158e31..73b49fdc6 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -542,7 +542,7 @@ int main(int arg_count, char **arg_ptr) { String output_name = ir_gen.output_name; String output_base = ir_gen.output_base; - int base_name_len = output_base.len; + int base_name_len = cast(int)output_base.len; build_context.optimization_level = gb_clamp(build_context.optimization_level, 0, 3); diff --git a/src/parser.cpp b/src/parser.cpp index 3ae3f767e..b9ff2554c 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -36,7 +36,7 @@ struct ImportedFile { struct AstFile { - i32 id; + isize id; gbArena arena; Tokenizer tokenizer; Array tokens; @@ -1574,7 +1574,7 @@ AstNode *ast_foreign_library_spec(AstFile *f, Token filepath, Token library_name bool next_token0(AstFile *f) { - Token prev = f->curr_token; + // Token prev = f->curr_token; if (f->curr_token_index+1 < f->tokens.count) { f->curr_token = f->tokens[++f->curr_token_index]; return true; @@ -1675,10 +1675,9 @@ TokenKind look_ahead_token_kind(AstFile *f, isize amount) { Token expect_token(AstFile *f, TokenKind kind) { Token prev = f->curr_token; if (prev.kind != kind) { + String c = token_strings[kind]; String p = token_strings[prev.kind]; - syntax_error(f->curr_token, "Expected `%.*s`, got `%.*s`", - LIT(token_strings[kind]), - LIT(token_strings[prev.kind])); + syntax_error(f->curr_token, "Expected `%.*s`, got `%.*s`", LIT(c), LIT(p)); if (prev.kind == Token_EOF) { gb_exit(1); } @@ -5122,7 +5121,7 @@ ParseFileError parse_files(Parser *p, String init_filename) { } else if (p->curr_import_index < p->imports.count) { if (t->return_value != 0) { for_array(i, worker_threads) { - gb_thread_destory(&worker_threads[i]); + gb_thread_destroy(&worker_threads[i]); } return cast(ParseFileError)t->return_value; } @@ -5137,7 +5136,7 @@ ParseFileError parse_files(Parser *p, String init_filename) { } for_array(i, worker_threads) { - gb_thread_destory(&worker_threads[i]); + gb_thread_destroy(&worker_threads[i]); } } else { for_array(i, p->imports) { diff --git a/src/ssa.cpp b/src/ssa.cpp index 94ee4f15e..b3681b3ed 100644 --- a/src/ssa.cpp +++ b/src/ssa.cpp @@ -1640,18 +1640,18 @@ ssaValue *ssa_build_expr(ssaProc *p, AstNode *expr) { i64 s = 8*type_size_of(p->allocator, t); switch (s) { - case 8: return ssa_const_i8 (p, tv.type, i128_to_i64(tv.value.value_integer)); - case 16: return ssa_const_i16(p, tv.type, i128_to_i64(tv.value.value_integer)); - case 32: return ssa_const_i32(p, tv.type, i128_to_i64(tv.value.value_integer)); - case 64: return ssa_const_i64(p, tv.type, i128_to_i64(tv.value.value_integer)); + case 8: return ssa_const_i8 (p, tv.type, cast (i8)i128_to_i64(tv.value.value_integer)); + case 16: return ssa_const_i16(p, tv.type, cast(i16)i128_to_i64(tv.value.value_integer)); + case 32: return ssa_const_i32(p, tv.type, cast(i32)i128_to_i64(tv.value.value_integer)); + case 64: return ssa_const_i64(p, tv.type, cast(i64)i128_to_i64(tv.value.value_integer)); default: GB_PANIC("Unknown integer size"); } } else if (is_type_float(t)) { GB_ASSERT(tv.value.kind == ExactValue_Float); i64 s = 8*type_size_of(p->allocator, t); switch (s) { - case 32: return ssa_const_f32(p, tv.type, tv.value.value_float); - case 64: return ssa_const_f64(p, tv.type, tv.value.value_float); + case 32: return ssa_const_f32(p, tv.type, cast(f32)tv.value.value_float); + case 64: return ssa_const_f64(p, tv.type, cast(f64)tv.value.value_float); default: GB_PANIC("Unknown float size"); } } diff --git a/src/string.cpp b/src/string.cpp index f9aaa8e11..20c5e28c9 100644 --- a/src/string.cpp +++ b/src/string.cpp @@ -196,7 +196,6 @@ gb_inline bool str_has_prefix(String s, String prefix) { gb_inline isize string_extension_position(String str) { isize dot_pos = -1; isize i = str.len; - bool seen_dot = false; while (i --> 0) { if (str[i] == GB_PATH_SEPARATOR) break; @@ -317,14 +316,14 @@ String16 string_to_string16(gbAllocator a, String s) { return make_string16(nullptr, 0); } - len = convert_multibyte_to_widechar(cast(char *)s.text, s.len, nullptr, 0); + len = convert_multibyte_to_widechar(cast(char *)s.text, cast(int)s.len, nullptr, 0); if (len == 0) { return make_string16(nullptr, 0); } text = gb_alloc_array(a, wchar_t, len+1); - len1 = convert_multibyte_to_widechar(cast(char *)s.text, s.len, text, len); + len1 = convert_multibyte_to_widechar(cast(char *)s.text, cast(int)s.len, text, cast(int)len); if (len1 == 0) { gb_free(a, text); return make_string16(nullptr, 0); @@ -343,7 +342,7 @@ String string16_to_string(gbAllocator a, String16 s) { return make_string(nullptr, 0); } - len = convert_widechar_to_multibyte(s.text, s.len, nullptr, 0); + len = convert_widechar_to_multibyte(s.text, cast(int)s.len, nullptr, 0); if (len == 0) { return make_string(nullptr, 0); } @@ -351,7 +350,7 @@ String string16_to_string(gbAllocator a, String16 s) { text = gb_alloc_array(a, u8, len+1); - len1 = convert_widechar_to_multibyte(s.text, s.len, cast(char *)text, len); + len1 = convert_widechar_to_multibyte(s.text, cast(int)s.len, cast(char *)text, cast(int)len); if (len1 == 0) { gb_free(a, text); return make_string(nullptr, 0); diff --git a/src/types.cpp b/src/types.cpp index 86b673796..dd05f3238 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -551,9 +551,9 @@ Type *make_type_proc(gbAllocator a, Scope *scope, Type *params, isize param_coun t->Proc.scope = scope; t->Proc.params = params; - t->Proc.param_count = param_count; + t->Proc.param_count = cast(i32)param_count; t->Proc.results = results; - t->Proc.result_count = result_count; + t->Proc.result_count = cast(i32)result_count; t->Proc.variadic = variadic; t->Proc.calling_convention = calling_convention; return t; @@ -1400,7 +1400,7 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) { GB_ASSERT(is_type_struct(type) || is_type_union(type) || is_type_tuple(type)); type = base_type(type); - i64 max_count = 0; + isize max_count = 0; switch (type->kind) { case Type_Struct: max_count = type->Struct.fields.count; break; case Type_Tuple: max_count = type->Tuple.variables.count; break; @@ -1419,7 +1419,7 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) { if (f->Variable.field_src_index == index) { Array sel_array = {0}; array_init_count(&sel_array, a, 1); - sel_array[0] = i; + sel_array[0] = cast(i32)i; return make_selection(f, sel_array, false); } } @@ -1431,7 +1431,7 @@ Selection lookup_field_from_index(gbAllocator a, Type *type, i64 index) { if (i == index) { Array sel_array = {0}; array_init_count(&sel_array, a, 1); - sel_array[0] = i; + sel_array[0] = cast(i32)i; return make_selection(f, sel_array, false); } } @@ -2192,7 +2192,7 @@ i64 type_offset_of_from_selection(gbAllocator allocator, Type *type, Selection s Type *t = type; i64 offset = 0; for_array(i, sel.index) { - isize index = sel.index[i]; + i32 index = sel.index[i]; t = base_type(t); offset += type_offset_of(allocator, t, index); if (t->kind == Type_Struct && !t->Struct.is_raw_union) {