diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp index e1615ce87..acbb303c1 100644 --- a/src/check_builtin.cpp +++ b/src/check_builtin.cpp @@ -270,6 +270,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 BlockingMutex *ignore_mutex = nullptr; String path = {}; bool ok = determine_path_from_string(ignore_mutex, call, base_dir, original_string, &path); + gb_unused(ok); char *c_str = alloc_cstring(a, path); defer (gb_free(a, c_str)); @@ -369,6 +370,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 } bool is_defined = check_identifier_exists(c->scope, arg); + gb_unused(is_defined); operand->type = t_untyped_bool; operand->mode = Addressing_Constant; operand->value = exact_value_bool(false); diff --git a/src/check_decl.cpp b/src/check_decl.cpp index 06214810b..c8bacb9b2 100644 --- a/src/check_decl.cpp +++ b/src/check_decl.cpp @@ -384,7 +384,6 @@ void check_const_decl(CheckerContext *ctx, Entity *e, Ast *type_expr, Ast *init, Operand operand = {}; - Entity *other_entity = nullptr; if (init != nullptr) { Entity *entity = nullptr; if (init->kind == Ast_Ident) { @@ -1287,9 +1286,9 @@ void check_proc_body(CheckerContext *ctx_, Token token, DeclInfo *decl, Type *ty check_open_scope(ctx, body); { for_array(i, using_entities) { - Entity *e = using_entities[i].e; Entity *uvar = using_entities[i].uvar; Entity *prev = scope_insert(ctx->scope, uvar); + gb_unused(prev); // NOTE(bill): Don't err here } diff --git a/src/check_expr.cpp b/src/check_expr.cpp index 581021ac7..9e6a47a4e 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -913,7 +913,6 @@ bool is_polymorphic_type_assignable(CheckerContext *c, Type *poly, Type *source, Entity *e = scope_lookup(gt->Generic.scope, gt->Generic.name); GB_ASSERT(e != nullptr); if (e->kind == Entity_TypeName) { - Type *elem = poly->Array.elem; Type *index = source->EnumeratedArray.index; Type *it = base_type(index); if (it->kind != Type_Enum) { @@ -2399,7 +2398,6 @@ bool check_is_castable_to(CheckerContext *c, Operand *operand, Type *y) { bool check_cast_internal(CheckerContext *c, Operand *x, Type *type) { bool is_const_expr = x->mode == Addressing_Constant; - bool can_convert = false; Type *bt = base_type(type); if (is_const_expr && is_type_constant_type(bt)) { @@ -3181,10 +3179,8 @@ void convert_to_typed(CheckerContext *c, Operand *operand, Type *target_type) { if (valid_count > 1) { gb_sort_array(valids, valid_count, valid_index_and_score_cmp); i64 best_score = valids[0].score; - Type *best_type = t->Union.variants[valids[0].index]; for (isize i = 1; i < valid_count; i++) { auto v = valids[i]; - Type *vt = t->Union.variants[v.index]; if (best_score > v.score) { valid_count = i; break; @@ -3557,7 +3553,6 @@ ExactValue get_constant_field(CheckerContext *c, Operand const *operand, Selecti ExactValue value = operand->value; if (value.kind == ExactValue_Compound) { - i32 depth = 0; while (sel.index.count > 0) { i32 index = sel.index[0]; sel = sub_selection(sel, 1); @@ -3712,7 +3707,6 @@ Entity *check_selector(CheckerContext *c, Operand *operand, Ast *node, Type *typ add_entity_use(c, op_expr, e); expr_entity = e; - Entity *original_e = e; if (e != nullptr && e->kind == Entity_ImportName && selector->kind == Ast_Ident) { // IMPORTANT NOTE(bill): This is very sloppy code but it's also very fragile // It pretty much needs to be in this order and this way @@ -4163,7 +4157,6 @@ bool check_assignment_arguments(CheckerContext *ctx, Array const &lhs, if (o.type == nullptr || o.type->kind != Type_Tuple) { if (lhs.count == 2 && rhs.count == 1 && (o.mode == Addressing_MapIndex || o.mode == Addressing_OptionalOk || o.mode == Addressing_OptionalOkPtr)) { - bool do_normal = true; Ast *expr = unparen_expr(o.expr); Operand val0 = o; @@ -4269,7 +4262,6 @@ bool check_unpack_arguments(CheckerContext *ctx, Entity **lhs, isize lhs_count, if (o.type == nullptr || o.type->kind != Type_Tuple) { if (allow_ok && lhs_count == 2 && rhs.count == 1 && (o.mode == Addressing_MapIndex || o.mode == Addressing_OptionalOk || o.mode == Addressing_OptionalOkPtr)) { - bool do_normal = true; Ast *expr = unparen_expr(o.expr); Operand val0 = o; @@ -5348,6 +5340,7 @@ CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type proc_type = e->type; CallArgumentData data = {}; CallArgumentError err = call_checker(c, call, proc_type, e, operands, CallArgumentMode_ShowErrors, &data); + gb_unused(err); Entity *entity_to_use = data.gen_entity != nullptr ? data.gen_entity : e; add_entity_use(c, ident, entity_to_use); if (entity_to_use != nullptr) { @@ -5381,6 +5374,7 @@ CallArgumentData check_call_arguments(CheckerContext *c, Operand *operand, Type CallArgumentData data = {}; CallArgumentError err = call_checker(c, call, proc_type, e, operands, CallArgumentMode_ShowErrors, &data); + gb_unused(err); Entity *entity_to_use = data.gen_entity != nullptr ? data.gen_entity : e; add_entity_use(c, ident, entity_to_use); if (entity_to_use != nullptr) { @@ -6270,12 +6264,8 @@ bool attempt_implicit_selector_expr(CheckerContext *c, Operand *o, AstImplicitSe o->type = e->type; return true; } - bool show_error = true; if (is_type_union(th)) { Type *union_type = base_type(th); - isize enum_count = 0; - Type *et = nullptr; - auto operands = array_make(temporary_allocator(), 0, union_type->Union.variants.count); for_array(i, union_type->Union.variants) { @@ -6311,7 +6301,6 @@ ExprKind check_implicit_selector_expr(CheckerContext *c, Operand *o, Ast *node, return Expr_Expr; } o->type = th; - Type *enum_type = th; bool ok = attempt_implicit_selector_expr(c, o, ise, th); if (!ok) { @@ -7533,7 +7522,6 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type is_constant = false; } else { for_array(index, cl->elems) { - Entity *field = nullptr; Ast *elem = cl->elems[index]; if (elem->kind == Ast_FieldValue) { error(elem, "'field = value' in a bit_set a literal is not allowed"); @@ -7585,7 +7573,6 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type u64 bits = 0; for_array(index, cl->elems) { - Entity *field = nullptr; Ast *elem = cl->elems[index]; GB_ASSERT(elem->kind != Ast_FieldValue); TypeAndValue tav = elem->tav; @@ -7677,7 +7664,6 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type return kind; } - bool src_is_ptr = is_type_pointer(o->type); Type *src = type_deref(o->type); Type *bsrc = base_type(src); @@ -7725,8 +7711,6 @@ ExprKind check_expr_base_internal(CheckerContext *c, Operand *o, Ast *node, Type } else { Type *t = check_type(c, ta->type); Type *dst = t; - Type *bdst = base_type(dst); - if (is_type_union(src)) { bool ok = false; diff --git a/src/check_type.cpp b/src/check_type.cpp index 7dbd72612..d3bcb5bb6 100644 --- a/src/check_type.cpp +++ b/src/check_type.cpp @@ -59,9 +59,6 @@ void populate_using_entity_scope(CheckerContext *ctx, Ast *node, AstField *field } } } else if (t->kind == Type_Array && t->Array.count <= 4) { - Entity *e = nullptr; - String name = {}; - i32 idx = 0; switch (t->Array.count) { case 4: populate_using_array_index(ctx, node, field, t, str_lit("w"), 3); @@ -121,8 +118,6 @@ void check_struct_fields(CheckerContext *ctx, Ast *node, Array *fields ast_node(p, Field, param); Ast *type_expr = p->type; Type *type = nullptr; - bool detemine_type_from_operand = false; - if (type_expr != nullptr) { type = check_type_expr(ctx, type_expr, nullptr); @@ -591,6 +586,7 @@ void check_struct_type(CheckerContext *ctx, Type *struct_type, Ast *node, Array< error(st->where_clauses[0], "'where' clauses can only be used on structures with polymorphic parameters"); } else { bool where_clause_ok = evaluate_where_clauses(ctx, node, ctx->scope, &st->where_clauses, true); + gb_unused(where_clause_ok); } check_struct_fields(ctx, node, &struct_type->Struct.fields, &struct_type->Struct.tags, st->fields, min_field_count, struct_type, context); } @@ -625,6 +621,7 @@ void check_union_type(CheckerContext *ctx, Type *union_type, Ast *node, Arraywhere_clauses[0], "'where' clauses can only be used on unions with polymorphic parameters"); } else { bool where_clause_ok = evaluate_where_clauses(ctx, node, ctx->scope, &ut->where_clauses, true); + gb_unused(where_clause_ok); } } @@ -1093,6 +1090,10 @@ bool check_type_specialization_to(CheckerContext *ctx, Type *specialization, Typ return false; } else { bool ok = is_polymorphic_type_assignable(ctx, st, tt, true, modify_type); + if (!ok) { + // TODO(bill, 2021-08-19): is this logic correct? + return false; + } } } } @@ -1133,6 +1134,10 @@ bool check_type_specialization_to(CheckerContext *ctx, Type *specialization, Typ } } else { bool ok = is_polymorphic_type_assignable(ctx, st, tt, true, modify_type); + if (!ok) { + // TODO(bill, 2021-08-19): is this logic correct? + return false; + } } } @@ -1297,8 +1302,6 @@ Type *check_get_params(CheckerContext *ctx, Scope *scope, Ast *_params, bool *is return nullptr; } - bool allow_polymorphic_types = ctx->allow_polymorphic_types; - bool success = true; ast_node(field_list, FieldList, _params); Slice params = field_list->list; @@ -1308,8 +1311,6 @@ Type *check_get_params(CheckerContext *ctx, Scope *scope, Ast *_params, bool *is return nullptr; } - - isize variable_count = 0; for_array(i, params) { Ast *field = params[i]; @@ -2080,7 +2081,6 @@ void init_map_entry_type(Type *type) { value: Value, } */ - Ast *dummy_node = alloc_ast_node(nullptr, Ast_Invalid); Scope *s = create_scope(nullptr, builtin_pkg->scope); auto fields = array_make(permanent_allocator(), 0, 4); @@ -2114,7 +2114,6 @@ void init_map_internal_types(Type *type) { entries: [dynamic]EntryType; } */ - Ast *dummy_node = alloc_ast_node(nullptr, Ast_Invalid); Scope *s = create_scope(nullptr, builtin_pkg->scope); Type *hashes_type = alloc_type_slice(t_int); @@ -2386,6 +2385,7 @@ bool check_type_internal(CheckerContext *ctx, Ast *e, Type **type, Type *named_t case_ast_node(i, Ident, e); Operand o = {}; Entity *entity = check_ident(ctx, &o, e, named_type, nullptr, false); + gb_unused(entity); gbString err_str = nullptr; defer (gb_string_free(err_str)); diff --git a/src/checker.cpp b/src/checker.cpp index aad54a20d..e3d80f68a 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -2112,9 +2112,6 @@ void add_entity_dependency_from_procedure_parameters(Map *M, if (tuple == nullptr) { return; } - Entity *e = n->entity; - bool print_deps = false; - GB_ASSERT(tuple->kind == Type_Tuple); TypeTuple *t = &tuple->Tuple; for_array(i, t->variables) { @@ -2138,7 +2135,6 @@ Array generate_entity_dependency_graph(CheckerInfo *info, gbA defer (map_destroy(&M)); for_array(i, info->entities) { Entity *e = info->entities[i]; - DeclInfo *d = e->decl_info; if (is_entity_a_dependency(e)) { EntityGraphNode *n = gb_alloc_item(allocator, EntityGraphNode); n->entity = e; @@ -4345,8 +4341,6 @@ void check_import_entities(Checker *c) { reset_checker_context(&ctx, f, &untyped); ctx.collect_delayed_decls = true; - MPMCQueue *q = nullptr; - // Check import declarations first to simplify things for (Ast *id = nullptr; mpmc_dequeue(&f->delayed_decls_queues[AstDelayQueue_Import], &id); /**/) { check_add_import_decl(&ctx, id); @@ -4730,7 +4724,6 @@ GB_THREAD_PROC(thread_proc_body) { ThreadProcBodyData *data = cast(ThreadProcBodyData *)thread->user_data; Checker *c = data->checker; GB_ASSERT(c != nullptr); - ThreadProcBodyData *all_data = data->all_data; ProcBodyQueue *this_queue = data->queue; UntypedExprInfoMap untyped = {}; @@ -4897,9 +4890,6 @@ void check_deferred_procedures(Checker *c) { GB_ASSERT(src_params->kind == Type_Tuple); GB_ASSERT(dst_params->kind == Type_Tuple); - auto const &sv = src_params->Tuple.variables; - auto const &dv = dst_params->Tuple.variables; - if (are_types_identical(src_params, dst_params)) { // Okay! } else { @@ -4928,9 +4918,6 @@ void check_deferred_procedures(Checker *c) { GB_ASSERT(src_results->kind == Type_Tuple); GB_ASSERT(dst_params->kind == Type_Tuple); - auto const &sv = src_results->Tuple.variables; - auto const &dv = dst_params->Tuple.variables; - if (are_types_identical(src_results, dst_params)) { // Okay! } else { @@ -4955,6 +4942,7 @@ void check_deferred_procedures(Checker *c) { Type *tsrc = alloc_type_tuple(); auto &sv = tsrc->Tuple.variables; auto const &dv = dst_params->Tuple.variables; + gb_unused(dv); isize len = 0; if (src_params != nullptr) { diff --git a/src/docs.cpp b/src/docs.cpp index 65166faa4..8d65cb83a 100644 --- a/src/docs.cpp +++ b/src/docs.cpp @@ -107,7 +107,6 @@ bool print_doc_comment_group_string(i32 indent, CommentGroup *g) { String original_comment = comment; bool slash_slash = comment[1] == '/'; - bool slash_star = comment[1] == '*'; if (comment[1] == '/') { comment.text += 2; comment.len -= 2; diff --git a/src/docs_writer.cpp b/src/docs_writer.cpp index 58e674d1d..8708724e8 100644 --- a/src/docs_writer.cpp +++ b/src/docs_writer.cpp @@ -301,7 +301,6 @@ bool odin_doc_append_comment_group_string(Array *buf, CommentGroup *g) { String original_comment = comment; bool slash_slash = comment[1] == '/'; - bool slash_star = comment[1] == '*'; if (comment[1] == '/') { comment.text += 2; comment.len -= 2; @@ -895,6 +894,7 @@ void odin_doc_update_entities(OdinDocWriter *w) { for_array(i, entities) { Entity *e = entities[i]; OdinDocTypeIndex type_index = odin_doc_type(w, e->type); + gb_unused(type_index); } } @@ -974,7 +974,6 @@ OdinDocArray odin_doc_add_pkg_entities(OdinDocWriter *w, Ast auto entity_indices = array_make(heap_allocator(), 0, w->entity_cache.entries.count); defer (array_free(&entity_indices)); - EntityKind curr_entity_kind = Entity_Invalid; for_array(i, entities) { Entity *e = entities[i]; if (e->pkg != pkg) { diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 60552b087..05b10ffd7 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -75,7 +75,6 @@ void lb_emit_init_context(lbProcedure *p, lbAddr addr) { GB_ASSERT(addr.kind == lbAddr_Context); GB_ASSERT(addr.ctx.sel.index.count == 0); - lbModule *m = p->module; auto args = array_make(permanent_allocator(), 1); args[0] = addr.addr; lb_emit_runtime_call(p, "__init_context", args); @@ -118,7 +117,6 @@ lbContextData *lb_push_context_onto_stack(lbProcedure *p, lbAddr ctx) { lbValue lb_get_equal_proc_for_type(lbModule *m, Type *type) { - Type *original_type = type; type = base_type(type); GB_ASSERT(is_type_comparable(type)); @@ -276,12 +274,10 @@ lbValue lb_simple_compare_hash(lbProcedure *p, Type *type, lbValue data, lbValue } lbValue lb_get_hasher_proc_for_type(lbModule *m, Type *type) { - Type *original_type = type; type = core_type(type); GB_ASSERT(is_type_valid_for_keys(type)); Type *pt = alloc_type_pointer(type); - LLVMTypeRef ptr_type = lb_type(m, pt); auto key = hash_type(type); lbProcedure **found = map_get(&m->hasher_procs, key); @@ -358,7 +354,6 @@ lbValue lb_get_hasher_proc_for_type(lbModule *m, Type *type) { lb_start_block(p, case_block); Type *v = type->Union.variants[i]; - Type *vp = alloc_type_pointer(v); lbValue case_tag = lb_const_union_tag(p->module, type, v); lbValue variant_hasher = lb_get_hasher_proc_for_type(m, v); @@ -490,6 +485,7 @@ lbValue lb_gen_map_header(lbProcedure *p, lbValue map_val_ptr, Type *map_type) { Type *key_type = map_type->Map.key; Type *val_type = map_type->Map.value; + gb_unused(val_type); // NOTE(bill): Removes unnecessary allocation if split gep lbValue gep0 = lb_emit_struct_ep(p, h.addr, 0); @@ -564,10 +560,8 @@ lbValue lb_const_hash(lbModule *m, lbValue key, Type *key_type) { } lbValue lb_gen_map_hash(lbProcedure *p, lbValue key, Type *key_type) { - Type *hash_type = t_u64; lbAddr v = lb_add_local_generated(p, t_map_hash, true); lbValue vp = lb_addr_get_ptr(p, v); - Type *t = base_type(key.type); key = lb_emit_conv(p, key, key_type); lbValue key_ptr = lb_address_from_load_or_generate_local(p, key); @@ -622,9 +616,6 @@ lbProcedure *lb_create_startup_type_info(lbModule *m) { lb_populate_function_pass_manager(m, default_function_pass_manager, false, build_context.optimization_level); LLVMFinalizeFunctionPassManager(default_function_pass_manager); - Type *params = alloc_type_tuple(); - Type *results = alloc_type_tuple(); - Type *proc_type = alloc_type_proc(nullptr, nullptr, 0, nullptr, 0, false, ProcCC_CDecl); lbProcedure *p = lb_create_dummy_procedure(m, str_lit(LB_STARTUP_TYPE_INFO_PROC_NAME), proc_type); @@ -654,9 +645,6 @@ lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *start lb_populate_function_pass_manager(main_module, default_function_pass_manager, false, build_context.optimization_level); LLVMFinalizeFunctionPassManager(default_function_pass_manager); - Type *params = alloc_type_tuple(); - Type *results = alloc_type_tuple(); - Type *proc_type = alloc_type_proc(nullptr, nullptr, 0, nullptr, 0, false, ProcCC_CDecl); lbProcedure *p = lb_create_dummy_procedure(main_module, str_lit(LB_STARTUP_RUNTIME_PROC_NAME), proc_type); @@ -695,9 +683,6 @@ lbProcedure *lb_create_startup_runtime(lbModule *main_module, lbProcedure *start GB_PANIC("Invalid init value, got %s", expr_to_string(init_expr)); } - LLVMValueKind value_kind = LLVMGetValueKind(init.value); - // gb_printf_err("%s %d\n", LLVMPrintValueToString(init.value)); - if (is_type_any(e->type) || is_type_union(e->type)) { var->init = init; } else if (lb_is_const_or_global(init)) { @@ -1135,7 +1120,6 @@ void lb_generate_code(lbGenerator *gen) { LLVMInitializeNativeTarget(); char const *target_triple = alloc_cstring(permanent_allocator(), build_context.metrics.target_triplet); - char const *target_data_layout = alloc_cstring(permanent_allocator(), build_context.metrics.target_data_layout); for_array(i, gen->modules.entries) { LLVMSetTarget(gen->modules.entries[i].value->mod, target_triple); } @@ -1500,9 +1484,8 @@ void lb_generate_code(lbGenerator *gen) { TIME_SECTION("LLVM Global Procedures and Types"); for_array(i, info->entities) { Entity *e = info->entities[i]; - String name = e->token.string; - DeclInfo *decl = e->decl_info; - Scope * scope = e->scope; + String name = e->token.string; + Scope * scope = e->scope; if ((scope->flags & ScopeFlag_File) == 0) { continue; diff --git a/src/llvm_backend_debug.cpp b/src/llvm_backend_debug.cpp index f3640de11..81b8b9a60 100644 --- a/src/llvm_backend_debug.cpp +++ b/src/llvm_backend_debug.cpp @@ -45,10 +45,8 @@ LLVMMetadataRef lb_debug_location_from_ast(lbProcedure *p, Ast *node) { } LLVMMetadataRef lb_debug_type_internal_proc(lbModule *m, Type *type) { - Type *original_type = type; - - LLVMContextRef ctx = m->ctx; i64 size = type_size_of(type); // Check size + gb_unused(size); GB_ASSERT(type != t_invalid); @@ -56,7 +54,6 @@ LLVMMetadataRef lb_debug_type_internal_proc(lbModule *m, Type *type) { unsigned const word_bits = cast(unsigned)(8*build_context.word_size); GB_ASSERT(type->kind == Type_Proc); - LLVMTypeRef return_type = LLVMVoidTypeInContext(ctx); unsigned parameter_count = 1; for (i32 i = 0; i < type->Proc.param_count; i++) { Entity *e = type->Proc.params->Tuple.variables[i]; @@ -73,8 +70,6 @@ LLVMMetadataRef lb_debug_type_internal_proc(lbModule *m, Type *type) { parameters[param_index++] = lb_debug_type(m, type->Proc.results); } - LLVMMetadataRef parent_scope = nullptr; - LLVMMetadataRef scope = nullptr; LLVMMetadataRef file = nullptr; for (i32 i = 0; i < type->Proc.param_count; i++) { @@ -129,10 +124,8 @@ LLVMMetadataRef lb_debug_type_basic_type(lbModule *m, String const &name, u64 si } LLVMMetadataRef lb_debug_type_internal(lbModule *m, Type *type) { - Type *original_type = type; - - LLVMContextRef ctx = m->ctx; i64 size = type_size_of(type); // Check size + gb_unused(size); GB_ASSERT(type != t_invalid); diff --git a/src/llvm_backend_expr.cpp b/src/llvm_backend_expr.cpp index e6bb35c0c..c598fbf62 100644 --- a/src/llvm_backend_expr.cpp +++ b/src/llvm_backend_expr.cpp @@ -430,8 +430,6 @@ lbValue lb_emit_arith_array(lbProcedure *p, TokenKind op, lbValue lhs, lbValue r lbValue lb_emit_arith(lbProcedure *p, TokenKind op, lbValue lhs, lbValue rhs, Type *type) { - lbModule *m = p->module; - if (is_type_array_like(lhs.type) || is_type_array_like(rhs.type)) { return lb_emit_arith_array(p, op, lhs, rhs, type); } else if (is_type_complex(type)) { @@ -779,7 +777,6 @@ lbValue lb_build_binary_expr(lbProcedure *p, Ast *expr) { case Token_not_in: { lbValue left = lb_build_expr(p, be->left); - Type *type = default_type(tv.type); lbValue right = lb_build_expr(p, be->right); Type *rt = base_type(right.type); if (is_type_pointer(rt)) { @@ -989,7 +986,7 @@ lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) { if (is_type_boolean(src) && (is_type_boolean(dst) || is_type_integer(dst))) { LLVMValueRef b = LLVMBuildICmp(p->builder, LLVMIntNE, value.value, LLVMConstNull(lb_type(m, value.type)), ""); lbValue res = {}; - res.value = LLVMBuildIntCast2(p->builder, value.value, lb_type(m, t), false, ""); + res.value = LLVMBuildIntCast2(p->builder, b, lb_type(m, t), false, ""); res.type = t; return res; } @@ -1228,14 +1225,12 @@ lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t) { // subtype polymorphism casting if (check_is_assignable_to_using_subtype(src_type, t)) { Type *st = type_deref(src_type); - Type *pst = st; st = type_deref(st); bool st_is_ptr = is_type_pointer(src_type); st = base_type(st); Type *dt = t; - bool dt_is_ptr = type_deref(dt) != dt; GB_ASSERT(is_type_struct(st) || is_type_raw_union(st)); String field_name = lookup_subtype_polymorphic_field(t, src_type); @@ -1966,7 +1961,6 @@ lbValue lb_build_unary_and(lbProcedure *p, Ast *expr) { lbValue key = lb_build_expr(p, ie->index); key = lb_emit_conv(p, key, t->Map.key); - Type *result_type = type_of_expr(expr); lbAddr addr = lb_addr_map(map_val, key, t, alloc_type_pointer(t->Map.value)); lbValue ptr = lb_addr_get_ptr(p, addr); @@ -3403,9 +3397,6 @@ lbAddr lb_build_addr(lbProcedure *p, Ast *expr) { } case Type_Slice: { if (cl->elems.count > 0) { - Type *elem_type = bt->Slice.elem; - Type *elem_ptr_type = alloc_type_pointer(elem_type); - Type *elem_ptr_ptr_type = alloc_type_pointer(elem_ptr_type); lbValue slice = lb_const_value(p->module, type, exact_value_compound(expr)); lbValue data = lb_slice_elem(p, slice); diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp index 073596b6e..6907bfe2c 100644 --- a/src/llvm_backend_general.cpp +++ b/src/llvm_backend_general.cpp @@ -811,7 +811,6 @@ LLVMTypeRef llvm_addr_type(lbValue addr_val) { } lbValue lb_emit_load(lbProcedure *p, lbValue value) { - lbModule *m = p->module; GB_ASSERT(value.value != nullptr); GB_ASSERT(is_type_pointer(value.type)); Type *t = type_deref(value.type); @@ -981,7 +980,6 @@ lbValue lb_addr_load(lbProcedure *p, lbAddr const &addr) { Entity *field = t->Struct.fields[i]; Type *base_type = field->type; GB_ASSERT(base_type->kind == Type_Pointer); - Type *elem = base_type->Pointer.elem; lbValue dst = lb_emit_struct_ep(p, res.addr, cast(i32)i); lbValue src_ptr = lb_emit_struct_ep(p, addr.addr, cast(i32)i); @@ -1010,7 +1008,6 @@ lbValue lb_addr_load(lbProcedure *p, lbAddr const &addr) { } } - Type *elem_type = base_type(array_type->Array.elem); lbAddr res = lb_add_local_generated(p, addr.swizzle.type, false); lbValue ptr = lb_addr_get_ptr(p, res); GB_ASSERT(is_type_pointer(ptr.type)); @@ -1044,8 +1041,8 @@ lbValue lb_addr_load(lbProcedure *p, lbAddr const &addr) { GB_ASSERT(array_type->kind == Type_Array); unsigned res_align = cast(unsigned)type_align_of(addr.swizzle_large.type); + gb_unused(res_align); - Type *elem_type = base_type(array_type->Array.elem); lbAddr res = lb_add_local_generated(p, addr.swizzle_large.type, false); lbValue ptr = lb_addr_get_ptr(p, res); GB_ASSERT(is_type_pointer(ptr.type)); @@ -1291,10 +1288,9 @@ String lb_get_entity_name(lbModule *m, Entity *e, String default_name) { LLVMTypeRef lb_type_internal(lbModule *m, Type *type) { - Type *original_type = type; - LLVMContextRef ctx = m->ctx; i64 size = type_size_of(type); // Check size + gb_unused(size); GB_ASSERT(type != t_invalid); @@ -1681,6 +1677,7 @@ LLVMTypeRef lb_type_internal(lbModule *m, Type *type) { // LLVM takes the first element's alignment as the entire alignment (like C) i64 align = type_align_of(type); i64 size = type_size_of(type); + gb_unused(size); if (is_type_union_maybe_pointer_original_alignment(type)) { LLVMTypeRef fields[1] = {lb_type(m, type->Union.variants[0])}; @@ -1890,6 +1887,7 @@ lbFunctionType *lb_get_function_type(lbModule *m, lbProcedure *p, Type *pt) { ft_found = map_get(&m->function_type_map, hash_type(pt)); if (!ft_found) { LLVMTypeRef llvm_proc_type = lb_type(p->module, pt); + gb_unused(llvm_proc_type); ft_found = map_get(&m->function_type_map, hash_type(pt)); } GB_ASSERT(ft_found != nullptr); @@ -1905,6 +1903,7 @@ void lb_ensure_abi_function_type(lbModule *m, lbProcedure *p) { lbFunctionType **ft_found = map_get(&m->function_type_map, hash); if (ft_found == nullptr) { LLVMTypeRef llvm_proc_type = lb_type(p->module, p->type); + gb_unused(llvm_proc_type); ft_found = map_get(&m->function_type_map, hash); } GB_ASSERT(ft_found != nullptr); diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp index 03b052c71..9516f2e3d 100644 --- a/src/llvm_backend_proc.cpp +++ b/src/llvm_backend_proc.cpp @@ -179,8 +179,9 @@ lbProcedure *lb_create_procedure(lbModule *m, Entity *entity, bool ignore_body) TypeTuple *params = &pt->Proc.params->Tuple; for (isize i = 0; i < pt->Proc.param_count; i++) { Entity *e = params->variables[i]; - Type *original_type = e->type; - if (e->kind != Entity_Variable) continue; + if (e->kind != Entity_Variable) { + continue; + } if (i+1 == params->variables.count && pt->Proc.c_vararg) { continue; @@ -658,7 +659,6 @@ lbValue lb_emit_call_internal(lbProcedure *p, lbValue value, lbValue return_ptr, { LLVMTypeRef ftp = lb_type(p->module, value.type); - LLVMTypeRef ft = LLVMGetElementType(ftp); LLVMValueRef fn = value.value; if (!lb_is_type_kind(LLVMTypeOf(value.value), LLVMFunctionTypeKind)) { fn = LLVMBuildPointerCast(p->builder, fn, ftp, ""); @@ -1690,8 +1690,6 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv, case BuiltinProc_atomic_cxchgweak_failacq: case BuiltinProc_atomic_cxchgweak_acq_failrelaxed: case BuiltinProc_atomic_cxchgweak_acqrel_failrelaxed: { - Type *type = expr->tav.type; - lbValue address = lb_build_expr(p, ce->args[0]); Type *elem = type_deref(address.type); lbValue old_value = lb_build_expr(p, ce->args[1]); @@ -1765,7 +1763,6 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv, case BuiltinProc_fixed_point_mul_sat: case BuiltinProc_fixed_point_div_sat: { - bool do_bswap = is_type_different_to_arch_endianness(tv.type); Type *platform_type = integer_endian_type_to_platform_type(tv.type); lbValue x = lb_emit_conv(p, lb_build_expr(p, ce->args[0]), platform_type); @@ -2062,7 +2059,6 @@ lbValue lb_build_call_expr_internal(lbProcedure *p, Ast *expr) { Type *at = a.type; if (at->kind == Type_Tuple) { for_array(i, at->Tuple.variables) { - Entity *e = at->Tuple.variables[i]; lbValue v = lb_emit_struct_ev(p, a, cast(i32)i); args[arg_index++] = v; } diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp index 7c537853c..303d58ce1 100644 --- a/src/llvm_backend_stmt.cpp +++ b/src/llvm_backend_stmt.cpp @@ -547,7 +547,6 @@ void lb_build_range_enum(lbProcedure *p, Type *enum_type, Type *val_type, lbValu Type *t = enum_type; GB_ASSERT(is_type_enum(t)); - Type *enum_ptr = alloc_type_pointer(t); t = base_type(t); Type *core_elem = core_type(t); GB_ASSERT(t->kind == Type_Enum); @@ -863,8 +862,6 @@ void lb_build_unroll_range_stmt(lbProcedure *p, AstUnrollRangeStmt *rs, Scope *s lbValue val = {}; lbValue key = {}; - lbBlock *loop = nullptr; - lbBlock *done = nullptr; Ast *expr = unparen_expr(rs->expr); TypeAndValue tav = type_and_value_of_expr(expr); @@ -1460,7 +1457,6 @@ void lb_build_assignment(lbProcedure *p, Array &lvals, Slice cons Type *t = init.type; GB_ASSERT(t->kind == Type_Tuple); for_array(i, t->Tuple.variables) { - Entity *e = t->Tuple.variables[i]; lbValue v = lb_emit_struct_ev(p, init, cast(i32)i); array_add(&inits, v); } @@ -1553,7 +1549,6 @@ void lb_build_return_stmt(lbProcedure *p, Slice const &return_results) { Type *t = res.type; if (t->kind == Type_Tuple) { for_array(i, t->Tuple.variables) { - Entity *e = t->Tuple.variables[i]; lbValue v = lb_emit_struct_ev(p, res, cast(i32)i); array_add(&results, v); } @@ -1765,7 +1760,6 @@ void lb_build_for_stmt(lbProcedure *p, Ast *node) { void lb_build_assign_stmt_array(lbProcedure *p, TokenKind op, lbAddr const &lhs, lbValue const &value) { Type *lhs_type = lb_addr_type(lhs); - Type *rhs_type = value.type; Type *array_type = base_type(lhs_type); GB_ASSERT(is_type_array_like(array_type)); i64 count = get_array_type_count(array_type); diff --git a/src/llvm_backend_type.cpp b/src/llvm_backend_type.cpp index 66f8aa633..d58ab1c77 100644 --- a/src/llvm_backend_type.cpp +++ b/src/llvm_backend_type.cpp @@ -155,7 +155,6 @@ lbValue lb_type_info_member_tags_offset(lbProcedure *p, isize count) { void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info data lbModule *m = p->module; - LLVMContextRef ctx = m->ctx; CheckerInfo *info = m->info; { @@ -176,16 +175,9 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da // Useful types - Type *t_i64_slice_ptr = alloc_type_pointer(alloc_type_slice(t_i64)); - Type *t_string_slice_ptr = alloc_type_pointer(alloc_type_slice(t_string)); Entity *type_info_flags_entity = find_core_entity(info->checker, str_lit("Type_Info_Flags")); Type *t_type_info_flags = type_info_flags_entity->type; - - i32 type_info_member_types_index = 0; - i32 type_info_member_names_index = 0; - i32 type_info_member_offsets_index = 0; - for_array(type_info_type_index, info->type_info_types) { Type *t = info->type_info_types[type_info_type_index]; if (t == nullptr || t == t_invalid) { @@ -567,9 +559,6 @@ void lb_setup_type_info_data(lbProcedure *p) { // NOTE(bill): Setup type_info da GB_ASSERT(is_type_integer(t->Enum.base_type)); - LLVMTypeRef align_type = lb_alignment_prefix_type_hack(m, type_align_of(t)); - LLVMTypeRef array_type = LLVMArrayType(lb_type(m, t_u8), 8); - for_array(i, fields) { name_values[i] = lb_const_string(m, fields[i]->token.string).value; value_values[i] = lb_const_value(m, t_i64, fields[i]->Constant.value).value; diff --git a/src/llvm_backend_utility.cpp b/src/llvm_backend_utility.cpp index 406b4fc2e..6f08ddf5f 100644 --- a/src/llvm_backend_utility.cpp +++ b/src/llvm_backend_utility.cpp @@ -1207,7 +1207,6 @@ lbValue lb_map_entries(lbProcedure *p, lbValue value) { Type *t = base_type(value.type); GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t)); init_map_internal_types(t); - Type *gst = t->Map.generated_struct_type; i32 index = 1; lbValue entries = lb_emit_struct_ev(p, value, index); return entries; @@ -1217,7 +1216,6 @@ lbValue lb_map_entries_ptr(lbProcedure *p, lbValue value) { Type *t = base_type(type_deref(value.type)); GB_ASSERT_MSG(t->kind == Type_Map, "%s", type_to_string(t)); init_map_internal_types(t); - Type *gst = t->Map.generated_struct_type; i32 index = 1; lbValue entries = lb_emit_struct_ep(p, value, index); return entries; diff --git a/src/main.cpp b/src/main.cpp index 2a7468051..b4dabcd25 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -236,8 +236,8 @@ i32 linker_stage(lbGenerator *gen) { for_array(i, m->foreign_library_paths) { String lib = m->foreign_library_paths[i]; GB_ASSERT(lib.len < gb_count_of(lib_str_buf)-1); - isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), - " \"%.*s\"", LIT(lib)); + gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), + " \"%.*s\"", LIT(lib)); lib_str = gb_string_appendc(lib_str, lib_str_buf); } } @@ -245,8 +245,8 @@ i32 linker_stage(lbGenerator *gen) { for_array(i, gen->default_module.foreign_library_paths) { String lib = gen->default_module.foreign_library_paths[i]; GB_ASSERT(lib.len < gb_count_of(lib_str_buf)-1); - isize len = gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), - " \"%.*s\"", LIT(lib)); + gb_snprintf(lib_str_buf, gb_size_of(lib_str_buf), + " \"%.*s\"", LIT(lib)); lib_str = gb_string_appendc(lib_str, lib_str_buf); } diff --git a/src/parser.cpp b/src/parser.cpp index a79413c01..3b5c30207 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -2432,7 +2432,6 @@ Ast *parse_operand(AstFile *f, bool lhs) { bool no_nil = false; bool maybe = false; - CommentGroup *docs = f->lead_comment; Token start_token = f->curr_token; if (allow_token(f, Token_OpenParen)) { @@ -3634,7 +3633,6 @@ bool parse_expect_field_separator(AstFile *f, Ast *param) { } Ast *parse_struct_field_list(AstFile *f, isize *name_count_) { - CommentGroup *docs = f->lead_comment; Token start_token = f->curr_token; auto decls = array_make(heap_allocator()); @@ -4750,7 +4748,6 @@ ParseFileError init_ast_file(AstFile *f, String fullpath, TokenPos *err_pos) { isize init_token_cap = gb_max(token_cap, 16); array_init(&f->tokens, heap_allocator(), 0, gb_max(init_token_cap, 16)); - isize cap0 = f->tokens.capacity; if (err == TokenizerInit_Empty) { Token token = {Token_EOF}; diff --git a/src/parser.hpp b/src/parser.hpp index bce451043..3612d5e96 100644 --- a/src/parser.hpp +++ b/src/parser.hpp @@ -709,7 +709,7 @@ struct Ast { }; -#define ast_node(n_, Kind_, node_) GB_JOIN2(Ast, Kind_) *n_ = &(node_)->Kind_; GB_ASSERT_MSG((node_)->kind == GB_JOIN2(Ast_, Kind_), \ +#define ast_node(n_, Kind_, node_) GB_JOIN2(Ast, Kind_) *n_ = &(node_)->Kind_; gb_unused(n_); GB_ASSERT_MSG((node_)->kind == GB_JOIN2(Ast_, Kind_), \ "expected '%.*s' got '%.*s'", \ LIT(ast_strings[GB_JOIN2(Ast_, Kind_)]), LIT(ast_strings[(node_)->kind])) #define case_ast_node(n_, Kind_, node_) case GB_JOIN2(Ast_, Kind_): { ast_node(n_, Kind_, node_); diff --git a/src/query_data.cpp b/src/query_data.cpp index 6c9637948..ce42c00e2 100644 --- a/src/query_data.cpp +++ b/src/query_data.cpp @@ -946,7 +946,7 @@ void generate_and_print_query_data_go_to_definitions(Checker *c) { isize data_min_size = 0; - u32 header_offset = cast(u32)data_min_size; + u32 header_offset = cast(u32)data_min_size; gb_unused(header_offset); data_min_size += gb_size_of(GoToDefHeader); data_min_size = align_formula_isize(data_min_size, 8); diff --git a/src/string.cpp b/src/string.cpp index 0764009bc..434c20d90 100644 --- a/src/string.cpp +++ b/src/string.cpp @@ -539,14 +539,12 @@ String quote_to_ascii(gbAllocator a, String str, u8 quote='"') { r = 0XFFFD; } if (r < 0x10000) { - u8 b = cast(u8)r; array_add(&buf, cast(u8)'\\'); array_add(&buf, cast(u8)'u'); for (isize i = 12; i >= 0; i -= 4) { array_add(&buf, cast(u8)lower_hex[(r>>i)&0xf]); } } else { - u8 b = cast(u8)r; array_add(&buf, cast(u8)'\\'); array_add(&buf, cast(u8)'U'); for (isize i = 28; i >= 0; i -= 4) { diff --git a/src/types.cpp b/src/types.cpp index fd5bdbc6d..b8a20173b 100644 --- a/src/types.cpp +++ b/src/types.cpp @@ -1286,7 +1286,6 @@ i64 get_array_type_count(Type *t) { Type *core_array_type(Type *t) { for (;;) { - Type *prev = t; t = base_array_type(t); if (t->kind != Type_Array && t->kind != Type_EnumeratedArray && t->kind != Type_SimdVector) { break; @@ -1664,7 +1663,6 @@ Scope *polymorphic_record_parent_scope(Type *t) { } bool is_type_polymorphic_record_specialized(Type *t) { - Type *original_type = t; t = base_type(t); if (t->kind == Type_Struct) { return t->Struct.is_poly_specialized; @@ -3030,10 +3028,6 @@ i64 type_align_of_internal(Type *t, TypePath *path) { } case Type_SimdVector: { - // align of - i64 count = t->SimdVector.count; - Type *elem = t->SimdVector.elem; - i64 size = count * type_size_of_internal(elem, path); // IMPORTANT TODO(bill): Figure out the alignment of vector types return gb_clamp(next_pow2(type_size_of_internal(t, path)), 1, build_context.max_align); }