ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-14 07:01:25 -07:00
Code Issues Packages Projects Releases Wiki Activity

Remove atomic, ++, and --

Browse Source
This commit is contained in:
Ginger Bill
2017-07-18 18:58:41 +01:00
parent d16aa79492
commit 65f079ebc4
23 changed files with 179 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/check_expr.cpp
-17
View File
@@ -1711,11 +1711,6 @@ bool is_polymorphic_type_assignable(Checker *c, Type *poly, Type *source, bool c
return is_polymorphic_type_assignable(c, poly->Pointer.elem, source->Pointer.elem, true, modify_type);
}
return false;
case Type_Atomic:
if (source->kind == Type_Atomic) {
return is_polymorphic_type_assignable(c, poly->Atomic.elem, source->Atomic.elem, true, modify_type);
}
return false;
case Type_Array:
if (source->kind == Type_Array &&
poly->Array.count == source->Array.count) {
@@ -2942,13 +2937,6 @@ bool check_type_internal(Checker *c, AstNode *e, Type **type, Type *named_type)
return true;
case_end;
case_ast_node(at, AtomicType, e);
Type *elem = check_type(c, at->type);
i64 esz = type_size_of(c->allocator, elem);
*type = make_type_atomic(c->allocator, elem);
return true;
case_end;
case_ast_node(at, ArrayType, e);
if (at->count != nullptr) {
Type *elem = check_type(c, at->elem, nullptr);
@@ -8399,11 +8387,6 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
}
str = gb_string_appendc(str, "}");
case_end;
case_ast_node(at, AtomicType, node);
str = gb_string_appendc(str, "atomic ");
str = write_expr_to_string(str, at->type);
case_end;
}
return str;
src/check_stmt.cpp
+2
View File
@@ -629,6 +629,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
check_stmt(c, ts->stmt, flags);
case_end;
#if 0
case_ast_node(s, IncDecStmt, node);
TokenKind op = s->op.kind;
switch (op) {
@@ -671,6 +672,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
}
check_assignment_variable(c, &x, left);
case_end;
#endif
case_ast_node(as, AssignStmt, node);
switch (as->op.kind) {
src/checker.cpp
+13 -19
View File
@@ -1142,10 +1142,6 @@ void add_type_info_type(Checker *c, Type *t) {
add_type_info_type(c, bt->Pointer.elem);
break;
case Type_Atomic:
add_type_info_type(c, bt->Atomic.elem);
break;
case Type_Array:
add_type_info_type(c, bt->Array.elem);
add_type_info_type(c, make_type_pointer(c->allocator, bt->Array.elem));
@@ -1361,7 +1357,7 @@ void init_preload(Checker *c) {
GB_ASSERT(is_type_union(tiv_type));
TypeUnion *tiv = &tiv_type->Union;
if (tiv->variant_count != 23) {
if (tiv->variant_count != 22) {
compiler_error("Invalid `TypeInfo` layout");
}
t_type_info_named = tiv->variants[ 1];
@@ -1373,19 +1369,18 @@ void init_preload(Checker *c) {
t_type_info_boolean = tiv->variants[ 7];
t_type_info_any = tiv->variants[ 8];
t_type_info_pointer = tiv->variants[ 9];
t_type_info_atomic = tiv->variants[10];
t_type_info_procedure = tiv->variants[11];
t_type_info_array = tiv->variants[12];
t_type_info_dynamic_array = tiv->variants[13];
t_type_info_slice = tiv->variants[14];
t_type_info_vector = tiv->variants[15];
t_type_info_tuple = tiv->variants[16];
t_type_info_struct = tiv->variants[17];
t_type_info_raw_union = tiv->variants[18];
t_type_info_union = tiv->variants[19];
t_type_info_enum = tiv->variants[20];
t_type_info_map = tiv->variants[21];
t_type_info_bit_field = tiv->variants[22];
t_type_info_procedure = tiv->variants[10];
t_type_info_array = tiv->variants[11];
t_type_info_dynamic_array = tiv->variants[12];
t_type_info_slice = tiv->variants[13];
t_type_info_vector = tiv->variants[14];
t_type_info_tuple = tiv->variants[15];
t_type_info_struct = tiv->variants[16];
t_type_info_raw_union = tiv->variants[17];
t_type_info_union = tiv->variants[18];
t_type_info_enum = tiv->variants[19];
t_type_info_map = tiv->variants[20];
t_type_info_bit_field = tiv->variants[21];
t_type_info_named_ptr = make_type_pointer(c->allocator, t_type_info_named);
t_type_info_integer_ptr = make_type_pointer(c->allocator, t_type_info_integer);
@@ -1396,7 +1391,6 @@ void init_preload(Checker *c) {
t_type_info_boolean_ptr = make_type_pointer(c->allocator, t_type_info_boolean);
t_type_info_any_ptr = make_type_pointer(c->allocator, t_type_info_any);
t_type_info_pointer_ptr = make_type_pointer(c->allocator, t_type_info_pointer);
t_type_info_atomic_ptr = make_type_pointer(c->allocator, t_type_info_atomic);
t_type_info_procedure_ptr = make_type_pointer(c->allocator, t_type_info_procedure);
t_type_info_array_ptr = make_type_pointer(c->allocator, t_type_info_array);
t_type_info_dynamic_array_ptr = make_type_pointer(c->allocator, t_type_info_dynamic_array);
src/ir.cpp
+4 -8
View File
@@ -151,7 +151,7 @@ struct irProcedure {
Entity * entity; \
Type * type; \
bool zero_initialized; \
Array<irValue *> referrers; \
Array<irValue *> referrers; \
i64 alignment; \
}) \
IR_INSTR_KIND(ZeroInit, struct { irValue *address; }) \
@@ -1481,7 +1481,7 @@ irValue *ir_emit_store(irProcedure *p, irValue *address, irValue *value) {
GB_ASSERT_MSG(are_types_identical(core_type(a), core_type(b)), "%s %s", type_to_string(a), type_to_string(b));
}
#endif
return ir_emit(p, ir_instr_store(p, address, value, is_type_atomic(a)));
return ir_emit(p, ir_instr_store(p, address, value, false));
}
irValue *ir_emit_load(irProcedure *p, irValue *address) {
GB_ASSERT(address != nullptr);
@@ -6233,6 +6233,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
ir_build_when_stmt(proc, ws);
case_end;
#if 0
case_ast_node(s, IncDecStmt, node);
TokenKind op = Token_Add;
if (s->op.kind == Token_Dec) {
@@ -6241,6 +6242,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
irAddr addr = ir_build_addr(proc, s->expr);
ir_build_assign_op(proc, addr, v_one, op);
case_end;
#endif
case_ast_node(vd, ValueDecl, node);
if (vd->is_mutable) {
@@ -8024,12 +8026,6 @@ void ir_gen_tree(irGen *s) {
irValue *gep = ir_get_type_info_ptr(proc, t->Pointer.elem);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
} break;
case Type_Atomic: {
ir_emit_comment(proc, str_lit("TypeInfoAtomic"));
tag = ir_emit_conv(proc, variant_ptr, t_type_info_atomic_ptr);
irValue *gep = ir_get_type_info_ptr(proc, t->Atomic.elem);
ir_emit_store(proc, ir_emit_struct_ep(proc, tag, 0), gep);
} break;
case Type_Array: {
ir_emit_comment(proc, str_lit("TypeInfoArray"));
tag = ir_emit_conv(proc, variant_ptr, t_type_info_array_ptr);
src/ir_print.cpp
+7 -10
View File
@@ -252,9 +252,6 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t) {
ir_print_type(f, m, t->Pointer.elem);
ir_fprintf(f, "*");
return;
case Type_Atomic:
ir_print_type(f, m, t->Atomic.elem);
return;
case Type_Array:
ir_fprintf(f, "[%lld x ", t->Array.count);
ir_print_type(f, m, t->Array.elem);
@@ -890,7 +887,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
ir_print_type(f, m, type);
ir_fprintf(f, "* ");
ir_print_value(f, m, instr->Store.address, type);
if (is_type_atomic(type)) {
if (instr->Store.atomic) {
// TODO(bill): Do ordering
ir_fprintf(f, " unordered");
ir_fprintf(f, ", align %lld\n", type_align_of(m->allocator, type));
@@ -901,18 +898,18 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
case irInstr_Load: {
Type *type = instr->Load.type;
ir_fprintf(f, "%%%d = load ", value->index);
if (is_type_atomic(type)) {
ir_fprintf(f, "atomic ");
}
// if (is_type_atomic(type)) {
// ir_fprintf(f, "atomic ");
// }
ir_print_type(f, m, type);
ir_fprintf(f, ", ");
ir_print_type(f, m, type);
ir_fprintf(f, "* ");
ir_print_value(f, m, instr->Load.address, type);
if (is_type_atomic(type)) {
// if (is_type_atomic(type)) {
// TODO(bill): Do ordering
ir_fprintf(f, " unordered");
}
// ir_fprintf(f, " unordered");
// }
ir_fprintf(f, ", align %lld\n", type_align_of(m->allocator, type));
} break;
src/parser.cpp
+2 -24
View File
@@ -402,10 +402,6 @@ AST_NODE_KIND(_TypeBegin, "", i32) \
Token token; \
AstNode *type; \
}) \
AST_NODE_KIND(AtomicType, "atomic type", struct { \
Token token; \
AstNode *type; \
}) \
AST_NODE_KIND(ArrayType, "array type", struct { \
Token token; \
AstNode *count; \
@@ -598,7 +594,6 @@ Token ast_node_token(AstNode *node) {
case AstNode_PolyType: return node->PolyType.token;
case AstNode_ProcType: return node->ProcType.token;
case AstNode_PointerType: return node->PointerType.token;
case AstNode_AtomicType: return node->AtomicType.token;
case AstNode_ArrayType: return node->ArrayType.token;
case AstNode_DynamicArrayType: return node->DynamicArrayType.token;
case AstNode_VectorType: return node->VectorType.token;
@@ -854,9 +849,6 @@ AstNode *clone_ast_node(gbAllocator a, AstNode *node) {
case AstNode_PointerType:
n->PointerType.type = clone_ast_node(a, n->PointerType.type);
break;
case AstNode_AtomicType:
n->AtomicType.type = clone_ast_node(a, n->AtomicType.type);
break;
case AstNode_ArrayType:
n->ArrayType.count = clone_ast_node(a, n->ArrayType.count);
n->ArrayType.elem = clone_ast_node(a, n->ArrayType.elem);
@@ -1435,13 +1427,6 @@ AstNode *ast_pointer_type(AstFile *f, Token token, AstNode *type) {
return result;
}
AstNode *ast_atomic_type(AstFile *f, Token token, AstNode *type) {
AstNode *result = make_ast_node(f, AstNode_AtomicType);
result->AtomicType.token = token;
result->AtomicType.type = type;
return result;
}
AstNode *ast_array_type(AstFile *f, Token token, AstNode *count, AstNode *elem) {
AstNode *result = make_ast_node(f, AstNode_ArrayType);
result->ArrayType.token = token;
@@ -1850,9 +1835,6 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) {
case AstNode_PointerType:
return is_semicolon_optional_for_node(f, s->PointerType.type);
case AstNode_AtomicType:
return is_semicolon_optional_for_node(f, s->AtomicType.type);
case AstNode_StructType:
case AstNode_UnionType:
case AstNode_RawUnionType:
@@ -2390,12 +2372,6 @@ AstNode *parse_operand(AstFile *f, bool lhs) {
return ast_pointer_type(f, token, elem);
} break;
case Token_atomic: {
Token token = expect_token(f, Token_atomic);
AstNode *elem = parse_type(f);
return ast_atomic_type(f, token, elem);
} break;
case Token_OpenBracket: {
Token token = expect_token(f, Token_OpenBracket);
AstNode *count_expr = nullptr;
@@ -3402,12 +3378,14 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) {
#if 0
switch (token.kind) {
case Token_Inc:
case Token_Dec:
advance_token(f);
return ast_inc_dec_stmt(f, token, lhs[0]);
}
#endif
return ast_expr_stmt(f, lhs[0]);
}
src/ssa.cpp
+2
View File
@@ -1956,6 +1956,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
ssa_build_when_stmt(p, ws);
case_end;
#if 0
case_ast_node(s, IncDecStmt, node);
TokenKind op = Token_Add;
if (s->op.kind == Token_Dec) {
@@ -1965,6 +1966,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) {
Type *t = ssa_addr_type(addr);
ssa_build_assign_op(p, addr, ssa_const_int(p, t, 1), op);
case_end;
#endif
case_ast_node(as, AssignStmt, node);
ssa_emit_comment(p, str_lit("AssignStmt"));
src/tokenizer.cpp
+5 -5
View File
@@ -55,8 +55,8 @@ TOKEN_KIND(Token__AssignOpEnd, "_AssignOpEnd"), \
TOKEN_KIND(Token_ArrowRight, "->"), \
TOKEN_KIND(Token_ArrowLeft, "<-"), \
TOKEN_KIND(Token_DoubleArrowRight, "=>"), \
TOKEN_KIND(Token_Inc, "++"), \
TOKEN_KIND(Token_Dec, "--"), \
/* TOKEN_KIND(Token_Inc, "++"), */ \
/* TOKEN_KIND(Token_Dec, "--"), */ \
TOKEN_KIND(Token_Undef, "---"), \
\
TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \
@@ -126,7 +126,6 @@ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
TOKEN_KIND(Token_asm, "asm"), \
TOKEN_KIND(Token_yield, "yield"), \
TOKEN_KIND(Token_await, "await"), \
TOKEN_KIND(Token_atomic, "atomic"), \
TOKEN_KIND(Token__KeywordEnd, "_KeywordEnd"), \
TOKEN_KIND(Token_Count, "")
@@ -929,7 +928,8 @@ Token tokenizer_get_token(Tokenizer *t) {
break;
case '~': token.kind = token_kind_variant2(t, Token_Xor, Token_XorEq); break;
case '!': token.kind = token_kind_variant2(t, Token_Not, Token_NotEq); break;
case '+': token.kind = token_kind_variant3(t, Token_Add, Token_AddEq, '+', Token_Inc); break;
// case '+': token.kind = token_kind_variant3(t, Token_Add, Token_AddEq, '+', Token_Inc); break;
case '+': token.kind = token_kind_variant2(t, Token_Add, Token_AddEq); break;
case '-':
token.kind = Token_Sub;
if (t->curr_rune == '=') {
@@ -937,7 +937,7 @@ Token tokenizer_get_token(Tokenizer *t) {
token.kind = Token_SubEq;
} else if (t->curr_rune == '-') {
advance_to_next_rune(t);
token.kind = Token_Dec;
token.kind = Token_Invalid;
if (t->curr_rune == '-') {
advance_to_next_rune(t);
token.kind = Token_Undef;
src/types.cpp
-23
View File
@@ -111,7 +111,6 @@ struct TypeRecord {
Type * specialized; \
}) \
TYPE_KIND(Pointer, struct { Type *elem; }) \
TYPE_KIND(Atomic, struct { Type *elem; }) \
TYPE_KIND(Array, struct { Type *elem; i64 count; }) \
TYPE_KIND(DynamicArray, struct { Type *elem; }) \
TYPE_KIND(Vector, struct { Type *elem; i64 count; }) \
@@ -355,7 +354,6 @@ gb_global Type *t_type_info_any = nullptr;
gb_global Type *t_type_info_string = nullptr;
gb_global Type *t_type_info_boolean = nullptr;
gb_global Type *t_type_info_pointer = nullptr;
gb_global Type *t_type_info_atomic = nullptr;
gb_global Type *t_type_info_procedure = nullptr;
gb_global Type *t_type_info_array = nullptr;
gb_global Type *t_type_info_dynamic_array = nullptr;
@@ -379,7 +377,6 @@ gb_global Type *t_type_info_any_ptr = nullptr;
gb_global Type *t_type_info_string_ptr = nullptr;
gb_global Type *t_type_info_boolean_ptr = nullptr;
gb_global Type *t_type_info_pointer_ptr = nullptr;
gb_global Type *t_type_info_atomic_ptr = nullptr;
gb_global Type *t_type_info_procedure_ptr = nullptr;
gb_global Type *t_type_info_array_ptr = nullptr;
gb_global Type *t_type_info_dynamic_array_ptr = nullptr;
@@ -456,9 +453,6 @@ Type *core_type(Type *t) {
case Type_Enum:
t = t->Enum.base_type;
continue;
case Type_Atomic:
t = t->Atomic.elem;
continue;
}
break;
}
@@ -500,12 +494,6 @@ Type *make_type_pointer(gbAllocator a, Type *elem) {
return t;
}
Type *make_type_atomic(gbAllocator a, Type *elem) {
Type *t = alloc_type(a, Type_Atomic);
t->Atomic.elem = elem;
return t;
}
Type *make_type_array(gbAllocator a, Type *elem, i64 count) {
Type *t = alloc_type(a, Type_Array);
t->Array.elem = elem;
@@ -774,10 +762,6 @@ bool is_type_pointer(Type *t) {
}
return t->kind == Type_Pointer;
}
bool is_type_atomic(Type *t) {
t = base_type(t);
return t->kind == Type_Atomic;
}
bool is_type_tuple(Type *t) {
t = base_type(t);
return t->kind == Type_Tuple;
@@ -975,8 +959,6 @@ bool is_type_polymorphic(Type *t) {
case Type_Pointer:
return is_type_polymorphic(t->Pointer.elem);
case Type_Atomic:
return is_type_polymorphic(t->Atomic.elem);
case Type_Array:
return is_type_polymorphic(t->Array.elem);
case Type_DynamicArray:
@@ -2307,11 +2289,6 @@ gbString write_type_to_string(gbString str, Type *type) {
str = write_type_to_string(str, type->Pointer.elem);
break;
case Type_Atomic:
str = gb_string_appendc(str, "atomic ");
str = write_type_to_string(str, type->Atomic.elem);
break;
case Type_Array:
str = gb_string_appendc(str, gb_bprintf("[%d]", cast(int)type->Array.count));
str = write_type_to_string(str, type->Array.elem);