diff --git a/src/build_settings.cpp b/src/build_settings.cpp index 9f9844279..7fc049ef3 100644 --- a/src/build_settings.cpp +++ b/src/build_settings.cpp @@ -518,8 +518,8 @@ String internal_odin_root_dir(void) { } len += 1; // NOTE(bill): It needs an extra 1 for some reason - gb_mutex_lock(&string_buffer_mutex); - defer (gb_mutex_unlock(&string_buffer_mutex)); + mutex_lock(&string_buffer_mutex); + defer (mutex_unlock(&string_buffer_mutex)); tmp = gb_temp_arena_memory_begin(&string_buffer_arena); defer (gb_temp_arena_memory_end(tmp)); @@ -576,8 +576,8 @@ String internal_odin_root_dir(void) { } } - gb_mutex_lock(&string_buffer_mutex); - defer (gb_mutex_unlock(&string_buffer_mutex)); + mutex_lock(&string_buffer_mutex); + defer (mutex_unlock(&string_buffer_mutex)); tmp = gb_temp_arena_memory_begin(&string_buffer_arena); defer (gb_temp_arena_memory_end(tmp)); @@ -653,8 +653,8 @@ String internal_odin_root_dir(void) { array_resize(&path_buf, 2*path_buf.count + 300); } - gb_mutex_lock(&string_buffer_mutex); - defer (gb_mutex_unlock(&string_buffer_mutex)); + mutex_lock(&string_buffer_mutex); + defer (mutex_unlock(&string_buffer_mutex)); tmp = gb_temp_arena_memory_begin(&string_buffer_arena); defer (gb_temp_arena_memory_end(tmp)); @@ -683,8 +683,8 @@ String internal_odin_root_dir(void) { #if defined(GB_SYSTEM_WINDOWS) String path_to_fullpath(gbAllocator a, String s) { String result = {}; - gb_mutex_lock(&string_buffer_mutex); - defer (gb_mutex_unlock(&string_buffer_mutex)); + mutex_lock(&string_buffer_mutex); + defer (mutex_unlock(&string_buffer_mutex)); gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&string_buffer_arena); defer (gb_temp_arena_memory_end(tmp)); @@ -711,9 +711,9 @@ String path_to_fullpath(gbAllocator a, String s) { #elif defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_UNIX) String path_to_fullpath(gbAllocator a, String s) { char *p; - gb_mutex_lock(&string_buffer_mutex); + mutex_lock(&string_buffer_mutex); p = realpath(cast(char *)s.text, 0); - gb_mutex_unlock(&string_buffer_mutex); + mutex_unlock(&string_buffer_mutex); if(p == nullptr) return String{}; return make_string_c(p); } diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index 03ee6eb14..1b68728a0 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -242,7 +242,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 String original_string = o.value.value_string; - gbMutex *ignore_mutex = nullptr; + BlockingMutex *ignore_mutex = nullptr; String path = {}; bool ok = determine_path_from_string(ignore_mutex, call, base_dir, original_string, &path); diff --git a/src/check_decl.cpp b/src/check_decl.cpp index cc3ec6e5b..32a333ce3 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -1116,7 +1116,7 @@ void check_entity_decl(CheckerContext *ctx, Entity *e, DeclInfo *d, Type *named_ return; } if (e->flags & EntityFlag_Lazy) { - gb_mutex_lock(&ctx->info->lazy_mutex); + mutex_lock(&ctx->info->lazy_mutex); } String name = e->token.string; @@ -1173,7 +1173,7 @@ end:; } if (e->flags & EntityFlag_Lazy) { - gb_mutex_unlock(&ctx->info->lazy_mutex); + mutex_unlock(&ctx->info->lazy_mutex); } } diff --git a/src/check_expr.cpp b/src/check_expr.cpp index a789a181e..09bd5f8ed 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -240,8 +240,8 @@ bool find_or_generate_polymorphic_procedure(CheckerContext *c, Entity *base_enti GB_ASSERT(dst == nullptr); } - gb_mutex_lock(&info->gen_procs_mutex); - defer (gb_mutex_unlock(&info->gen_procs_mutex)); + mutex_lock(&info->gen_procs_mutex); + defer (mutex_unlock(&info->gen_procs_mutex)); if (!src->Proc.is_polymorphic || src->Proc.is_poly_specialized) { return false; diff --git a/src/check_type.cpp b/src/check_type.cpp index f65768277..4822b3f0d 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -236,8 +236,8 @@ bool check_custom_align(CheckerContext *ctx, Ast *node, i64 *align_) { Entity *find_polymorphic_record_entity(CheckerContext *ctx, Type *original_type, isize param_count, Array const &ordered_operands, bool *failure) { - gb_mutex_lock(&ctx->info->gen_types_mutex); - defer (gb_mutex_unlock(&ctx->info->gen_types_mutex)); + mutex_lock(&ctx->info->gen_types_mutex); + defer (mutex_unlock(&ctx->info->gen_types_mutex)); auto *found_gen_types = map_get(&ctx->info->gen_types, hash_pointer(original_type)); if (found_gen_types != nullptr) { @@ -318,7 +318,7 @@ void add_polymorphic_record_entity(CheckerContext *ctx, Ast *node, Type *named_t named_type->Named.type_name = e; - gb_mutex_lock(&ctx->info->gen_types_mutex); + mutex_lock(&ctx->info->gen_types_mutex); auto *found_gen_types = map_get(&ctx->info->gen_types, hash_pointer(original_type)); if (found_gen_types) { array_add(found_gen_types, e); @@ -327,7 +327,7 @@ void add_polymorphic_record_entity(CheckerContext *ctx, Ast *node, Type *named_t array_add(&array, e); map_set(&ctx->info->gen_types, hash_pointer(original_type), array); } - gb_mutex_unlock(&ctx->info->gen_types_mutex); + mutex_unlock(&ctx->info->gen_types_mutex); } Type *check_record_polymorphic_params(CheckerContext *ctx, Ast *polymorphic_params, diff --git a/src/checker.cpp b/src/checker.cpp index 649f84c93..30413f716 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -860,9 +860,9 @@ void init_checker_info(CheckerInfo *i) { TIME_SECTION("checker info: mutexes"); - gb_mutex_init(&i->gen_procs_mutex); - gb_mutex_init(&i->gen_types_mutex); - gb_mutex_init(&i->lazy_mutex); + mutex_init(&i->gen_procs_mutex); + mutex_init(&i->gen_types_mutex); + mutex_init(&i->lazy_mutex); mutex_init(&i->type_info_mutex); mutex_init(&i->deps_mutex); @@ -895,9 +895,9 @@ void destroy_checker_info(CheckerInfo *i) { mpmc_destroy(&i->required_global_variable_queue); mpmc_destroy(&i->required_foreign_imports_through_force_queue); - gb_mutex_destroy(&i->gen_procs_mutex); - gb_mutex_destroy(&i->gen_types_mutex); - gb_mutex_destroy(&i->lazy_mutex); + mutex_destroy(&i->gen_procs_mutex); + mutex_destroy(&i->gen_types_mutex); + mutex_destroy(&i->lazy_mutex); mutex_destroy(&i->type_info_mutex); mutex_destroy(&i->deps_mutex); mutex_destroy(&i->identifier_uses_mutex); diff --git a/src/checker.hpp b/src/checker.hpp index cf39bdd76..2b77f96e3 100644 --- a/src/checker.hpp +++ b/src/checker.hpp @@ -300,10 +300,10 @@ struct CheckerInfo { // too much of a problem in practice BlockingMutex deps_mutex; - gbMutex lazy_mutex; // Mutex required for lazy type checking of specific files + RecursiveMutex lazy_mutex; // Mutex required for lazy type checking of specific files - gbMutex gen_procs_mutex; // Possibly recursive - gbMutex gen_types_mutex; // Possibly recursive + RecursiveMutex gen_procs_mutex; + RecursiveMutex gen_types_mutex; Map > gen_procs; // Key: Ast * | Identifier -> Entity Map > gen_types; // Key: Type * diff --git a/src/common.cpp b/src/common.cpp index 0e11ed5a6..8a51bbcb5 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -29,6 +29,64 @@ #include #include // Because I wanted the C++11 memory order semantics, of which gb.h does not offer (because it was a C89 library) + +#if defined(GB_SYSTEM_WINDOWS) + struct BlockingMutex { + SRWLOCK srwlock; + }; + void mutex_init(BlockingMutex *m) { + } + void mutex_destroy(BlockingMutex *m) { + } + void mutex_lock(BlockingMutex *m) { + AcquireSRWLockExclusive(&m->srwlock); + } + bool mutex_try_lock(BlockingMutex *m) { + return !!TryAcquireSRWLockExclusive(&m->srwlock); + } + void mutex_unlock(BlockingMutex *m) { + ReleaseSRWLockExclusive(&m->srwlock); + } +#else + typedef gbMutex BlockingMutex; + void mutex_init(BlockingMutex *m) { + gb_mutex_init(m); + } + void mutex_destroy(BlockingMutex *m) { + gb_mutex_destroy(m); + } + void mutex_lock(BlockingMutex *m) { + gb_mutex_lock(m); + } + bool mutex_try_lock(BlockingMutex *m) { + return !!gb_mutex_try_lock(m); + } + void mutex_unlock(BlockingMutex *m) { + gb_mutex_unlock(m); + } +#endif + +struct RecursiveMutex { + gbMutex mutex; +}; +void mutex_init(RecursiveMutex *m) { + gb_mutex_init(&m->mutex); +} +void mutex_destroy(RecursiveMutex *m) { + gb_mutex_destroy(&m->mutex); +} +void mutex_lock(RecursiveMutex *m) { + gb_mutex_lock(&m->mutex); +} +bool mutex_try_lock(RecursiveMutex *m) { + return gb_mutex_try_lock(&m->mutex); +} +void mutex_unlock(RecursiveMutex *m) { + gb_mutex_unlock(&m->mutex); +} + + + gb_inline void zero_size(void *ptr, isize len) { memset(ptr, 0, len); } @@ -1300,41 +1358,3 @@ Slice did_you_mean_results(DidYouMeanAnswers *d) { } return slice_array(d->distances, 0, count); } - - - -#if defined(GB_SYSTEM_WINDOWS) - struct BlockingMutex { - SRWLOCK srwlock; - }; - void mutex_init(BlockingMutex *m) { - } - void mutex_destroy(BlockingMutex *m) { - } - void mutex_lock(BlockingMutex *m) { - AcquireSRWLockExclusive(&m->srwlock); - } - bool mutex_try_lock(BlockingMutex *m) { - return !!TryAcquireSRWLockExclusive(&m->srwlock); - } - void mutex_unlock(BlockingMutex *m) { - ReleaseSRWLockExclusive(&m->srwlock); - } -#else - typedef gbMutex BlockingMutex; - void mutex_init(BlockingMutex *m) { - gb_mutex_init(m); - } - void mutex_destroy(BlockingMutex *m) { - gb_mutex_destroy(m); - } - void mutex_lock(BlockingMutex *m) { - gb_mutex_lock(m); - } - bool mutex_try_lock(BlockingMutex *m) { - return !!gb_mutex_try_lock(m); - } - void mutex_unlock(BlockingMutex *m) { - gb_mutex_unlock(m); - } -#endif diff --git a/src/parser.cpp b/src/parser.cpp index afead99c6..f20c29558 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -4664,9 +4664,9 @@ bool init_parser(Parser *p) { string_map_init(&p->package_map, heap_allocator()); array_init(&p->packages, heap_allocator()); array_init(&p->package_imports, heap_allocator()); - gb_mutex_init(&p->import_mutex); - gb_mutex_init(&p->file_add_mutex); - gb_mutex_init(&p->file_decl_mutex); + mutex_init(&p->import_mutex); + mutex_init(&p->file_add_mutex); + mutex_init(&p->file_decl_mutex); mpmc_init(&p->file_error_queue, heap_allocator(), 1024); return true; } @@ -4691,9 +4691,9 @@ void destroy_parser(Parser *p) { array_free(&p->package_imports); string_set_destroy(&p->imported_files); string_map_destroy(&p->package_map); - gb_mutex_destroy(&p->import_mutex); - gb_mutex_destroy(&p->file_add_mutex); - gb_mutex_destroy(&p->file_decl_mutex); + mutex_destroy(&p->import_mutex); + mutex_destroy(&p->file_add_mutex); + mutex_destroy(&p->file_decl_mutex); mpmc_destroy(&p->file_error_queue); } @@ -4760,9 +4760,9 @@ WORKER_TASK_PROC(foreign_file_worker_proc) { // TODO(bill): Actually do something with it break; } - gb_mutex_lock(&p->file_add_mutex); + mutex_lock(&p->file_add_mutex); array_add(&pkg->foreign_files, foreign_file); - gb_mutex_unlock(&p->file_add_mutex); + mutex_unlock(&p->file_add_mutex); return 0; } @@ -4782,8 +4782,8 @@ void parser_add_foreign_file_to_process(Parser *p, AstPackage *pkg, AstForeignFi AstPackage *try_add_import_path(Parser *p, String const &path, String const &rel_path, TokenPos pos, PackageKind kind = Package_Normal) { String const FILE_EXT = str_lit(".odin"); - gb_mutex_lock(&p->import_mutex); - defer (gb_mutex_unlock(&p->import_mutex)); + mutex_lock(&p->import_mutex); + defer (mutex_unlock(&p->import_mutex)); if (string_set_exists(&p->imported_files, path)) { return nullptr; @@ -4962,7 +4962,7 @@ bool is_package_name_reserved(String const &name) { } -bool determine_path_from_string(gbMutex *file_mutex, Ast *node, String base_dir, String original_string, String *path) { +bool determine_path_from_string(BlockingMutex *file_mutex, Ast *node, String base_dir, String original_string, String *path) { GB_ASSERT(path != nullptr); // NOTE(bill): if file_mutex == nullptr, this means that the code is used within the semantics stage @@ -5052,8 +5052,8 @@ bool determine_path_from_string(gbMutex *file_mutex, Ast *node, String base_dir, return true; } - if (file_mutex) gb_mutex_lock(file_mutex); - defer (if (file_mutex) gb_mutex_unlock(file_mutex)); + if (file_mutex) mutex_lock(file_mutex); + defer (if (file_mutex) mutex_unlock(file_mutex)); if (node->kind == Ast_ForeignImportDecl) { @@ -5452,8 +5452,8 @@ ParseFileError process_imported_file(Parser *p, ImportedFile const &imported_fil } if (parse_file(p, file)) { - gb_mutex_lock(&p->file_add_mutex); - defer (gb_mutex_unlock(&p->file_add_mutex)); + mutex_lock(&p->file_add_mutex); + defer (mutex_unlock(&p->file_add_mutex)); array_add(&file->pkg->files, file); diff --git a/src/parser.hpp b/src/parser.hpp index d7d972f9e..73fb537e7 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -192,9 +192,9 @@ struct Parser { isize file_to_process_count; isize total_token_count; isize total_line_count; - gbMutex import_mutex; - gbMutex file_add_mutex; - gbMutex file_decl_mutex; + BlockingMutex import_mutex; + BlockingMutex file_add_mutex; + BlockingMutex file_decl_mutex; MPMCQueue file_error_queue; }; diff --git a/src/queue.cpp b/src/queue.cpp index 4d7c0f052..db92ec72a 100644 --- a/src/queue.cpp +++ b/src/queue.cpp @@ -18,7 +18,7 @@ struct MPMCQueue { CacheLinePad pad0; isize mask; Array> buffer; - gbMutex mutex; + BlockingMutex mutex; std::atomic count; CacheLinePad pad1; @@ -37,7 +37,7 @@ void mpmc_init(MPMCQueue *q, gbAllocator a, isize size) { size = next_pow2_isize(size); GB_ASSERT(gb_is_power_of_two(size)); - gb_mutex_init(&q->mutex); + mutex_init(&q->mutex); q->mask = size-1; array_init(&q->buffer, a, size); @@ -57,7 +57,7 @@ void mpmc_init(MPMCQueue *q, gbAllocator a, isize size) { template void mpmc_destroy(MPMCQueue *q) { - gb_mutex_destroy(&q->mutex); + mutex_destroy(&q->mutex); gb_free(q->buffer.allocator, q->buffer.data); } @@ -83,13 +83,13 @@ isize mpmc_enqueue(MPMCQueue *q, T const &data) { return q->count.fetch_add(1, std::memory_order_release); } } else if (diff < 0) { - gb_mutex_lock(&q->mutex); + mutex_lock(&q->mutex); isize old_size = q->buffer.count; isize new_size = old_size*2; array_resize(&q->buffer, new_size); if (q->buffer.data == nullptr) { GB_PANIC("Unable to resize enqueue: %td -> %td", old_size, new_size); - gb_mutex_unlock(&q->mutex); + mutex_unlock(&q->mutex); return -1; } // NOTE(bill): pretend it's not atomic for performance @@ -98,7 +98,7 @@ isize mpmc_enqueue(MPMCQueue *q, T const &data) { raw_data[i].idx = i; } q->mask = new_size-1; - gb_mutex_unlock(&q->mutex); + mutex_unlock(&q->mutex); } else { head_idx = q->head_idx.load(std::memory_order_relaxed); } diff --git a/src/string.cpp b/src/string.cpp index 9cb5933e0..4e8273f60 100644 --- a/src/string.cpp +++ b/src/string.cpp @@ -1,12 +1,12 @@ -gb_global gbArena string_buffer_arena = {}; -gb_global gbAllocator string_buffer_allocator = {}; -gb_global gbMutex string_buffer_mutex = {}; +gb_global gbArena string_buffer_arena = {}; +gb_global gbAllocator string_buffer_allocator = {}; +gb_global BlockingMutex string_buffer_mutex = {}; void init_string_buffer_memory(void) { // NOTE(bill): This should be enough memory for file systems gb_arena_init_from_allocator(&string_buffer_arena, heap_allocator(), gb_megabytes(1)); string_buffer_allocator = gb_arena_allocator(&string_buffer_arena); - gb_mutex_init(&string_buffer_mutex); + mutex_init(&string_buffer_mutex); } diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp index edffb7446..9a0a1c17c 100644 --- a/src/tokenizer.cpp +++ b/src/tokenizer.cpp @@ -264,8 +264,9 @@ struct ErrorCollector { i64 count; i64 warning_count; bool in_block; - gbMutex mutex; - gbMutex string_mutex; + BlockingMutex mutex; + BlockingMutex error_out_mutex; + BlockingMutex string_mutex; Array error_buffer; Array errors; @@ -281,8 +282,9 @@ bool any_errors(void) { } void init_global_error_collector(void) { - gb_mutex_init(&global_error_collector.mutex); - gb_mutex_init(&global_error_collector.string_mutex); + mutex_init(&global_error_collector.mutex); + mutex_init(&global_error_collector.error_out_mutex); + mutex_init(&global_error_collector.string_mutex); array_init(&global_error_collector.errors, heap_allocator()); array_init(&global_error_collector.error_buffer, heap_allocator()); array_init(&global_file_path_strings, heap_allocator(), 4096); @@ -293,7 +295,7 @@ void init_global_error_collector(void) { bool set_file_path_string(i32 index, String const &path) { bool ok = false; GB_ASSERT(index >= 0); - gb_mutex_lock(&global_error_collector.string_mutex); + mutex_lock(&global_error_collector.string_mutex); if (index >= global_file_path_strings.count) { array_resize(&global_file_path_strings, index); @@ -304,14 +306,14 @@ bool set_file_path_string(i32 index, String const &path) { ok = true; } - gb_mutex_unlock(&global_error_collector.string_mutex); + mutex_unlock(&global_error_collector.string_mutex); return ok; } bool set_ast_file_from_id(i32 index, AstFile *file) { bool ok = false; GB_ASSERT(index >= 0); - gb_mutex_lock(&global_error_collector.string_mutex); + mutex_lock(&global_error_collector.string_mutex); if (index >= global_files.count) { array_resize(&global_files, index); @@ -322,39 +324,40 @@ bool set_ast_file_from_id(i32 index, AstFile *file) { ok = true; } - gb_mutex_unlock(&global_error_collector.string_mutex); + mutex_unlock(&global_error_collector.string_mutex); return ok; } String get_file_path_string(i32 index) { GB_ASSERT(index >= 0); - gb_mutex_lock(&global_error_collector.string_mutex); + mutex_lock(&global_error_collector.string_mutex); String path = {}; if (index < global_file_path_strings.count) { path = global_file_path_strings[index]; } - gb_mutex_unlock(&global_error_collector.string_mutex); + mutex_unlock(&global_error_collector.string_mutex); return path; } AstFile *get_ast_file_from_id(i32 index) { GB_ASSERT(index >= 0); - gb_mutex_lock(&global_error_collector.string_mutex); + mutex_lock(&global_error_collector.string_mutex); AstFile *file = nullptr; if (index < global_files.count) { file = global_files[index]; } - gb_mutex_unlock(&global_error_collector.string_mutex); + mutex_unlock(&global_error_collector.string_mutex); return file; } + void begin_error_block(void) { - gb_mutex_lock(&global_error_collector.mutex); + mutex_lock(&global_error_collector.mutex); global_error_collector.in_block = true; } @@ -367,13 +370,10 @@ void end_error_block(void) { String s = {text, n}; array_add(&global_error_collector.errors, s); global_error_collector.error_buffer.count = 0; - - // gbFile *f = gb_file_get_standard(gbFileStandard_Error); - // gb_file_write(f, text, n); } global_error_collector.in_block = false; - gb_mutex_unlock(&global_error_collector.mutex); + mutex_unlock(&global_error_collector.mutex); } @@ -393,14 +393,14 @@ ERROR_OUT_PROC(default_error_out_va) { gb_memmove(data, buf, n); global_error_collector.error_buffer.count += n; } else { - gb_mutex_lock(&global_error_collector.mutex); + mutex_lock(&global_error_collector.error_out_mutex); { u8 *text = gb_alloc_array(heap_allocator(), u8, n+1); gb_memmove(text, buf, n); text[n] = 0; array_add(&global_error_collector.errors, make_string(text, n)); } - gb_mutex_unlock(&global_error_collector.mutex); + mutex_unlock(&global_error_collector.error_out_mutex); } gb_file_write(f, buf, n); @@ -491,7 +491,7 @@ bool show_error_on_line(TokenPos const &pos, TokenPos end) { } void error_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) { - gb_mutex_lock(&global_error_collector.mutex); + mutex_lock(&global_error_collector.mutex); global_error_collector.count++; // NOTE(bill): Duplicate error, skip it if (pos.line == 0) { @@ -503,7 +503,7 @@ void error_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) { gb_bprintf_va(fmt, va)); show_error_on_line(pos, end); } - gb_mutex_unlock(&global_error_collector.mutex); + mutex_unlock(&global_error_collector.mutex); if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT) { gb_exit(1); } @@ -514,7 +514,7 @@ void warning_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) error_va(pos, end, fmt, va); return; } - gb_mutex_lock(&global_error_collector.mutex); + mutex_lock(&global_error_collector.mutex); global_error_collector.warning_count++; if (!global_ignore_warnings()) { // NOTE(bill): Duplicate error, skip it @@ -528,18 +528,16 @@ void warning_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) show_error_on_line(pos, end); } } - gb_mutex_unlock(&global_error_collector.mutex); + mutex_unlock(&global_error_collector.mutex); } void error_line_va(char const *fmt, va_list va) { - gb_mutex_lock(&global_error_collector.mutex); error_out_va(fmt, va); - gb_mutex_unlock(&global_error_collector.mutex); } void error_no_newline_va(TokenPos const &pos, char const *fmt, va_list va) { - gb_mutex_lock(&global_error_collector.mutex); + mutex_lock(&global_error_collector.mutex); global_error_collector.count++; // NOTE(bill): Duplicate error, skip it if (pos.line == 0) { @@ -550,7 +548,7 @@ void error_no_newline_va(TokenPos const &pos, char const *fmt, va_list va) { token_pos_to_string(pos), gb_bprintf_va(fmt, va)); } - gb_mutex_unlock(&global_error_collector.mutex); + mutex_unlock(&global_error_collector.mutex); if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT) { gb_exit(1); } @@ -558,7 +556,7 @@ void error_no_newline_va(TokenPos const &pos, char const *fmt, va_list va) { void syntax_error_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) { - gb_mutex_lock(&global_error_collector.mutex); + mutex_lock(&global_error_collector.mutex); global_error_collector.count++; // NOTE(bill): Duplicate error, skip it if (global_error_collector.prev != pos) { @@ -571,7 +569,7 @@ void syntax_error_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list error_out("Syntax Error: %s\n", gb_bprintf_va(fmt, va)); } - gb_mutex_unlock(&global_error_collector.mutex); + mutex_unlock(&global_error_collector.mutex); if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT) { gb_exit(1); } @@ -582,7 +580,7 @@ void syntax_warning_va(TokenPos const &pos, TokenPos end, char const *fmt, va_li syntax_error_va(pos, end, fmt, va); return; } - gb_mutex_lock(&global_error_collector.mutex); + mutex_lock(&global_error_collector.mutex); global_error_collector.warning_count++; if (!global_ignore_warnings()) { // NOTE(bill): Duplicate error, skip it @@ -596,7 +594,7 @@ void syntax_warning_va(TokenPos const &pos, TokenPos end, char const *fmt, va_li error_out("Warning: %s\n", gb_bprintf_va(fmt, va)); } } - gb_mutex_unlock(&global_error_collector.mutex); + mutex_unlock(&global_error_collector.mutex); } diff --git a/src/types.cpp b/src/types.cpp index dac2632a9..085bf67b7 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -661,7 +661,7 @@ gb_global Type *t_map_header = nullptr; gb_global Type *t_equal_proc = nullptr; gb_global Type *t_hasher_proc = nullptr; -gb_global gbMutex g_type_mutex; +gb_global RecursiveMutex g_type_mutex; i64 type_size_of (Type *t); @@ -677,7 +677,7 @@ bool is_type_slice(Type *t); bool is_type_integer(Type *t); void init_type_mutex(void) { - gb_mutex_init(&g_type_mutex); + mutex_init(&g_type_mutex); } bool type_ptr_set_exists(PtrSet *s, Type *t) { @@ -2850,8 +2850,8 @@ i64 type_align_of_internal(Type *t, TypePath *path) { if (t->failure) { return FAILURE_ALIGNMENT; } - gb_mutex_lock(&g_type_mutex); - defer (gb_mutex_unlock(&g_type_mutex)); + mutex_lock(&g_type_mutex); + defer (mutex_unlock(&g_type_mutex)); t = base_type(t); @@ -3046,8 +3046,8 @@ Array type_set_offsets_of(Array const &fields, bool is_packed, bo } bool type_set_offsets(Type *t) { - gb_mutex_lock(&g_type_mutex); - defer (gb_mutex_unlock(&g_type_mutex)); + mutex_lock(&g_type_mutex); + defer (mutex_unlock(&g_type_mutex)); t = base_type(t); if (t->kind == Type_Struct) { @@ -3077,8 +3077,8 @@ i64 type_size_of_internal(Type *t, TypePath *path) { if (t->failure) { return FAILURE_SIZE; } - gb_mutex_lock(&g_type_mutex); - defer (gb_mutex_unlock(&g_type_mutex)); + mutex_lock(&g_type_mutex); + defer (mutex_unlock(&g_type_mutex)); switch (t->kind) {