authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-02-16 13:45:14-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-02-16 13:45:14-05:00
log4a957b9ea32e0539772993278a9a1f99ee3df68b
tree2a2055b06413d72d3f3381a2723d9adef2c16623
parent1fc2082b4ccc2b75fba892bc9e27e9a5a3d821bf

move int and array types to central table

3 files changed, 134 insertions(+), 35 deletions(-)

src/all_types.hpp+22-7
...@@ -1040,7 +1040,6 @@ struct TypeTableEntry {...@@ -1040,7 +1040,6 @@ struct TypeTableEntry {
1040 // use these fields to make sure we don't duplicate type table entries for the same type1040 // use these fields to make sure we don't duplicate type table entries for the same type
1041 TypeTableEntry *pointer_parent[2][2]; // [0 - mut, 1 - const][0 - normal, 1 - volatile]1041 TypeTableEntry *pointer_parent[2][2]; // [0 - mut, 1 - const][0 - normal, 1 - volatile]
1042 TypeTableEntry *slice_parent[2]; // [0 - mut, 1 - const]1042 TypeTableEntry *slice_parent[2]; // [0 - mut, 1 - const]
1043 HashMap<uint64_t, TypeTableEntry *, uint64_hash, uint64_eq> arrays_by_size;
1044 TypeTableEntry *maybe_parent;1043 TypeTableEntry *maybe_parent;
1045 TypeTableEntry *error_parent;1044 TypeTableEntry *error_parent;
1046 // If we generate a constant name value for this type, we memoize it here.1045 // If we generate a constant name value for this type, we memoize it here.
...@@ -1195,13 +1194,29 @@ enum PanicMsgId {...@@ -1195,13 +1194,29 @@ enum PanicMsgId {
1195uint32_t fn_eval_hash(Scope*);1194uint32_t fn_eval_hash(Scope*);
1196bool fn_eval_eql(Scope *a, Scope *b);1195bool fn_eval_eql(Scope *a, Scope *b);
11971196
1198struct IntTypeId {1197struct TypeId {
1199 bool is_signed;1198 TypeTableEntryId id;
1200 uint8_t bit_count;1199
1200 union {
1201 struct {
1202 TypeTableEntry *child_type;
1203 bool is_const;
1204 bool is_volatile;
1205 uint8_t bit_offset;
1206 } pointer;
1207 struct {
1208 TypeTableEntry *child_type;
1209 uint64_t size;
1210 } array;
1211 struct {
1212 bool is_signed;
1213 uint8_t bit_count;
1214 } integer;
1215 } data;
1201};1216};
12021217
1203uint32_t int_type_id_hash(IntTypeId);1218uint32_t type_id_hash(TypeId);
1204bool int_type_id_eql(IntTypeId a, IntTypeId b);1219bool type_id_eql(TypeId a, TypeId b);
12051220
1206struct CodeGen {1221struct CodeGen {
1207 LLVMModuleRef module;1222 LLVMModuleRef module;
...@@ -1218,7 +1233,7 @@ struct CodeGen {...@@ -1218,7 +1233,7 @@ struct CodeGen {
1218 HashMap<Buf *, ImportTableEntry *, buf_hash, buf_eql_buf> import_table;1233 HashMap<Buf *, ImportTableEntry *, buf_hash, buf_eql_buf> import_table;
1219 HashMap<Buf *, BuiltinFnEntry *, buf_hash, buf_eql_buf> builtin_fn_table;1234 HashMap<Buf *, BuiltinFnEntry *, buf_hash, buf_eql_buf> builtin_fn_table;
1220 HashMap<Buf *, TypeTableEntry *, buf_hash, buf_eql_buf> primitive_type_table;1235 HashMap<Buf *, TypeTableEntry *, buf_hash, buf_eql_buf> primitive_type_table;
1221 HashMap<IntTypeId, TypeTableEntry *, int_type_id_hash, int_type_id_eql> int_type_table;1236 HashMap<TypeId, TypeTableEntry *, type_id_hash, type_id_eql> type_table;
1222 HashMap<FnTypeId *, TypeTableEntry *, fn_type_id_hash, fn_type_id_eql> fn_type_table;1237 HashMap<FnTypeId *, TypeTableEntry *, fn_type_id_hash, fn_type_id_eql> fn_type_table;
1223 HashMap<Buf *, ErrorTableEntry *, buf_hash, buf_eql_buf> error_table;1238 HashMap<Buf *, ErrorTableEntry *, buf_hash, buf_eql_buf> error_table;
1224 HashMap<GenericFnTypeId *, FnTableEntry *, generic_fn_type_id_hash, generic_fn_type_id_eql> generic_table;1239 HashMap<GenericFnTypeId *, FnTableEntry *, generic_fn_type_id_hash, generic_fn_type_id_eql> generic_table;
src/analyze.cpp+111-27
...@@ -50,7 +50,6 @@ ErrorMsg *add_error_note(CodeGen *g, ErrorMsg *parent_msg, AstNode *node, Buf *m...@@ -50,7 +50,6 @@ ErrorMsg *add_error_note(CodeGen *g, ErrorMsg *parent_msg, AstNode *node, Buf *m
5050
51TypeTableEntry *new_type_table_entry(TypeTableEntryId id) {51TypeTableEntry *new_type_table_entry(TypeTableEntryId id) {
52 TypeTableEntry *entry = allocate<TypeTableEntry>(1);52 TypeTableEntry *entry = allocate<TypeTableEntry>(1);
53 entry->arrays_by_size.init(2);
54 entry->id = id;53 entry->id = id;
55 return entry;54 return entry;
56}55}
...@@ -489,34 +488,38 @@ TypeTableEntry *get_error_type(CodeGen *g, TypeTableEntry *child_type) {...@@ -489,34 +488,38 @@ TypeTableEntry *get_error_type(CodeGen *g, TypeTableEntry *child_type) {
489}488}
490489
491TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, uint64_t array_size) {490TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, uint64_t array_size) {
492 auto existing_entry = child_type->arrays_by_size.maybe_get(array_size);491 TypeId type_id;
492 type_id.id = TypeTableEntryIdArray;
493 type_id.data.array.child_type = child_type;
494 type_id.data.array.size = array_size;
495 auto existing_entry = g->type_table.maybe_get(type_id);
493 if (existing_entry) {496 if (existing_entry) {
494 TypeTableEntry *entry = existing_entry->value;497 TypeTableEntry *entry = existing_entry->value;
495 return entry;498 return entry;
496 } else {499 }
497 ensure_complete_type(g, child_type);
498500
499 TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArray);501 ensure_complete_type(g, child_type);
500 entry->zero_bits = (array_size == 0) || child_type->zero_bits;
501502
502 buf_resize(&entry->name, 0);503 TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArray);
503 buf_appendf(&entry->name, "[%" PRIu64 "]%s", array_size, buf_ptr(&child_type->name));504 entry->zero_bits = (array_size == 0) || child_type->zero_bits;
504505
505 if (!entry->zero_bits) {506 buf_resize(&entry->name, 0);
506 entry->type_ref = child_type->type_ref ? LLVMArrayType(child_type->type_ref, array_size) : nullptr;507 buf_appendf(&entry->name, "[%" PRIu64 "]%s", array_size, buf_ptr(&child_type->name));
507508
508 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);509 if (!entry->zero_bits) {
509 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);510 entry->type_ref = child_type->type_ref ? LLVMArrayType(child_type->type_ref, array_size) : nullptr;
510511
511 entry->di_type = ZigLLVMCreateDebugArrayType(g->dbuilder, debug_size_in_bits,512 uint64_t debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, entry->type_ref);
512 debug_align_in_bits, child_type->di_type, array_size);513 uint64_t debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, entry->type_ref);
513 }
514 entry->data.array.child_type = child_type;
515 entry->data.array.len = array_size;
516514
517 child_type->arrays_by_size.put(array_size, entry);515 entry->di_type = ZigLLVMCreateDebugArrayType(g->dbuilder, debug_size_in_bits,
518 return entry;516 debug_align_in_bits, child_type->di_type, array_size);
519 }517 }
518 entry->data.array.child_type = child_type;
519 entry->data.array.len = array_size;
520
521 g->type_table.put(type_id, entry);
522 return entry;
520}523}
521524
522static void slice_type_common_init(CodeGen *g, TypeTableEntry *child_type,525static void slice_type_common_init(CodeGen *g, TypeTableEntry *child_type,
...@@ -2822,14 +2825,19 @@ TypeTableEntry *get_int_type(CodeGen *g, bool is_signed, uint8_t size_in_bits) {...@@ -2822,14 +2825,19 @@ TypeTableEntry *get_int_type(CodeGen *g, bool is_signed, uint8_t size_in_bits) {
2822 if (common_entry)2825 if (common_entry)
2823 return *common_entry;2826 return *common_entry;
28242827
2828 TypeId type_id;
2829 type_id.id = TypeTableEntryIdInt;
2830 type_id.data.integer.is_signed = is_signed;
2831 type_id.data.integer.bit_count = size_in_bits;
2832
2825 {2833 {
2826 auto entry = g->int_type_table.maybe_get({is_signed, size_in_bits});2834 auto entry = g->type_table.maybe_get(type_id);
2827 if (entry)2835 if (entry)
2828 return entry->value;2836 return entry->value;
2829 }2837 }
28302838
2831 TypeTableEntry *new_entry = make_int_type(g, is_signed, size_in_bits);2839 TypeTableEntry *new_entry = make_int_type(g, is_signed, size_in_bits);
2832 g->int_type_table.put({is_signed, size_in_bits}, new_entry);2840 g->type_table.put(type_id, new_entry);
2833 return new_entry;2841 return new_entry;
2834}2842}
28352843
...@@ -3877,12 +3885,88 @@ TypeTableEntry *make_int_type(CodeGen *g, bool is_signed, size_t size_in_bits) {...@@ -3877,12 +3885,88 @@ TypeTableEntry *make_int_type(CodeGen *g, bool is_signed, size_t size_in_bits) {
3877 return entry;3885 return entry;
3878}3886}
38793887
3880uint32_t int_type_id_hash(IntTypeId x) {3888uint32_t type_id_hash(TypeId x) {
3881 uint32_t hash = x.is_signed ? 2652528194 : 163929201;3889 switch (x.id) {
3882 hash += ((uint32_t)x.bit_count) * 2998081557;3890 case TypeTableEntryIdInvalid:
3883 return hash;3891 case TypeTableEntryIdVar:
3892 case TypeTableEntryIdMetaType:
3893 case TypeTableEntryIdVoid:
3894 case TypeTableEntryIdBool:
3895 case TypeTableEntryIdUnreachable:
3896 case TypeTableEntryIdFloat:
3897 case TypeTableEntryIdStruct:
3898 case TypeTableEntryIdNumLitFloat:
3899 case TypeTableEntryIdNumLitInt:
3900 case TypeTableEntryIdUndefLit:
3901 case TypeTableEntryIdNullLit:
3902 case TypeTableEntryIdMaybe:
3903 case TypeTableEntryIdErrorUnion:
3904 case TypeTableEntryIdPureError:
3905 case TypeTableEntryIdEnum:
3906 case TypeTableEntryIdEnumTag:
3907 case TypeTableEntryIdUnion:
3908 case TypeTableEntryIdFn:
3909 case TypeTableEntryIdTypeDecl:
3910 case TypeTableEntryIdNamespace:
3911 case TypeTableEntryIdBlock:
3912 case TypeTableEntryIdBoundFn:
3913 case TypeTableEntryIdArgTuple:
3914 zig_unreachable();
3915 case TypeTableEntryIdPointer:
3916 return hash_ptr(x.data.pointer.child_type) +
3917 (x.data.pointer.is_const ? 2749109194 : 4047371087) +
3918 (x.data.pointer.is_volatile ? 536730450 : 1685612214) +
3919 (((uint32_t)x.data.pointer.bit_offset) * 2639019452);
3920 case TypeTableEntryIdArray:
3921 return hash_ptr(x.data.array.child_type) +
3922 (x.data.array.size * 2122979968);
3923 case TypeTableEntryIdInt:
3924 return (x.data.integer.is_signed ? 2652528194 : 163929201) +
3925 (((uint32_t)x.data.integer.bit_count) * 2998081557);
3926 }
3927 zig_unreachable();
3884}3928}
38853929
3886bool int_type_id_eql(IntTypeId a, IntTypeId b) {3930bool type_id_eql(TypeId a, TypeId b) {
3887 return (a.is_signed == b.is_signed && a.bit_count == b.bit_count);3931 if (a.id != b.id)
3932 return false;
3933 switch (a.id) {
3934 case TypeTableEntryIdInvalid:
3935 case TypeTableEntryIdVar:
3936 case TypeTableEntryIdMetaType:
3937 case TypeTableEntryIdVoid:
3938 case TypeTableEntryIdBool:
3939 case TypeTableEntryIdUnreachable:
3940 case TypeTableEntryIdFloat:
3941 case TypeTableEntryIdStruct:
3942 case TypeTableEntryIdNumLitFloat:
3943 case TypeTableEntryIdNumLitInt:
3944 case TypeTableEntryIdUndefLit:
3945 case TypeTableEntryIdNullLit:
3946 case TypeTableEntryIdMaybe:
3947 case TypeTableEntryIdErrorUnion:
3948 case TypeTableEntryIdPureError:
3949 case TypeTableEntryIdEnum:
3950 case TypeTableEntryIdEnumTag:
3951 case TypeTableEntryIdUnion:
3952 case TypeTableEntryIdFn:
3953 case TypeTableEntryIdTypeDecl:
3954 case TypeTableEntryIdNamespace:
3955 case TypeTableEntryIdBlock:
3956 case TypeTableEntryIdBoundFn:
3957 case TypeTableEntryIdArgTuple:
3958 zig_unreachable();
3959 case TypeTableEntryIdPointer:
3960 return a.data.pointer.child_type == b.data.pointer.child_type &&
3961 a.data.pointer.is_const == b.data.pointer.is_const &&
3962 a.data.pointer.is_volatile == b.data.pointer.is_volatile &&
3963 a.data.pointer.bit_offset == b.data.pointer.bit_offset;
3964 case TypeTableEntryIdArray:
3965 return a.data.array.child_type == b.data.array.child_type &&
3966 a.data.array.size == b.data.array.size;
3967 case TypeTableEntryIdInt:
3968 return a.data.integer.is_signed == b.data.integer.is_signed &&
3969 a.data.integer.bit_count == b.data.integer.bit_count;
3970 }
3971 zig_unreachable();
3888}3972}
src/codegen.cpp+1-1
...@@ -58,7 +58,7 @@ CodeGen *codegen_create(Buf *root_source_dir, const ZigTarget *target) {...@@ -58,7 +58,7 @@ CodeGen *codegen_create(Buf *root_source_dir, const ZigTarget *target) {
58 g->import_table.init(32);58 g->import_table.init(32);
59 g->builtin_fn_table.init(32);59 g->builtin_fn_table.init(32);
60 g->primitive_type_table.init(32);60 g->primitive_type_table.init(32);
61 g->int_type_table.init(8);61 g->type_table.init(32);
62 g->fn_type_table.init(32);62 g->fn_type_table.init(32);
63 g->error_table.init(16);63 g->error_table.init(16);
64 g->generic_table.init(16);64 g->generic_table.init(16);