aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--example/shared_library/mathtest.zig9
-rw-r--r--src/analyze.cpp214
-rw-r--r--src/analyze.hpp7
-rw-r--r--src/codegen.cpp14
-rw-r--r--src/ir.cpp361
-rw-r--r--src/result.hpp36
-rw-r--r--src/util.hpp2
-rw-r--r--std/c/darwin.zig12
-rw-r--r--std/c/linux.zig3
-rw-r--r--std/debug/index.zig779
-rw-r--r--std/elf.zig5
-rw-r--r--std/hash_map.zig16
-rw-r--r--std/index.zig1
-rw-r--r--std/io.zig6
-rw-r--r--std/macho.zig468
-rw-r--r--std/os/index.zig29
16 files changed, 1389 insertions, 573 deletions
diff --git a/example/shared_library/mathtest.zig b/example/shared_library/mathtest.zig
index a04ec1544d..96e41f847c 100644
--- a/example/shared_library/mathtest.zig
+++ b/example/shared_library/mathtest.zig
@@ -1,3 +1,12 @@
+// TODO Remove this workaround
+comptime {
+ const builtin = @import("builtin");
+ if (builtin.os == builtin.Os.macosx) {
+ @export("__mh_execute_header", _mh_execute_header, builtin.GlobalLinkage.Weak);
+ }
+}
+var _mh_execute_header = extern struct {x: usize}{.x = 0};
+
export fn add(a: i32, b: i32) i32 {
return a + b;
}
diff --git a/src/analyze.cpp b/src/analyze.cpp
index da5a5ea69b..a8b3ea7132 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -19,12 +19,12 @@
static const size_t default_backward_branch_quota = 1000;
-static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type);
-static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type);
+static Error resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type);
+static Error resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type);
-static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type);
-static void resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type);
-static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type);
+static Error ATTRIBUTE_MUST_USE resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type);
+static Error ATTRIBUTE_MUST_USE resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type);
+static Error ATTRIBUTE_MUST_USE resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type);
static void analyze_fn_body(CodeGen *g, FnTableEntry *fn_table_entry);
ErrorMsg *add_node_error(CodeGen *g, AstNode *node, Buf *msg) {
@@ -370,15 +370,20 @@ uint64_t type_size_bits(CodeGen *g, TypeTableEntry *type_entry) {
return LLVMSizeOfTypeInBits(g->target_data_ref, type_entry->type_ref);
}
-bool type_is_copyable(CodeGen *g, TypeTableEntry *type_entry) {
- type_ensure_zero_bits_known(g, type_entry);
+Result<bool> type_is_copyable(CodeGen *g, TypeTableEntry *type_entry) {
+ Error err;
+ if ((err = type_ensure_zero_bits_known(g, type_entry)))
+ return err;
+
if (!type_has_bits(type_entry))
return true;
if (!handle_is_ptr(type_entry))
return true;
- ensure_complete_type(g, type_entry);
+ if ((err = ensure_complete_type(g, type_entry)))
+ return err;
+
return type_entry->is_copyable;
}
@@ -447,7 +452,7 @@ TypeTableEntry *get_pointer_to_type_extra(CodeGen *g, TypeTableEntry *child_type
}
}
- type_ensure_zero_bits_known(g, child_type);
+ assertNoError(type_ensure_zero_bits_known(g, child_type));
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdPointer);
entry->is_copyable = true;
@@ -554,11 +559,11 @@ TypeTableEntry *get_optional_type(CodeGen *g, TypeTableEntry *child_type) {
TypeTableEntry *entry = child_type->optional_parent;
return entry;
} else {
- ensure_complete_type(g, child_type);
+ assertNoError(ensure_complete_type(g, child_type));
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdOptional);
assert(child_type->type_ref || child_type->zero_bits);
- entry->is_copyable = type_is_copyable(g, child_type);
+ entry->is_copyable = type_is_copyable(g, child_type).unwrap();
buf_resize(&entry->name, 0);
buf_appendf(&entry->name, "?%s", buf_ptr(&child_type->name));
@@ -650,7 +655,7 @@ TypeTableEntry *get_error_union_type(CodeGen *g, TypeTableEntry *err_set_type, T
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdErrorUnion);
entry->is_copyable = true;
assert(payload_type->di_type);
- ensure_complete_type(g, payload_type);
+ assertNoError(ensure_complete_type(g, payload_type));
buf_resize(&entry->name, 0);
buf_appendf(&entry->name, "%s!%s", buf_ptr(&err_set_type->name), buf_ptr(&payload_type->name));
@@ -739,7 +744,7 @@ TypeTableEntry *get_array_type(CodeGen *g, TypeTableEntry *child_type, uint64_t
return entry;
}
- ensure_complete_type(g, child_type);
+ assertNoError(ensure_complete_type(g, child_type));
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdArray);
entry->zero_bits = (array_size == 0) || child_type->zero_bits;
@@ -1050,13 +1055,13 @@ TypeTableEntry *get_ptr_to_stack_trace_type(CodeGen *g) {
}
TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
+ Error err;
auto table_entry = g->fn_type_table.maybe_get(fn_type_id);
if (table_entry) {
return table_entry->value;
}
if (fn_type_id->return_type != nullptr) {
- ensure_complete_type(g, fn_type_id->return_type);
- if (type_is_invalid(fn_type_id->return_type))
+ if ((err = ensure_complete_type(g, fn_type_id->return_type)))
return g->builtin_types.entry_invalid;
assert(fn_type_id->return_type->id != TypeTableEntryIdOpaque);
} else {
@@ -1172,8 +1177,7 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
gen_param_info->src_index = i;
gen_param_info->gen_index = SIZE_MAX;
- ensure_complete_type(g, type_entry);
- if (type_is_invalid(type_entry))
+ if ((err = ensure_complete_type(g, type_entry)))
return g->builtin_types.entry_invalid;
if (type_has_bits(type_entry)) {
@@ -1493,6 +1497,7 @@ TypeTableEntry *get_auto_err_set_type(CodeGen *g, FnTableEntry *fn_entry) {
static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_scope, FnTableEntry *fn_entry) {
assert(proto_node->type == NodeTypeFnProto);
AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
+ Error err;
FnTypeId fn_type_id = {0};
init_fn_type_id(&fn_type_id, proto_node, proto_node->data.fn_proto.params.length);
@@ -1550,7 +1555,8 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
return g->builtin_types.entry_invalid;
}
if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
- type_ensure_zero_bits_known(g, type_entry);
+ if ((err = type_ensure_zero_bits_known(g, type_entry)))
+ return g->builtin_types.entry_invalid;
if (!type_has_bits(type_entry)) {
add_node_error(g, param_node->data.param_decl.type,
buf_sprintf("parameter of type '%s' has 0 bits; not allowed in function with calling convention '%s'",
@@ -1598,7 +1604,8 @@ static TypeTableEntry *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *c
case TypeTableEntryIdUnion:
case TypeTableEntryIdFn:
case TypeTableEntryIdPromise:
- type_ensure_zero_bits_known(g, type_entry);
+ if ((err = type_ensure_zero_bits_known(g, type_entry)))
+ return g->builtin_types.entry_invalid;
if (type_requires_comptime(type_entry)) {
add_node_error(g, param_node->data.param_decl.type,
buf_sprintf("parameter of type '%s' must be declared comptime",
@@ -1729,24 +1736,28 @@ bool type_is_invalid(TypeTableEntry *type_entry) {
}
-static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
+static Error resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
assert(enum_type->id == TypeTableEntryIdEnum);
+ if (enum_type->data.enumeration.is_invalid)
+ return ErrorSemanticAnalyzeFail;
+
if (enum_type->data.enumeration.complete)
- return;
+ return ErrorNone;
- resolve_enum_zero_bits(g, enum_type);
- if (type_is_invalid(enum_type))
- return;
+ Error err;
+ if ((err = resolve_enum_zero_bits(g, enum_type)))
+ return err;
AstNode *decl_node = enum_type->data.enumeration.decl_node;
if (enum_type->data.enumeration.embedded_in_current) {
if (!enum_type->data.enumeration.reported_infinite_err) {
+ enum_type->data.enumeration.is_invalid = true;
enum_type->data.enumeration.reported_infinite_err = true;
add_node_error(g, decl_node, buf_sprintf("enum '%s' contains itself", buf_ptr(&enum_type->name)));
}
- return;
+ return ErrorSemanticAnalyzeFail;
}
assert(!enum_type->data.enumeration.zero_bits_loop_flag);
@@ -1778,7 +1789,7 @@ static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
enum_type->data.enumeration.complete = true;
if (enum_type->data.enumeration.is_invalid)
- return;
+ return ErrorSemanticAnalyzeFail;
if (enum_type->zero_bits) {
enum_type->type_ref = LLVMVoidType();
@@ -1797,7 +1808,7 @@ static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
ZigLLVMReplaceTemporary(g->dbuilder, enum_type->di_type, replacement_di_type);
enum_type->di_type = replacement_di_type;
- return;
+ return ErrorNone;
}
TypeTableEntry *tag_int_type = enum_type->data.enumeration.tag_int_type;
@@ -1815,6 +1826,7 @@ static void resolve_enum_type(CodeGen *g, TypeTableEntry *enum_type) {
ZigLLVMReplaceTemporary(g->dbuilder, enum_type->di_type, tag_di_type);
enum_type->di_type = tag_di_type;
+ return ErrorNone;
}
@@ -1897,15 +1909,15 @@ TypeTableEntry *get_struct_type(CodeGen *g, const char *type_name, const char *f
return struct_type;
}
-static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
+static Error resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
assert(struct_type->id == TypeTableEntryIdStruct);
if (struct_type->data.structure.complete)
- return;
+ return ErrorNone;
- resolve_struct_zero_bits(g, struct_type);
- if (struct_type->data.structure.is_invalid)
- return;
+ Error err;
+ if ((err = resolve_struct_zero_bits(g, struct_type)))
+ return err;
AstNode *decl_node = struct_type->data.structure.decl_node;
@@ -1916,7 +1928,7 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
add_node_error(g, decl_node,
buf_sprintf("struct '%s' contains itself", buf_ptr(&struct_type->name)));
}
- return;
+ return ErrorSemanticAnalyzeFail;
}
assert(!struct_type->data.structure.zero_bits_loop_flag);
@@ -1943,8 +1955,7 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
TypeTableEntry *field_type = type_struct_field->type_entry;
- ensure_complete_type(g, field_type);
- if (type_is_invalid(field_type)) {
+ if ((err = ensure_complete_type(g, field_type))) {
struct_type->data.structure.is_invalid = true;
break;
}
@@ -2026,7 +2037,7 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
struct_type->data.structure.complete = true;
if (struct_type->data.structure.is_invalid)
- return;
+ return ErrorSemanticAnalyzeFail;
if (struct_type->zero_bits) {
struct_type->type_ref = LLVMVoidType();
@@ -2045,7 +2056,7 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
0, nullptr, di_element_types, (int)debug_field_count, 0, nullptr, "");
ZigLLVMReplaceTemporary(g->dbuilder, struct_type->di_type, replacement_di_type);
struct_type->di_type = replacement_di_type;
- return;
+ return ErrorNone;
}
assert(struct_type->di_type);
@@ -2128,17 +2139,19 @@ static void resolve_struct_type(CodeGen *g, TypeTableEntry *struct_type) {
ZigLLVMReplaceTemporary(g->dbuilder, struct_type->di_type, replacement_di_type);
struct_type->di_type = replacement_di_type;
+
+ return ErrorNone;
}
-static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
+static Error resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
assert(union_type->id == TypeTableEntryIdUnion);
if (union_type->data.unionation.complete)
- return;
+ return ErrorNone;
- resolve_union_zero_bits(g, union_type);
- if (type_is_invalid(union_type))
- return;
+ Error err;
+ if ((err = resolve_union_zero_bits(g, union_type)))
+ return err;
AstNode *decl_node = union_type->data.unionation.decl_node;
@@ -2148,7 +2161,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
union_type->data.unionation.is_invalid = true;
add_node_error(g, decl_node, buf_sprintf("union '%s' contains itself", buf_ptr(&union_type->name)));
}
- return;
+ return ErrorSemanticAnalyzeFail;
}
assert(!union_type->data.unionation.zero_bits_loop_flag);
@@ -2179,8 +2192,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
TypeUnionField *union_field = &union_type->data.unionation.fields[i];
TypeTableEntry *field_type = union_field->type_entry;
- ensure_complete_type(g, field_type);
- if (type_is_invalid(field_type)) {
+ if ((err = ensure_complete_type(g, field_type))) {
union_type->data.unionation.is_invalid = true;
continue;
}
@@ -2219,7 +2231,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
union_type->data.unionation.most_aligned_union_member = most_aligned_union_member;
if (union_type->data.unionation.is_invalid)
- return;
+ return ErrorSemanticAnalyzeFail;
if (union_type->zero_bits) {
union_type->type_ref = LLVMVoidType();
@@ -2238,7 +2250,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
ZigLLVMReplaceTemporary(g->dbuilder, union_type->di_type, replacement_di_type);
union_type->di_type = replacement_di_type;
- return;
+ return ErrorNone;
}
uint64_t padding_in_bits = biggest_size_in_bits - size_of_most_aligned_member_in_bits;
@@ -2274,7 +2286,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
ZigLLVMReplaceTemporary(g->dbuilder, union_type->di_type, replacement_di_type);
union_type->di_type = replacement_di_type;
- return;
+ return ErrorNone;
}
LLVMTypeRef union_type_ref;
@@ -2293,7 +2305,7 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
ZigLLVMReplaceTemporary(g->dbuilder, union_type->di_type, tag_type->di_type);
union_type->di_type = tag_type->di_type;
- return;
+ return ErrorNone;
} else {
union_type_ref = most_aligned_union_member->type_ref;
}
@@ -2367,19 +2379,21 @@ static void resolve_union_type(CodeGen *g, TypeTableEntry *union_type) {
ZigLLVMReplaceTemporary(g->dbuilder, union_type->di_type, replacement_di_type);
union_type->di_type = replacement_di_type;
+
+ return ErrorNone;
}
-static void resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type) {
+static Error resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type) {
assert(enum_type->id == TypeTableEntryIdEnum);
if (enum_type->data.enumeration.zero_bits_known)
- return;
+ return ErrorNone;
if (enum_type->data.enumeration.zero_bits_loop_flag) {
add_node_error(g, enum_type->data.enumeration.decl_node,
buf_sprintf("'%s' depends on itself", buf_ptr(&enum_type->name)));
enum_type->data.enumeration.is_invalid = true;
- return;
+ return ErrorSemanticAnalyzeFail;
}
enum_type->data.enumeration.zero_bits_loop_flag = true;
@@ -2398,7 +2412,7 @@ static void resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type) {
enum_type->data.enumeration.is_invalid = true;
enum_type->data.enumeration.zero_bits_loop_flag = false;
enum_type->data.enumeration.zero_bits_known = true;
- return;
+ return ErrorSemanticAnalyzeFail;
}
enum_type->data.enumeration.src_field_count = field_count;
@@ -2525,13 +2539,23 @@ static void resolve_enum_zero_bits(CodeGen *g, TypeTableEntry *enum_type) {
enum_type->data.enumeration.zero_bits_loop_flag = false;
enum_type->zero_bits = !type_has_bits(tag_int_type);
enum_type->data.enumeration.zero_bits_known = true;
+
+ if (enum_type->data.enumeration.is_invalid)
+ return ErrorSemanticAnalyzeFail;
+
+ return ErrorNone;
}
-static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
+static Error resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
assert(struct_type->id == TypeTableEntryIdStruct);
+ Error err;
+
+ if (struct_type->data.structure.is_invalid)
+ return ErrorSemanticAnalyzeFail;
+
if (struct_type->data.structure.zero_bits_known)
- return;
+ return ErrorNone;
if (struct_type->data.structure.zero_bits_loop_flag) {
// If we get here it's due to recursion. This is a design flaw in the compiler,
@@ -2547,7 +2571,7 @@ static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
struct_type->data.structure.abi_alignment = LLVMABIAlignmentOfType(g->target_data_ref, LLVMPointerType(LLVMInt8Type(), 0));
}
}
- return;
+ return ErrorNone;
}
struct_type->data.structure.zero_bits_loop_flag = true;
@@ -2596,8 +2620,7 @@ static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
buf_sprintf("enums, not structs, support field assignment"));
}
- type_ensure_zero_bits_known(g, field_type);
- if (type_is_invalid(field_type)) {
+ if ((err = type_ensure_zero_bits_known(g, field_type))) {
struct_type->data.structure.is_invalid = true;
continue;
}
@@ -2634,16 +2657,27 @@ static void resolve_struct_zero_bits(CodeGen *g, TypeTableEntry *struct_type) {
struct_type->data.structure.gen_field_count = (uint32_t)gen_field_index;
struct_type->zero_bits = (gen_field_index == 0);
struct_type->data.structure.zero_bits_known = true;
+
+ if (struct_type->data.structure.is_invalid) {
+ return ErrorSemanticAnalyzeFail;
+ }
+
+ return ErrorNone;
}
-static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
+static Error resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
assert(union_type->id == TypeTableEntryIdUnion);
+ Error err;
+
+ if (union_type->data.unionation.is_invalid)
+ return ErrorSemanticAnalyzeFail;
+
if (union_type->data.unionation.zero_bits_known)
- return;
+ return ErrorNone;
if (type_is_invalid(union_type))
- return;
+ return ErrorSemanticAnalyzeFail;
if (union_type->data.unionation.zero_bits_loop_flag) {
// If we get here it's due to recursion. From this we conclude that the struct is
@@ -2660,7 +2694,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
LLVMPointerType(LLVMInt8Type(), 0));
}
}
- return;
+ return ErrorNone;
}
union_type->data.unionation.zero_bits_loop_flag = true;
@@ -2679,7 +2713,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
union_type->data.unionation.is_invalid = true;
union_type->data.unionation.zero_bits_loop_flag = false;
union_type->data.unionation.zero_bits_known = true;
- return;
+ return ErrorSemanticAnalyzeFail;
}
union_type->data.unionation.src_field_count = field_count;
union_type->data.unionation.fields = allocate<TypeUnionField>(field_count);
@@ -2711,13 +2745,13 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
tag_int_type = analyze_type_expr(g, scope, enum_type_node);
if (type_is_invalid(tag_int_type)) {
union_type->data.unionation.is_invalid = true;
- return;
+ return ErrorSemanticAnalyzeFail;
}
if (tag_int_type->id != TypeTableEntryIdInt) {
add_node_error(g, enum_type_node,
buf_sprintf("expected integer tag type, found '%s'", buf_ptr(&tag_int_type->name)));
union_type->data.unionation.is_invalid = true;
- return;
+ return ErrorSemanticAnalyzeFail;
}
} else {
tag_int_type = get_smallest_unsigned_int_type(g, field_count - 1);
@@ -2744,13 +2778,13 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
TypeTableEntry *enum_type = analyze_type_expr(g, scope, enum_type_node);
if (type_is_invalid(enum_type)) {
union_type->data.unionation.is_invalid = true;
- return;
+ return ErrorSemanticAnalyzeFail;
}
if (enum_type->id != TypeTableEntryIdEnum) {
union_type->data.unionation.is_invalid = true;
add_node_error(g, enum_type_node,
buf_sprintf("expected enum tag type, found '%s'", buf_ptr(&enum_type->name)));
- return;
+ return ErrorSemanticAnalyzeFail;
}
tag_type = enum_type;
abi_alignment_so_far = get_abi_alignment(g, enum_type); // this populates src_field_count
@@ -2789,8 +2823,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
}
} else {
field_type = analyze_type_expr(g, scope, field_node->data.struct_field.type);
- type_ensure_zero_bits_known(g, field_type);
- if (type_is_invalid(field_type)) {
+ if ((err = type_ensure_zero_bits_known(g, field_type))) {
union_type->data.unionation.is_invalid = true;
continue;
}
@@ -2883,7 +2916,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
union_type->data.unionation.abi_alignment = abi_alignment_so_far;
if (union_type->data.unionation.is_invalid)
- return;
+ return ErrorSemanticAnalyzeFail;
bool src_have_tag = decl_node->data.container_decl.auto_enum ||
decl_node->data.container_decl.init_arg_expr != nullptr;
@@ -2905,7 +2938,7 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
add_node_error(g, source_node,
buf_sprintf("%s union does not support enum tag type", qual_str));
union_type->data.unionation.is_invalid = true;
- return;
+ return ErrorSemanticAnalyzeFail;
}
if (create_enum_type) {
@@ -2970,6 +3003,11 @@ static void resolve_union_zero_bits(CodeGen *g, TypeTableEntry *union_type) {
union_type->data.unionation.gen_field_count = gen_field_index;
union_type->zero_bits = (gen_field_index == 0 && (field_count < 2 || !src_have_tag));
union_type->data.unionation.zero_bits_known = true;
+
+ if (union_type->data.unionation.is_invalid)
+ return ErrorSemanticAnalyzeFail;
+
+ return ErrorNone;
}
static void get_fully_qualified_decl_name_internal(Buf *buf, Scope *scope, uint8_t sep) {
@@ -3463,13 +3501,13 @@ VariableTableEntry *add_variable(CodeGen *g, AstNode *source_node, Scope *parent
variable_entry->shadowable = false;
variable_entry->mem_slot_index = SIZE_MAX;
variable_entry->src_arg_index = SIZE_MAX;
- variable_entry->align_bytes = get_abi_alignment(g, value->type);
assert(name);
-
buf_init_from_buf(&variable_entry->name, name);
- if (value->type->id != TypeTableEntryIdInvalid) {
+ if (!type_is_invalid(value->type)) {
+ variable_entry->align_bytes = get_abi_alignment(g, value->type);
+
VariableTableEntry *existing_var = find_variable(g, parent_scope, name);
if (existing_var && !existing_var->shadowable) {
ErrorMsg *msg = add_node_error(g, source_node,
@@ -5311,13 +5349,13 @@ ConstExprValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_
void init_const_undefined(CodeGen *g, ConstExprValue *const_val) {
+ Error err;
TypeTableEntry *wanted_type = const_val->type;
if (wanted_type->id == TypeTableEntryIdArray) {
const_val->special = ConstValSpecialStatic;
const_val->data.x_array.special = ConstArraySpecialUndef;
} else if (wanted_type->id == TypeTableEntryIdStruct) {
- ensure_complete_type(g, wanted_type);
- if (type_is_invalid(wanted_type)) {
+ if ((err = ensure_complete_type(g, wanted_type))) {
return;
}
@@ -5350,27 +5388,33 @@ ConstExprValue *create_const_vals(size_t count) {
return vals;
}
-void ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry) {
+Error ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry) {
+ if (type_is_invalid(type_entry))
+ return ErrorSemanticAnalyzeFail;
if (type_entry->id == TypeTableEntryIdStruct) {
if (!type_entry->data.structure.complete)
- resolve_struct_type(g, type_entry);
+ return resolve_struct_type(g, type_entry);
} else if (type_entry->id == TypeTableEntryIdEnum) {
if (!type_entry->data.enumeration.complete)
- resolve_enum_type(g, type_entry);
+ return resolve_enum_type(g, type_entry);
} else if (type_entry->id == TypeTableEntryIdUnion) {
if (!type_entry->data.unionation.complete)
- resolve_union_type(g, type_entry);
+ return resolve_union_type(g, type_entry);
}
+ return ErrorNone;
}
-void type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry) {
+Error type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry) {
+ if (type_is_invalid(type_entry))
+ return ErrorSemanticAnalyzeFail;
if (type_entry->id == TypeTableEntryIdStruct) {
- resolve_struct_zero_bits(g, type_entry);
+ return resolve_struct_zero_bits(g, type_entry);
} else if (type_entry->id == TypeTableEntryIdEnum) {
- resolve_enum_zero_bits(g, type_entry);
+ return resolve_enum_zero_bits(g, type_entry);
} else if (type_entry->id == TypeTableEntryIdUnion) {
- resolve_union_zero_bits(g, type_entry);
+ return resolve_union_zero_bits(g, type_entry);
}
+ return ErrorNone;
}
bool ir_get_var_is_comptime(VariableTableEntry *var) {
@@ -6213,7 +6257,7 @@ LinkLib *add_link_lib(CodeGen *g, Buf *name) {
}
uint32_t get_abi_alignment(CodeGen *g, TypeTableEntry *type_entry) {
- type_ensure_zero_bits_known(g, type_entry);
+ assertNoError(type_ensure_zero_bits_known(g, type_entry));
if (type_entry->zero_bits) return 0;
// We need to make this function work without requiring ensure_complete_type
diff --git a/src/analyze.hpp b/src/analyze.hpp
index e4dfae4ecb..0b52e9a5e6 100644
--- a/src/analyze.hpp
+++ b/src/analyze.hpp
@@ -9,6 +9,7 @@
#define ZIG_ANALYZE_HPP
#include "all_types.hpp"
+#include "result.hpp"
void semantic_analyze(CodeGen *g);
ErrorMsg *add_node_error(CodeGen *g, AstNode *node, Buf *msg);
@@ -88,8 +89,8 @@ void init_fn_type_id(FnTypeId *fn_type_id, AstNode *proto_node, size_t param_cou
AstNode *get_param_decl_node(FnTableEntry *fn_entry, size_t index);
FnTableEntry *scope_get_fn_if_root(Scope *scope);
bool type_requires_comptime(TypeTableEntry *type_entry);
-void ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry);
-void type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry);
+Error ATTRIBUTE_MUST_USE ensure_complete_type(CodeGen *g, TypeTableEntry *type_entry);
+Error ATTRIBUTE_MUST_USE type_ensure_zero_bits_known(CodeGen *g, TypeTableEntry *type_entry);
void complete_enum(CodeGen *g, TypeTableEntry *enum_type);
bool ir_get_var_is_comptime(VariableTableEntry *var);
bool const_values_equal(ConstExprValue *a, ConstExprValue *b);
@@ -178,7 +179,7 @@ TypeTableEntryId type_id_at_index(size_t index);
size_t type_id_len();
size_t type_id_index(TypeTableEntry *entry);
TypeTableEntry *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id);
-bool type_is_copyable(CodeGen *g, TypeTableEntry *type_entry);
+Result<bool> type_is_copyable(CodeGen *g, TypeTableEntry *type_entry);
LinkLib *create_link_lib(Buf *name);
bool calling_convention_does_first_arg_return(CallingConvention cc);
LinkLib *add_link_lib(CodeGen *codegen, Buf *lib);
diff --git a/src/codegen.cpp b/src/codegen.cpp
index e926d14a7e..7ea322c1c3 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -5812,12 +5812,16 @@ static void do_code_gen(CodeGen *g) {
LLVMValueRef global_value;
if (var->linkage == VarLinkageExternal) {
- global_value = LLVMAddGlobal(g->module, var->value->type->type_ref, buf_ptr(&var->name));
-
- // TODO debug info for the extern variable
+ LLVMValueRef existing_llvm_var = LLVMGetNamedGlobal(g->module, buf_ptr(&var->name));
+ if (existing_llvm_var) {
+ global_value = LLVMConstBitCast(existing_llvm_var, LLVMPointerType(var->value->type->type_ref, 0));
+ } else {
+ global_value = LLVMAddGlobal(g->module, var->value->type->type_ref, buf_ptr(&var->name));
+ // TODO debug info for the extern variable
- LLVMSetLinkage(global_value, LLVMExternalLinkage);
- LLVMSetAlignment(global_value, var->align_bytes);
+ LLVMSetLinkage(global_value, LLVMExternalLinkage);
+ LLVMSetAlignment(global_value, var->align_bytes);
+ }
} else {
bool exported = (var->linkage == VarLinkageExport);
const char *mangled_name = buf_ptr(get_mangled_name(g, &var->name, exported));
diff --git a/src/ir.cpp b/src/ir.cpp
index 406af8ee42..5bf39ee691 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -8711,6 +8711,7 @@ static void update_errors_helper(CodeGen *g, ErrorTableEntry ***errors, size_t *
}
static TypeTableEntry *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, TypeTableEntry *expected_type, IrInstruction **instructions, size_t instruction_count) {
+ Error err;
assert(instruction_count >= 1);
IrInstruction *prev_inst = instructions[0];
if (type_is_invalid(prev_inst->value.type)) {
@@ -9172,8 +9173,7 @@ static TypeTableEntry *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_nod
if (prev_type->id == TypeTableEntryIdEnum && cur_type->id == TypeTableEntryIdUnion &&
(cur_type->data.unionation.decl_node->data.container_decl.auto_enum || cur_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
{
- type_ensure_zero_bits_known(ira->codegen, cur_type);
- if (type_is_invalid(cur_type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, cur_type)))
return ira->codegen->builtin_types.entry_invalid;
if (cur_type->data.unionation.tag_type == prev_type) {
continue;
@@ -9183,8 +9183,7 @@ static TypeTableEntry *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_nod
if (cur_type->id == TypeTableEntryIdEnum && prev_type->id == TypeTableEntryIdUnion &&
(prev_type->data.unionation.decl_node->data.container_decl.auto_enum || prev_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
{
- type_ensure_zero_bits_known(ira->codegen, prev_type);
- if (type_is_invalid(prev_type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, prev_type)))
return ira->codegen->builtin_types.entry_invalid;
if (prev_type->data.unionation.tag_type == cur_type) {
prev_inst = cur_inst;
@@ -9999,11 +9998,11 @@ static IrInstruction *ir_analyze_array_to_slice(IrAnalyze *ira, IrInstruction *s
static IrInstruction *ir_analyze_enum_to_int(IrAnalyze *ira, IrInstruction *source_instr,
IrInstruction *target, TypeTableEntry *wanted_type)
{
+ Error err;
assert(wanted_type->id == TypeTableEntryIdInt);
TypeTableEntry *actual_type = target->value.type;
- ensure_complete_type(ira->codegen, actual_type);
- if (type_is_invalid(actual_type))
+ if ((err = ensure_complete_type(ira->codegen, actual_type)))
return ira->codegen->invalid_instruction;
if (wanted_type != actual_type->data.enumeration.tag_int_type) {
@@ -10069,6 +10068,7 @@ static IrInstruction *ir_analyze_undefined_to_anything(IrAnalyze *ira, IrInstruc
static IrInstruction *ir_analyze_enum_to_union(IrAnalyze *ira, IrInstruction *source_instr,
IrInstruction *target, TypeTableEntry *wanted_type)
{
+ Error err;
assert(wanted_type->id == TypeTableEntryIdUnion);
assert(target->value.type->id == TypeTableEntryIdEnum);
@@ -10078,8 +10078,7 @@ static IrInstruction *ir_analyze_enum_to_union(IrAnalyze *ira, IrInstruction *so
return ira->codegen->invalid_instruction;
TypeUnionField *union_field = find_union_field_by_tag(wanted_type, &val->data.x_enum_tag);
assert(union_field != nullptr);
- type_ensure_zero_bits_known(ira->codegen, union_field->type_entry);
- if (type_is_invalid(union_field->type_entry))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, union_field->type_entry)))
return ira->codegen->invalid_instruction;
if (!union_field->type_entry->zero_bits) {
AstNode *field_node = wanted_type->data.unionation.decl_node->data.container_decl.fields.at(
@@ -10169,12 +10168,12 @@ static IrInstruction *ir_analyze_widen_or_shorten(IrAnalyze *ira, IrInstruction
static IrInstruction *ir_analyze_int_to_enum(IrAnalyze *ira, IrInstruction *source_instr,
IrInstruction *target, TypeTableEntry *wanted_type)
{
+ Error err;
assert(wanted_type->id == TypeTableEntryIdEnum);
TypeTableEntry *actual_type = target->value.type;
- ensure_complete_type(ira->codegen, wanted_type);
- if (type_is_invalid(wanted_type))
+ if ((err = ensure_complete_type(ira->codegen, wanted_type)))
return ira->codegen->invalid_instruction;
if (actual_type != wanted_type->data.enumeration.tag_int_type) {
@@ -10517,6 +10516,7 @@ static void report_recursive_error(IrAnalyze *ira, AstNode *source_node, ConstCa
static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_instr,
TypeTableEntry *wanted_type, IrInstruction *value)
{
+ Error err;
TypeTableEntry *actual_type = value->value.type;
AstNode *source_node = source_instr->source_node;
@@ -10796,8 +10796,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
if (actual_type->id == TypeTableEntryIdComptimeFloat ||
actual_type->id == TypeTableEntryIdComptimeInt)
{
- ensure_complete_type(ira->codegen, wanted_type);
- if (type_is_invalid(wanted_type))
+ if ((err = ensure_complete_type(ira->codegen, wanted_type)))
return ira->codegen->invalid_instruction;
if (wanted_type->id == TypeTableEntryIdEnum) {
IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.enumeration.tag_int_type, value);
@@ -10853,8 +10852,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
// cast from union to the enum type of the union
if (actual_type->id == TypeTableEntryIdUnion && wanted_type->id == TypeTableEntryIdEnum) {
- type_ensure_zero_bits_known(ira->codegen, actual_type);
- if (type_is_invalid(actual_type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, actual_type)))
return ira->codegen->invalid_instruction;
if (actual_type->data.unionation.tag_type == wanted_type) {
@@ -10867,7 +10865,9 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
(wanted_type->data.unionation.decl_node->data.container_decl.auto_enum ||
wanted_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr))
{
- type_ensure_zero_bits_known(ira->codegen, wanted_type);
+ if ((err = type_ensure_zero_bits_known(ira->codegen, wanted_type)))
+ return ira->codegen->invalid_instruction;
+
if (wanted_type->data.unionation.tag_type == actual_type) {
return ir_analyze_enum_to_union(ira, source_instr, value, wanted_type);
}
@@ -10879,7 +10879,9 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
if (union_type->data.unionation.decl_node->data.container_decl.auto_enum ||
union_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr)
{
- type_ensure_zero_bits_known(ira->codegen, union_type);
+ if ((err = type_ensure_zero_bits_known(ira->codegen, union_type)))
+ return ira->codegen->invalid_instruction;
+
if (union_type->data.unionation.tag_type == actual_type) {
IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, union_type, value);
if (type_is_invalid(cast1->value.type))
@@ -10923,8 +10925,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
actual_type, source_node, !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk)
{
- type_ensure_zero_bits_known(ira->codegen, actual_type);
- if (type_is_invalid(actual_type)) {
+ if ((err = type_ensure_zero_bits_known(ira->codegen, actual_type))) {
return ira->codegen->invalid_instruction;
}
if (!type_has_bits(actual_type)) {
@@ -11323,6 +11324,7 @@ static bool optional_value_is_null(ConstExprValue *val) {
}
static TypeTableEntry *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
+ Error err;
IrInstruction *op1 = bin_op_instruction->op1->other;
IrInstruction *op2 = bin_op_instruction->op2->other;
AstNode *source_node = bin_op_instruction->base.source_node;
@@ -11458,8 +11460,7 @@ static TypeTableEntry *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp
TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, source_node, nullptr, instructions, 2);
if (type_is_invalid(resolved_type))
return resolved_type;
- type_ensure_zero_bits_known(ira->codegen, resolved_type);
- if (type_is_invalid(resolved_type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, resolved_type)))
return resolved_type;
bool operator_allowed;
@@ -12406,6 +12407,7 @@ static TypeTableEntry *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructi
}
static TypeTableEntry *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDeclVar *decl_var_instruction) {
+ Error err;
VariableTableEntry *var = decl_var_instruction->var;
IrInstruction *init_value = decl_var_instruction->init_value->other;
@@ -12439,8 +12441,7 @@ static TypeTableEntry *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstruc
if (type_is_invalid(result_type)) {
result_type = ira->codegen->builtin_types.entry_invalid;
} else {
- type_ensure_zero_bits_known(ira->codegen, result_type);
- if (type_is_invalid(result_type)) {
+ if ((err = type_ensure_zero_bits_known(ira->codegen, result_type))) {
result_type = ira->codegen->builtin_types.entry_invalid;
}
}
@@ -12958,6 +12959,7 @@ static VariableTableEntry *get_fn_var_by_index(FnTableEntry *fn_entry, size_t in
static IrInstruction *ir_get_var_ptr(IrAnalyze *ira, IrInstruction *instruction,
VariableTableEntry *var)
{
+ Error err;
if (var->mem_slot_index != SIZE_MAX && var->owner_exec->analysis == nullptr) {
assert(ira->codegen->errors.length != 0);
return ira->codegen->invalid_instruction;
@@ -13012,7 +13014,8 @@ no_mem_slot:
instruction->scope, instruction->source_node, var);
var_ptr_instruction->value.type = get_pointer_to_type_extra(ira->codegen, var->value->type,
var->src_is_const, is_volatile, PtrLenSingle, var->align_bytes, 0, 0);
- type_ensure_zero_bits_known(ira->codegen, var->value->type);
+ if ((err = type_ensure_zero_bits_known(ira->codegen, var->value->type)))
+ return ira->codegen->invalid_instruction;
bool in_fn_scope = (scope_fn_entry(var->parent_scope) != nullptr);
var_ptr_instruction->value.data.rh_ptr = in_fn_scope ? RuntimeHintPtrStack : RuntimeHintPtrNonStack;
@@ -13024,6 +13027,7 @@ static TypeTableEntry *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *cal
FnTableEntry *fn_entry, TypeTableEntry *fn_type, IrInstruction *fn_ref,
IrInstruction *first_arg_ptr, bool comptime_fn_call, FnInline fn_inline)
{
+ Error err;
FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
size_t first_arg_1_or_0 = first_arg_ptr ? 1 : 0;
@@ -13388,8 +13392,7 @@ static TypeTableEntry *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *cal
inst_fn_type_id.return_type = specified_return_type;
}
- type_ensure_zero_bits_known(ira->codegen, specified_return_type);
- if (type_is_invalid(specified_return_type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, specified_return_type)))
return ira->codegen->builtin_types.entry_invalid;
if (type_requires_comptime(specified_return_type)) {
@@ -13664,12 +13667,12 @@ static TypeTableEntry *ir_analyze_dereference(IrAnalyze *ira, IrInstructionUnOp
}
static TypeTableEntry *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
+ Error err;
IrInstruction *value = un_op_instruction->value->other;
TypeTableEntry *type_entry = ir_resolve_type(ira, value);
if (type_is_invalid(type_entry))
return ira->codegen->builtin_types.entry_invalid;
- ensure_complete_type(ira->codegen, type_entry);
- if (type_is_invalid(type_entry))
+ if ((err = ensure_complete_type(ira->codegen, type_entry)))
return ira->codegen->builtin_types.entry_invalid;
switch (type_entry->id) {
@@ -14023,6 +14026,7 @@ static TypeTableEntry *adjust_ptr_len(CodeGen *g, TypeTableEntry *ptr_type, PtrL
}
static TypeTableEntry *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionElemPtr *elem_ptr_instruction) {
+ Error err;
IrInstruction *array_ptr = elem_ptr_instruction->array_ptr->other;
if (type_is_invalid(array_ptr->value.type))
return ira->codegen->builtin_types.entry_invalid;
@@ -14131,8 +14135,7 @@ static TypeTableEntry *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruc
return ira->codegen->builtin_types.entry_invalid;
bool safety_check_on = elem_ptr_instruction->safety_check_on;
- ensure_complete_type(ira->codegen, return_type->data.pointer.child_type);
- if (type_is_invalid(return_type->data.pointer.child_type))
+ if ((err = ensure_complete_type(ira->codegen, return_type->data.pointer.child_type)))
return ira->codegen->builtin_types.entry_invalid;
uint64_t elem_size = type_size(ira->codegen, return_type->data.pointer.child_type);
@@ -14352,9 +14355,10 @@ static IrInstruction *ir_analyze_container_member_access_inner(IrAnalyze *ira,
static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name,
IrInstruction *source_instr, IrInstruction *container_ptr, TypeTableEntry *container_type)
{
+ Error err;
+
TypeTableEntry *bare_type = container_ref_type(container_type);
- ensure_complete_type(ira->codegen, bare_type);
- if (type_is_invalid(bare_type))
+ if ((err = ensure_complete_type(ira->codegen, bare_type)))
return ira->codegen->invalid_instruction;
assert(container_ptr->value.type->id == TypeTableEntryIdPointer);
@@ -14553,6 +14557,7 @@ static ErrorTableEntry *find_err_table_entry(TypeTableEntry *err_set_type, Buf *
}
static TypeTableEntry *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFieldPtr *field_ptr_instruction) {
+ Error err;
IrInstruction *container_ptr = field_ptr_instruction->container_ptr->other;
if (type_is_invalid(container_ptr->value.type))
return ira->codegen->builtin_types.entry_invalid;
@@ -14654,8 +14659,7 @@ static TypeTableEntry *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstru
ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
}
if (child_type->id == TypeTableEntryIdEnum) {
- ensure_complete_type(ira->codegen, child_type);
- if (type_is_invalid(child_type))
+ if ((err = ensure_complete_type(ira->codegen, child_type)))
return ira->codegen->builtin_types.entry_invalid;
TypeEnumField *field = find_enum_type_field(child_type, field_name);
@@ -14679,8 +14683,7 @@ static TypeTableEntry *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstru
(child_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr ||
child_type->data.unionation.decl_node->data.container_decl.auto_enum))
{
- ensure_complete_type(ira->codegen, child_type);
- if (type_is_invalid(child_type))
+ if ((err = ensure_complete_type(ira->codegen, child_type)))
return ira->codegen->builtin_types.entry_invalid;
TypeUnionField *field = find_union_type_field(child_type, field_name);
if (field) {
@@ -15257,6 +15260,7 @@ static TypeTableEntry *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
static TypeTableEntry *ir_analyze_instruction_slice_type(IrAnalyze *ira,
IrInstructionSliceType *slice_type_instruction)
{
+ Error err;
uint32_t align_bytes;
if (slice_type_instruction->align_value != nullptr) {
if (!ir_resolve_align(ira, slice_type_instruction->align_value->other, &align_bytes))
@@ -15268,6 +15272,8 @@ static TypeTableEntry *ir_analyze_instruction_slice_type(IrAnalyze *ira,
return ira->codegen->builtin_types.entry_invalid;
if (slice_type_instruction->align_value == nullptr) {
+ if ((err = type_ensure_zero_bits_known(ira->codegen, child_type)))
+ return ira->codegen->builtin_types.entry_invalid;
align_bytes = get_abi_alignment(ira->codegen, child_type);
}
@@ -15306,7 +15312,8 @@ static TypeTableEntry *ir_analyze_instruction_slice_type(IrAnalyze *ira,
case TypeTableEntryIdBoundFn:
case TypeTableEntryIdPromise:
{
- type_ensure_zero_bits_known(ira->codegen, child_type);
+ if ((err = type_ensure_zero_bits_known(ira->codegen, child_type)))
+ return ira->codegen->builtin_types.entry_invalid;
TypeTableEntry *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
is_const, is_volatile, PtrLenUnknown, align_bytes, 0, 0);
TypeTableEntry *result_type = get_slice_type(ira->codegen, slice_ptr_type);
@@ -15444,11 +15451,11 @@ static TypeTableEntry *ir_analyze_instruction_promise_type(IrAnalyze *ira, IrIns
static TypeTableEntry *ir_analyze_instruction_size_of(IrAnalyze *ira,
IrInstructionSizeOf *size_of_instruction)
{
+ Error err;
IrInstruction *type_value = size_of_instruction->type_value->other;
TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
- ensure_complete_type(ira->codegen, type_entry);
- if (type_is_invalid(type_entry))
+ if ((err = ensure_complete_type(ira->codegen, type_entry)))
return ira->codegen->builtin_types.entry_invalid;
switch (type_entry->id) {
@@ -15819,6 +15826,7 @@ static TypeTableEntry *ir_analyze_instruction_switch_br(IrAnalyze *ira,
static TypeTableEntry *ir_analyze_instruction_switch_target(IrAnalyze *ira,
IrInstructionSwitchTarget *switch_target_instruction)
{
+ Error err;
IrInstruction *target_value_ptr = switch_target_instruction->target_value_ptr->other;
if (type_is_invalid(target_value_ptr->value.type))
return ira->codegen->builtin_types.entry_invalid;
@@ -15845,8 +15853,7 @@ static TypeTableEntry *ir_analyze_instruction_switch_target(IrAnalyze *ira,
if (pointee_val->special == ConstValSpecialRuntime)
pointee_val = nullptr;
}
- ensure_complete_type(ira->codegen, target_type);
- if (type_is_invalid(target_type))
+ if ((err = ensure_complete_type(ira->codegen, target_type)))
return ira->codegen->builtin_types.entry_invalid;
switch (target_type->id) {
@@ -15910,8 +15917,7 @@ static TypeTableEntry *ir_analyze_instruction_switch_target(IrAnalyze *ira,
return tag_type;
}
case TypeTableEntryIdEnum: {
- type_ensure_zero_bits_known(ira->codegen, target_type);
- if (type_is_invalid(target_type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, target_type)))
return ira->codegen->builtin_types.entry_invalid;
if (target_type->data.enumeration.src_field_count < 2) {
TypeEnumField *only_field = &target_type->data.enumeration.fields[0];
@@ -16113,10 +16119,10 @@ static TypeTableEntry *ir_analyze_instruction_ref(IrAnalyze *ira, IrInstructionR
static TypeTableEntry *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruction *instruction,
TypeTableEntry *container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField *fields)
{
+ Error err;
assert(container_type->id == TypeTableEntryIdUnion);
- ensure_complete_type(ira->codegen, container_type);
- if (type_is_invalid(container_type))
+ if ((err = ensure_complete_type(ira->codegen, container_type)))
return ira->codegen->builtin_types.entry_invalid;
if (instr_field_count != 1) {
@@ -16145,8 +16151,7 @@ static TypeTableEntry *ir_analyze_container_init_fields_union(IrAnalyze *ira, Ir
if (casted_field_value == ira->codegen->invalid_instruction)
return ira->codegen->builtin_types.entry_invalid;
- type_ensure_zero_bits_known(ira->codegen, casted_field_value->value.type);
- if (type_is_invalid(casted_field_value->value.type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, casted_field_value->value.type)))
return ira->codegen->builtin_types.entry_invalid;
bool is_comptime = ir_should_inline(ira->new_irb.exec, instruction->scope);
@@ -16180,6 +16185,7 @@ static TypeTableEntry *ir_analyze_container_init_fields_union(IrAnalyze *ira, Ir
static TypeTableEntry *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *instruction,
TypeTableEntry *container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField *fields)
{
+ Error err;
if (container_type->id == TypeTableEntryIdUnion) {
return ir_analyze_container_init_fields_union(ira, instruction, container_type, instr_field_count, fields);
}
@@ -16190,8 +16196,7 @@ static TypeTableEntry *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstru
return ira->codegen->builtin_types.entry_invalid;
}
- ensure_complete_type(ira->codegen, container_type);
- if (type_is_invalid(container_type))
+ if ((err = ensure_complete_type(ira->codegen, container_type)))
return ira->codegen->builtin_types.entry_invalid;
size_t actual_field_count = container_type->data.structure.src_field_count;
@@ -16572,6 +16577,7 @@ static TypeTableEntry *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstruc
}
static TypeTableEntry *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrInstructionTagName *instruction) {
+ Error err;
IrInstruction *target = instruction->target->other;
if (type_is_invalid(target->value.type))
return ira->codegen->builtin_types.entry_invalid;
@@ -16579,8 +16585,7 @@ static TypeTableEntry *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrIn
assert(target->value.type->id == TypeTableEntryIdEnum);
if (instr_is_comptime(target)) {
- type_ensure_zero_bits_known(ira->codegen, target->value.type);
- if (type_is_invalid(target->value.type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, target->value.type)))
return ira->codegen->builtin_types.entry_invalid;
TypeEnumField *field = find_enum_field_by_tag(target->value.type, &target->value.data.x_bigint);
ConstExprValue *array_val = create_const_str_lit(ira->codegen, field->name);
@@ -16604,6 +16609,7 @@ static TypeTableEntry *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrIn
static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
IrInstructionFieldParentPtr *instruction)
{
+ Error err;
IrInstruction *type_value = instruction->type_value->other;
TypeTableEntry *container_type = ir_resolve_type(ira, type_value);
if (type_is_invalid(container_type))
@@ -16624,8 +16630,7 @@ static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
return ira->codegen->builtin_types.entry_invalid;
}
- ensure_complete_type(ira->codegen, container_type);
- if (type_is_invalid(container_type))
+ if ((err = ensure_complete_type(ira->codegen, container_type)))
return ira->codegen->builtin_types.entry_invalid;
TypeStructField *field = find_struct_type_field(container_type, field_name);
@@ -16697,13 +16702,13 @@ static TypeTableEntry *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
static TypeTableEntry *ir_analyze_instruction_offset_of(IrAnalyze *ira,
IrInstructionOffsetOf *instruction)
{
+ Error err;
IrInstruction *type_value = instruction->type_value->other;
TypeTableEntry *container_type = ir_resolve_type(ira, type_value);
if (type_is_invalid(container_type))
return ira->codegen->builtin_types.entry_invalid;
- ensure_complete_type(ira->codegen, container_type);
- if (type_is_invalid(container_type))
+ if ((err = ensure_complete_type(ira->codegen, container_type)))
return ira->codegen->builtin_types.entry_invalid;
IrInstruction *field_name_value = instruction->field_name->other;
@@ -16748,19 +16753,15 @@ static void ensure_field_index(TypeTableEntry *type, const char *field_name, siz
(buf_deinit(field_name_buf), true));
}
-static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_name, TypeTableEntry *root = nullptr)
-{
+static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_name, TypeTableEntry *root) {
+ Error err;
static ConstExprValue *type_info_var = nullptr;
static TypeTableEntry *type_info_type = nullptr;
- if (type_info_var == nullptr)
- {
+ if (type_info_var == nullptr) {
type_info_var = get_builtin_value(ira->codegen, "TypeInfo");
assert(type_info_var->type->id == TypeTableEntryIdMetaType);
- ensure_complete_type(ira->codegen, type_info_var->data.x_type);
- if (type_is_invalid(type_info_var->data.x_type))
- return ira->codegen->builtin_types.entry_invalid;
-
+ assertNoError(ensure_complete_type(ira->codegen, type_info_var->data.x_type));
type_info_type = type_info_var->data.x_type;
assert(type_info_type->id == TypeTableEntryIdUnion);
}
@@ -16785,8 +16786,7 @@ static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_na
VariableTableEntry *var = tld->var;
- ensure_complete_type(ira->codegen, var->value->type);
- if (type_is_invalid(var->value->type))
+ if ((err = ensure_complete_type(ira->codegen, var->value->type)))
return ira->codegen->builtin_types.entry_invalid;
assert(var->value->type->id == TypeTableEntryIdMetaType);
return var->value->data.x_type;
@@ -16794,9 +16794,9 @@ static TypeTableEntry *ir_type_info_get_type(IrAnalyze *ira, const char *type_na
static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, ScopeDecls *decls_scope)
{
- TypeTableEntry *type_info_definition_type = ir_type_info_get_type(ira, "Definition");
- ensure_complete_type(ira->codegen, type_info_definition_type);
- if (type_is_invalid(type_info_definition_type))
+ Error err;
+ TypeTableEntry *type_info_definition_type = ir_type_info_get_type(ira, "Definition", nullptr);
+ if ((err = ensure_complete_type(ira->codegen, type_info_definition_type)))
return false;
ensure_field_index(type_info_definition_type, "name", 0);
@@ -16804,18 +16804,15 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
ensure_field_index(type_info_definition_type, "data", 2);
TypeTableEntry *type_info_definition_data_type = ir_type_info_get_type(ira, "Data", type_info_definition_type);
- ensure_complete_type(ira->codegen, type_info_definition_data_type);
- if (type_is_invalid(type_info_definition_data_type))
+ if ((err = ensure_complete_type(ira->codegen, type_info_definition_data_type)))
return false;
TypeTableEntry *type_info_fn_def_type = ir_type_info_get_type(ira, "FnDef", type_info_definition_data_type);
- ensure_complete_type(ira->codegen, type_info_fn_def_type);
- if (type_is_invalid(type_info_fn_def_type))
+ if ((err = ensure_complete_type(ira->codegen, type_info_fn_def_type)))
return false;
TypeTableEntry *type_info_fn_def_inline_type = ir_type_info_get_type(ira, "Inline", type_info_fn_def_type);
- ensure_complete_type(ira->codegen, type_info_fn_def_inline_type);
- if (type_is_invalid(type_info_fn_def_inline_type))
+ if ((err = ensure_complete_type(ira->codegen, type_info_fn_def_inline_type)))
return false;
// Loop through our definitions once to figure out how many definitions we will generate info for.
@@ -16895,8 +16892,7 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
case TldIdVar:
{
VariableTableEntry *var = ((TldVar *)curr_entry->value)->var;
- ensure_complete_type(ira->codegen, var->value->type);
- if (type_is_invalid(var->value->type))
+ if ((err = ensure_complete_type(ira->codegen, var->value->type)))
return false;
if (var->value->type->id == TypeTableEntryIdMetaType)
@@ -16953,7 +16949,7 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
// calling_convention: TypeInfo.CallingConvention
ensure_field_index(fn_def_val->type, "calling_convention", 2);
fn_def_fields[2].special = ConstValSpecialStatic;
- fn_def_fields[2].type = ir_type_info_get_type(ira, "CallingConvention");
+ fn_def_fields[2].type = ir_type_info_get_type(ira, "CallingConvention", nullptr);
bigint_init_unsigned(&fn_def_fields[2].data.x_enum_tag, fn_node->cc);
// is_var_args: bool
ensure_field_index(fn_def_val->type, "is_var_args", 3);
@@ -17027,8 +17023,7 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
case TldIdContainer:
{
TypeTableEntry *type_entry = ((TldContainer *)curr_entry->value)->type_entry;
- ensure_complete_type(ira->codegen, type_entry);
- if (type_is_invalid(type_entry))
+ if ((err = ensure_complete_type(ira->codegen, type_entry)))
return false;
// This is a type.
@@ -17054,12 +17049,67 @@ static bool ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Scop
return true;
}
+static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, TypeTableEntry *ptr_type_entry) {
+ TypeTableEntry *attrs_type;
+ uint32_t size_enum_index;
+ if (is_slice(ptr_type_entry)) {
+ attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index].type_entry;
+ size_enum_index = 2;
+ } else if (ptr_type_entry->id == TypeTableEntryIdPointer) {
+ attrs_type = ptr_type_entry;
+ size_enum_index = (ptr_type_entry->data.pointer.ptr_len == PtrLenSingle) ? 0 : 1;
+ } else {
+ zig_unreachable();
+ }
+
+ TypeTableEntry *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer", nullptr);
+ assertNoError(ensure_complete_type(ira->codegen, type_info_pointer_type));
+
+ ConstExprValue *result = create_const_vals(1);
+ result->special = ConstValSpecialStatic;
+ result->type = type_info_pointer_type;
+
+ ConstExprValue *fields = create_const_vals(5);
+ result->data.x_struct.fields = fields;
+
+ // size: Size
+ ensure_field_index(result->type, "size", 0);
+ TypeTableEntry *type_info_pointer_size_type = ir_type_info_get_type(ira, "Size", type_info_pointer_type);
+ assertNoError(ensure_complete_type(ira->codegen, type_info_pointer_size_type));
+ fields[0].special = ConstValSpecialStatic;
+ fields[0].type = type_info_pointer_size_type;
+ bigint_init_unsigned(&fields[0].data.x_enum_tag, size_enum_index);
+
+ // is_const: bool
+ ensure_field_index(result->type, "is_const", 1);
+ fields[1].special = ConstValSpecialStatic;
+ fields[1].type = ira->codegen->builtin_types.entry_bool;
+ fields[1].data.x_bool = attrs_type->data.pointer.is_const;
+ // is_volatile: bool
+ ensure_field_index(result->type, "is_volatile", 2);
+ fields[2].special = ConstValSpecialStatic;
+ fields[2].type = ira->codegen->builtin_types.entry_bool;
+ fields[2].data.x_bool = attrs_type->data.pointer.is_volatile;
+ // alignment: u32
+ ensure_field_index(result->type, "alignment", 3);
+ fields[3].special = ConstValSpecialStatic;
+ fields[3].type = get_int_type(ira->codegen, false, 29);
+ bigint_init_unsigned(&fields[3].data.x_bigint, attrs_type->data.pointer.alignment);
+ // child: type
+ ensure_field_index(result->type, "child", 4);
+ fields[4].special = ConstValSpecialStatic;
+ fields[4].type = ira->codegen->builtin_types.entry_type;
+ fields[4].data.x_type = attrs_type->data.pointer.child_type;
+
+ return result;
+};
+
static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *type_entry) {
+ Error err;
assert(type_entry != nullptr);
assert(!type_is_invalid(type_entry));
- ensure_complete_type(ira->codegen, type_entry);
- if (type_is_invalid(type_entry))
+ if ((err = ensure_complete_type(ira->codegen, type_entry)))
return nullptr;
const auto make_enum_field_val = [ira](ConstExprValue *enum_field_val, TypeEnumField *enum_field,
@@ -17079,63 +17129,6 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
enum_field_val->data.x_struct.fields = inner_fields;
};
- const auto create_ptr_like_type_info = [ira](TypeTableEntry *ptr_type_entry) {
- TypeTableEntry *attrs_type;
- uint32_t size_enum_index;
- if (is_slice(ptr_type_entry)) {
- attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index].type_entry;
- size_enum_index = 2;
- } else if (ptr_type_entry->id == TypeTableEntryIdPointer) {
- attrs_type = ptr_type_entry;
- size_enum_index = (ptr_type_entry->data.pointer.ptr_len == PtrLenSingle) ? 0 : 1;
- } else {
- zig_unreachable();
- }
-
- TypeTableEntry *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer");
- ensure_complete_type(ira->codegen, type_info_pointer_type);
- assert(!type_is_invalid(type_info_pointer_type));
-
- ConstExprValue *result = create_const_vals(1);
- result->special = ConstValSpecialStatic;
- result->type = type_info_pointer_type;
-
- ConstExprValue *fields = create_const_vals(5);
- result->data.x_struct.fields = fields;
-
- // size: Size
- ensure_field_index(result->type, "size", 0);
- TypeTableEntry *type_info_pointer_size_type = ir_type_info_get_type(ira, "Size", type_info_pointer_type);
- ensure_complete_type(ira->codegen, type_info_pointer_size_type);
- assert(!type_is_invalid(type_info_pointer_size_type));
- fields[0].special = ConstValSpecialStatic;
- fields[0].type = type_info_pointer_size_type;
- bigint_init_unsigned(&fields[0].data.x_enum_tag, size_enum_index);
-
- // is_const: bool
- ensure_field_index(result->type, "is_const", 1);
- fields[1].special = ConstValSpecialStatic;
- fields[1].type = ira->codegen->builtin_types.entry_bool;
- fields[1].data.x_bool = attrs_type->data.pointer.is_const;
- // is_volatile: bool
- ensure_field_index(result->type, "is_volatile", 2);
- fields[2].special = ConstValSpecialStatic;
- fields[2].type = ira->codegen->builtin_types.entry_bool;
- fields[2].data.x_bool = attrs_type->data.pointer.is_volatile;
- // alignment: u32
- ensure_field_index(result->type, "alignment", 3);
- fields[3].special = ConstValSpecialStatic;
- fields[3].type = get_int_type(ira->codegen, false, 29);
- bigint_init_unsigned(&fields[3].data.x_bigint, attrs_type->data.pointer.alignment);
- // child: type
- ensure_field_index(result->type, "child", 4);
- fields[4].special = ConstValSpecialStatic;
- fields[4].type = ira->codegen->builtin_types.entry_type;
- fields[4].data.x_type = attrs_type->data.pointer.child_type;
-
- return result;
- };
-
if (type_entry == ira->codegen->builtin_types.entry_global_error_set) {
zig_panic("TODO implement @typeInfo for global error set");
}
@@ -17171,7 +17164,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Int");
+ result->type = ir_type_info_get_type(ira, "Int", nullptr);
ConstExprValue *fields = create_const_vals(2);
result->data.x_struct.fields = fields;
@@ -17193,7 +17186,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Float");
+ result->type = ir_type_info_get_type(ira, "Float", nullptr);
ConstExprValue *fields = create_const_vals(1);
result->data.x_struct.fields = fields;
@@ -17208,14 +17201,14 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
}
case TypeTableEntryIdPointer:
{
- result = create_ptr_like_type_info(type_entry);
+ result = create_ptr_like_type_info(ira, type_entry);
break;
}
case TypeTableEntryIdArray:
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Array");
+ result->type = ir_type_info_get_type(ira, "Array", nullptr);
ConstExprValue *fields = create_const_vals(2);
result->data.x_struct.fields = fields;
@@ -17237,7 +17230,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Optional");
+ result->type = ir_type_info_get_type(ira, "Optional", nullptr);
ConstExprValue *fields = create_const_vals(1);
result->data.x_struct.fields = fields;
@@ -17254,7 +17247,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Promise");
+ result->type = ir_type_info_get_type(ira, "Promise", nullptr);
ConstExprValue *fields = create_const_vals(1);
result->data.x_struct.fields = fields;
@@ -17280,7 +17273,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Enum");
+ result->type = ir_type_info_get_type(ira, "Enum", nullptr);
ConstExprValue *fields = create_const_vals(4);
result->data.x_struct.fields = fields;
@@ -17288,7 +17281,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
// layout: ContainerLayout
ensure_field_index(result->type, "layout", 0);
fields[0].special = ConstValSpecialStatic;
- fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+ fields[0].type = ir_type_info_get_type(ira, "ContainerLayout", nullptr);
bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.enumeration.layout);
// tag_type: type
ensure_field_index(result->type, "tag_type", 1);
@@ -17298,7 +17291,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
// fields: []TypeInfo.EnumField
ensure_field_index(result->type, "fields", 2);
- TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
+ TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
uint32_t enum_field_count = type_entry->data.enumeration.src_field_count;
ConstExprValue *enum_field_array = create_const_vals(1);
@@ -17330,7 +17323,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "ErrorSet");
+ result->type = ir_type_info_get_type(ira, "ErrorSet", nullptr);
ConstExprValue *fields = create_const_vals(1);
result->data.x_struct.fields = fields;
@@ -17338,7 +17331,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
// errors: []TypeInfo.Error
ensure_field_index(result->type, "errors", 0);
- TypeTableEntry *type_info_error_type = ir_type_info_get_type(ira, "Error");
+ TypeTableEntry *type_info_error_type = ir_type_info_get_type(ira, "Error", nullptr);
uint32_t error_count = type_entry->data.error_set.err_count;
ConstExprValue *error_array = create_const_vals(1);
error_array->special = ConstValSpecialStatic;
@@ -17380,7 +17373,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "ErrorUnion");
+ result->type = ir_type_info_get_type(ira, "ErrorUnion", nullptr);
ConstExprValue *fields = create_const_vals(2);
result->data.x_struct.fields = fields;
@@ -17403,7 +17396,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Union");
+ result->type = ir_type_info_get_type(ira, "Union", nullptr);
ConstExprValue *fields = create_const_vals(4);
result->data.x_struct.fields = fields;
@@ -17411,7 +17404,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
// layout: ContainerLayout
ensure_field_index(result->type, "layout", 0);
fields[0].special = ConstValSpecialStatic;
- fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+ fields[0].type = ir_type_info_get_type(ira, "ContainerLayout", nullptr);
bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.unionation.layout);
// tag_type: ?type
ensure_field_index(result->type, "tag_type", 1);
@@ -17433,7 +17426,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
// fields: []TypeInfo.UnionField
ensure_field_index(result->type, "fields", 2);
- TypeTableEntry *type_info_union_field_type = ir_type_info_get_type(ira, "UnionField");
+ TypeTableEntry *type_info_union_field_type = ir_type_info_get_type(ira, "UnionField", nullptr);
uint32_t union_field_count = type_entry->data.unionation.src_field_count;
ConstExprValue *union_field_array = create_const_vals(1);
@@ -17445,7 +17438,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
init_const_slice(ira->codegen, &fields[2], union_field_array, 0, union_field_count, false);
- TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
+ TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++) {
TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];
@@ -17487,13 +17480,13 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
case TypeTableEntryIdStruct:
{
if (type_entry->data.structure.is_slice) {
- result = create_ptr_like_type_info(type_entry);
+ result = create_ptr_like_type_info(ira, type_entry);
break;
}
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Struct");
+ result->type = ir_type_info_get_type(ira, "Struct", nullptr);
ConstExprValue *fields = create_const_vals(3);
result->data.x_struct.fields = fields;
@@ -17501,12 +17494,12 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
// layout: ContainerLayout
ensure_field_index(result->type, "layout", 0);
fields[0].special = ConstValSpecialStatic;
- fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
+ fields[0].type = ir_type_info_get_type(ira, "ContainerLayout", nullptr);
bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.structure.layout);
// fields: []TypeInfo.StructField
ensure_field_index(result->type, "fields", 1);
- TypeTableEntry *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField");
+ TypeTableEntry *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField", nullptr);
uint32_t struct_field_count = type_entry->data.structure.src_field_count;
ConstExprValue *struct_field_array = create_const_vals(1);
@@ -17562,7 +17555,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
{
result = create_const_vals(1);
result->special = ConstValSpecialStatic;
- result->type = ir_type_info_get_type(ira, "Fn");
+ result->type = ir_type_info_get_type(ira, "Fn", nullptr);
ConstExprValue *fields = create_const_vals(6);
result->data.x_struct.fields = fields;
@@ -17570,7 +17563,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
// calling_convention: TypeInfo.CallingConvention
ensure_field_index(result->type, "calling_convention", 0);
fields[0].special = ConstValSpecialStatic;
- fields[0].type = ir_type_info_get_type(ira, "CallingConvention");
+ fields[0].type = ir_type_info_get_type(ira, "CallingConvention", nullptr);
bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.fn.fn_type_id.cc);
// is_generic: bool
ensure_field_index(result->type, "is_generic", 1);
@@ -17611,7 +17604,7 @@ static ConstExprValue *ir_make_type_info_value(IrAnalyze *ira, TypeTableEntry *t
fields[4].data.x_optional = async_alloc_type;
}
// args: []TypeInfo.FnArg
- TypeTableEntry *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg");
+ TypeTableEntry *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg", nullptr);
size_t fn_arg_count = type_entry->data.fn.fn_type_id.param_count -
(is_varargs && type_entry->data.fn.fn_type_id.cc != CallingConventionC);
@@ -17686,7 +17679,7 @@ static TypeTableEntry *ir_analyze_instruction_type_info(IrAnalyze *ira,
if (type_is_invalid(type_entry))
return ira->codegen->builtin_types.entry_invalid;
- TypeTableEntry *result_type = ir_type_info_get_type(ira, nullptr);
+ TypeTableEntry *result_type = ir_type_info_get_type(ira, nullptr, nullptr);
ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
out_val->type = result_type;
@@ -18896,13 +18889,13 @@ static TypeTableEntry *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructio
}
static TypeTableEntry *ir_analyze_instruction_member_count(IrAnalyze *ira, IrInstructionMemberCount *instruction) {
+ Error err;
IrInstruction *container = instruction->container->other;
if (type_is_invalid(container->value.type))
return ira->codegen->builtin_types.entry_invalid;
TypeTableEntry *container_type = ir_resolve_type(ira, container);
- ensure_complete_type(ira->codegen, container_type);
- if (type_is_invalid(container_type))
+ if ((err = ensure_complete_type(ira->codegen, container_type)))
return ira->codegen->builtin_types.entry_invalid;
uint64_t result;
@@ -18934,13 +18927,13 @@ static TypeTableEntry *ir_analyze_instruction_member_count(IrAnalyze *ira, IrIns
}
static TypeTableEntry *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInstructionMemberType *instruction) {
+ Error err;
IrInstruction *container_type_value = instruction->container_type->other;
TypeTableEntry *container_type = ir_resolve_type(ira, container_type_value);
if (type_is_invalid(container_type))
return ira->codegen->builtin_types.entry_invalid;
- ensure_complete_type(ira->codegen, container_type);
- if (type_is_invalid(container_type))
+ if ((err = ensure_complete_type(ira->codegen, container_type)))
return ira->codegen->builtin_types.entry_invalid;
@@ -18981,13 +18974,13 @@ static TypeTableEntry *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInst
}
static TypeTableEntry *ir_analyze_instruction_member_name(IrAnalyze *ira, IrInstructionMemberName *instruction) {
+ Error err;
IrInstruction *container_type_value = instruction->container_type->other;
TypeTableEntry *container_type = ir_resolve_type(ira, container_type_value);
if (type_is_invalid(container_type))
return ira->codegen->builtin_types.entry_invalid;
- ensure_complete_type(ira->codegen, container_type);
- if (type_is_invalid(container_type))
+ if ((err = ensure_complete_type(ira->codegen, container_type)))
return ira->codegen->builtin_types.entry_invalid;
uint64_t member_index;
@@ -19068,13 +19061,13 @@ static TypeTableEntry *ir_analyze_instruction_handle(IrAnalyze *ira, IrInstructi
}
static TypeTableEntry *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAlignOf *instruction) {
+ Error err;
IrInstruction *type_value = instruction->type_value->other;
if (type_is_invalid(type_value->value.type))
return ira->codegen->builtin_types.entry_invalid;
TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
- type_ensure_zero_bits_known(ira->codegen, type_entry);
- if (type_is_invalid(type_entry))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, type_entry)))
return ira->codegen->builtin_types.entry_invalid;
switch (type_entry->id) {
@@ -19930,6 +19923,7 @@ static void buf_read_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
}
static TypeTableEntry *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBitCast *instruction) {
+ Error err;
IrInstruction *dest_type_value = instruction->dest_type->other;
TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
if (type_is_invalid(dest_type))
@@ -19940,12 +19934,10 @@ static TypeTableEntry *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstruc
if (type_is_invalid(src_type))
return ira->codegen->builtin_types.entry_invalid;
- ensure_complete_type(ira->codegen, dest_type);
- if (type_is_invalid(dest_type))
+ if ((err = ensure_complete_type(ira->codegen, dest_type)))
return ira->codegen->builtin_types.entry_invalid;
- ensure_complete_type(ira->codegen, src_type);
- if (type_is_invalid(src_type))
+ if ((err = ensure_complete_type(ira->codegen, src_type)))
return ira->codegen->builtin_types.entry_invalid;
if (get_codegen_ptr_type(src_type) != nullptr) {
@@ -20031,6 +20023,7 @@ static TypeTableEntry *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstruc
}
static TypeTableEntry *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstructionIntToPtr *instruction) {
+ Error err;
IrInstruction *dest_type_value = instruction->dest_type->other;
TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
if (type_is_invalid(dest_type))
@@ -20041,7 +20034,8 @@ static TypeTableEntry *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstr
return ira->codegen->builtin_types.entry_invalid;
}
- type_ensure_zero_bits_known(ira->codegen, dest_type);
+ if ((err = type_ensure_zero_bits_known(ira->codegen, dest_type)))
+ return ira->codegen->builtin_types.entry_invalid;
if (!type_has_bits(dest_type)) {
ir_add_error(ira, dest_type_value,
buf_sprintf("type '%s' has 0 bits and cannot store information", buf_ptr(&dest_type->name)));
@@ -20174,6 +20168,7 @@ static TypeTableEntry *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstr
}
static TypeTableEntry *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstructionPtrType *instruction) {
+ Error err;
TypeTableEntry *child_type = ir_resolve_type(ira, instruction->child_type->other);
if (type_is_invalid(child_type))
return ira->codegen->builtin_types.entry_invalid;
@@ -20191,8 +20186,7 @@ static TypeTableEntry *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstruc
if (!ir_resolve_align(ira, instruction->align_value->other, &align_bytes))
return ira->codegen->builtin_types.entry_invalid;
} else {
- type_ensure_zero_bits_known(ira->codegen, child_type);
- if (type_is_invalid(child_type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, child_type)))
return ira->codegen->builtin_types.entry_invalid;
align_bytes = get_abi_alignment(ira->codegen, child_type);
}
@@ -20312,22 +20306,21 @@ static TypeTableEntry *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstruc
}
static TypeTableEntry *ir_analyze_instruction_tag_type(IrAnalyze *ira, IrInstructionTagType *instruction) {
+ Error err;
IrInstruction *target_inst = instruction->target->other;
TypeTableEntry *enum_type = ir_resolve_type(ira, target_inst);
if (type_is_invalid(enum_type))
return ira->codegen->builtin_types.entry_invalid;
if (enum_type->id == TypeTableEntryIdEnum) {
- ensure_complete_type(ira->codegen, enum_type);
- if (type_is_invalid(enum_type))
+ if ((err = ensure_complete_type(ira->codegen, enum_type)))
return ira->codegen->builtin_types.entry_invalid;
ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
out_val->data.x_type = enum_type->data.enumeration.tag_int_type;
return ira->codegen->builtin_types.entry_type;
} else if (enum_type->id == TypeTableEntryIdUnion) {
- ensure_complete_type(ira->codegen, enum_type);
- if (type_is_invalid(enum_type))
+ if ((err = ensure_complete_type(ira->codegen, enum_type)))
return ira->codegen->builtin_types.entry_invalid;
AstNode *decl_node = enum_type->data.unionation.decl_node;
@@ -20830,6 +20823,7 @@ static TypeTableEntry *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstruction
}
static TypeTableEntry *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInstructionEnumToInt *instruction) {
+ Error err;
IrInstruction *target = instruction->target->other;
if (type_is_invalid(target->value.type))
return ira->codegen->builtin_types.entry_invalid;
@@ -20840,8 +20834,7 @@ static TypeTableEntry *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInst
return ira->codegen->builtin_types.entry_invalid;
}
- type_ensure_zero_bits_known(ira->codegen, target->value.type);
- if (type_is_invalid(target->value.type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, target->value.type)))
return ira->codegen->builtin_types.entry_invalid;
TypeTableEntry *tag_type = target->value.type->data.enumeration.tag_int_type;
@@ -20852,6 +20845,7 @@ static TypeTableEntry *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInst
}
static TypeTableEntry *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInstructionIntToEnum *instruction) {
+ Error err;
IrInstruction *dest_type_value = instruction->dest_type->other;
TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
if (type_is_invalid(dest_type))
@@ -20863,8 +20857,7 @@ static TypeTableEntry *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInst
return ira->codegen->builtin_types.entry_invalid;
}
- type_ensure_zero_bits_known(ira->codegen, dest_type);
- if (type_is_invalid(dest_type))
+ if ((err = type_ensure_zero_bits_known(ira->codegen, dest_type)))
return ira->codegen->builtin_types.entry_invalid;
TypeTableEntry *tag_type = dest_type->data.enumeration.tag_int_type;
diff --git a/src/result.hpp b/src/result.hpp
new file mode 100644
index 0000000000..6c9f35c0b6
--- /dev/null
+++ b/src/result.hpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018 Andrew Kelley
+ *
+ * This file is part of zig, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#ifndef ZIG_RESULT_HPP
+#define ZIG_RESULT_HPP
+
+#include "error.hpp"
+
+#include <assert.h>
+
+static inline void assertNoError(Error err) {
+ assert(err == ErrorNone);
+}
+
+template<typename T>
+struct Result {
+ T data;
+ Error err;
+
+ Result(T x) : data(x), err(ErrorNone) {}
+
+ Result(Error err) : err(err) {
+ assert(err != ErrorNone);
+ }
+
+ T unwrap() {
+ assert(err == ErrorNone);
+ return data;
+ }
+};
+
+#endif
diff --git a/src/util.hpp b/src/util.hpp
index b0402137bd..41f8feb591 100644
--- a/src/util.hpp
+++ b/src/util.hpp
@@ -21,6 +21,7 @@
#define ATTRIBUTE_PRINTF(a, b)
#define ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
#define ATTRIBUTE_NORETURN __declspec(noreturn)
+#define ATTRIBUTE_MUST_USE
#else
@@ -28,6 +29,7 @@
#define ATTRIBUTE_PRINTF(a, b) __attribute__((format(printf, a, b)))
#define ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
#define ATTRIBUTE_NORETURN __attribute__((noreturn))
+#define ATTRIBUTE_MUST_USE __attribute__((warn_unused_result))
#endif
diff --git a/std/c/darwin.zig b/std/c/darwin.zig
index 437b081cac..2e238e40eb 100644
--- a/std/c/darwin.zig
+++ b/std/c/darwin.zig
@@ -1,5 +1,8 @@
+const macho = @import("../macho.zig");
+
extern "c" fn __error() *c_int;
pub extern "c" fn _NSGetExecutablePath(buf: [*]u8, bufsize: *u32) c_int;
+pub extern "c" fn _dyld_get_image_header(image_index: u32) ?*mach_header;
pub extern "c" fn __getdirentries64(fd: c_int, buf_ptr: [*]u8, buf_len: usize, basep: *i64) usize;
@@ -33,6 +36,15 @@ pub extern "c" fn sysctlnametomib(name: [*]const u8, mibp: ?*c_int, sizep: ?*usi
pub extern "c" fn bind(socket: c_int, address: ?*const sockaddr, address_len: socklen_t) c_int;
pub extern "c" fn socket(domain: c_int, type: c_int, protocol: c_int) c_int;
+/// The value of the link editor defined symbol _MH_EXECUTE_SYM is the address
+/// of the mach header in a Mach-O executable file type. It does not appear in
+/// any file type other than a MH_EXECUTE file type. The type of the symbol is
+/// absolute as the header is not part of any section.
+pub extern "c" var _mh_execute_header: if (@sizeOf(usize) == 8) mach_header_64 else mach_header;
+
+pub const mach_header_64 = macho.mach_header_64;
+pub const mach_header = macho.mach_header;
+
pub use @import("../os/darwin/errno.zig");
pub const _errno = __error;
diff --git a/std/c/linux.zig b/std/c/linux.zig
index 2699e9bd09..b0dadf071d 100644
--- a/std/c/linux.zig
+++ b/std/c/linux.zig
@@ -8,3 +8,6 @@ pub const pthread_attr_t = extern struct {
__size: [56]u8,
__align: c_long,
};
+
+/// See std.elf for constants for this
+pub extern fn getauxval(__type: c_ulong) c_ulong;
diff --git a/std/debug/index.zig b/std/debug/index.zig
index 3477d1b6d3..39c41d4bc1 100644
--- a/std/debug/index.zig
+++ b/std/debug/index.zig
@@ -4,8 +4,8 @@ const mem = std.mem;
const io = std.io;
const os = std.os;
const elf = std.elf;
-const DW = std.dwarf;
const macho = std.macho;
+const DW = std.dwarf;
const ArrayList = std.ArrayList;
const builtin = @import("builtin");
@@ -19,9 +19,10 @@ pub const runtime_safety = switch (builtin.mode) {
/// Tries to write to stderr, unbuffered, and ignores any error returned.
/// Does not append a newline.
-/// TODO atomic/multithread support
var stderr_file: os.File = undefined;
var stderr_file_out_stream: io.FileOutStream = undefined;
+
+/// TODO multithreaded awareness
var stderr_stream: ?*io.OutStream(io.FileOutStream.Error) = null;
var stderr_mutex = std.Mutex.init();
pub fn warn(comptime fmt: []const u8, args: ...) void {
@@ -30,6 +31,7 @@ pub fn warn(comptime fmt: []const u8, args: ...) void {
const stderr = getStderrStream() catch return;
stderr.print(fmt, args) catch return;
}
+
pub fn getStderrStream() !*io.OutStream(io.FileOutStream.Error) {
if (stderr_stream) |st| {
return st;
@@ -42,14 +44,15 @@ pub fn getStderrStream() !*io.OutStream(io.FileOutStream.Error) {
}
}
-var self_debug_info: ?*ElfStackTrace = null;
-pub fn getSelfDebugInfo() !*ElfStackTrace {
- if (self_debug_info) |info| {
+/// TODO multithreaded awareness
+var self_debug_info: ?DebugInfo = null;
+
+pub fn getSelfDebugInfo() !*DebugInfo {
+ if (self_debug_info) |*info| {
return info;
} else {
- const info = try openSelfDebugInfo(getDebugInfoAllocator());
- self_debug_info = info;
- return info;
+ self_debug_info = try openSelfDebugInfo(getDebugInfoAllocator());
+ return &self_debug_info.?;
}
}
@@ -60,6 +63,7 @@ fn wantTtyColor() bool {
}
/// Tries to print the current stack trace to stderr, unbuffered, and ignores any error returned.
+/// TODO multithreaded awareness
pub fn dumpCurrentStackTrace(start_addr: ?usize) void {
const stderr = getStderrStream() catch return;
const debug_info = getSelfDebugInfo() catch |err| {
@@ -73,6 +77,7 @@ pub fn dumpCurrentStackTrace(start_addr: ?usize) void {
}
/// Tries to print a stack trace to stderr, unbuffered, and ignores any error returned.
+/// TODO multithreaded awareness
pub fn dumpStackTrace(stack_trace: *const builtin.StackTrace) void {
const stderr = getStderrStream() catch return;
const debug_info = getSelfDebugInfo() catch |err| {
@@ -127,6 +132,7 @@ pub fn panic(comptime format: []const u8, args: ...) noreturn {
panicExtra(null, first_trace_addr, format, args);
}
+/// TODO multithreaded awareness
var panicking: u8 = 0; // TODO make this a bool
pub fn panicExtra(trace: ?*const builtin.StackTrace, first_trace_addr: ?usize, comptime format: []const u8, args: ...) noreturn {
@@ -155,7 +161,7 @@ const WHITE = "\x1b[37;1m";
const DIM = "\x1b[2m";
const RESET = "\x1b[0m";
-pub fn writeStackTrace(stack_trace: *const builtin.StackTrace, out_stream: var, allocator: *mem.Allocator, debug_info: *ElfStackTrace, tty_color: bool) !void {
+pub fn writeStackTrace(stack_trace: *const builtin.StackTrace, out_stream: var, allocator: *mem.Allocator, debug_info: *DebugInfo, tty_color: bool) !void {
var frame_index: usize = undefined;
var frames_left: usize = undefined;
if (stack_trace.index < stack_trace.instruction_addresses.len) {
@@ -185,7 +191,7 @@ pub inline fn getReturnAddress(frame_count: usize) usize {
return @intToPtr(*const usize, fp + @sizeOf(usize)).*;
}
-pub fn writeCurrentStackTrace(out_stream: var, allocator: *mem.Allocator, debug_info: *ElfStackTrace, tty_color: bool, start_addr: ?usize) !void {
+pub fn writeCurrentStackTrace(out_stream: var, allocator: *mem.Allocator, debug_info: *DebugInfo, tty_color: bool, start_addr: ?usize) !void {
const AddressState = union(enum) {
NotLookingForStartAddress,
LookingForStartAddress: usize,
@@ -218,128 +224,290 @@ pub fn writeCurrentStackTrace(out_stream: var, allocator: *mem.Allocator, debug_
}
}
-pub fn printSourceAtAddress(debug_info: *ElfStackTrace, out_stream: var, address: usize, tty_color: bool) !void {
+pub fn printSourceAtAddress(debug_info: *DebugInfo, out_stream: var, address: usize, tty_color: bool) !void {
switch (builtin.os) {
- builtin.Os.windows => return error.UnsupportedDebugInfo,
- builtin.Os.macosx => {
- // TODO(bnoordhuis) It's theoretically possible to obtain the
- // compilation unit from the symbtab but it's not that useful
- // in practice because the compiler dumps everything in a single
- // object file. Future improvement: use external dSYM data when
- // available.
- const unknown = macho.Symbol{
- .name = "???",
- .address = address,
- };
- const symbol = debug_info.symbol_table.search(address) orelse &unknown;
- try out_stream.print(WHITE ++ "{}" ++ RESET ++ ": " ++ DIM ++ "0x{x}" ++ " in ??? (???)" ++ RESET ++ "\n", symbol.name, address);
+ builtin.Os.macosx => return printSourceAtAddressMacOs(debug_info, out_stream, address, tty_color),
+ builtin.Os.linux => return printSourceAtAddressLinux(debug_info, out_stream, address, tty_color),
+ builtin.Os.windows => {
+ // TODO https://github.com/ziglang/zig/issues/721
+ return error.UnsupportedOperatingSystem;
},
- else => {
- const compile_unit = findCompileUnit(debug_info, address) catch {
- if (tty_color) {
- try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? (???)" ++ RESET ++ "\n ???\n\n", address);
- } else {
- try out_stream.print("???:?:?: 0x{x} in ??? (???)\n ???\n\n", address);
- }
- return;
- };
- const compile_unit_name = try compile_unit.die.getAttrString(debug_info, DW.AT_name);
- if (getLineNumberInfo(debug_info, compile_unit, address - 1)) |line_info| {
- defer line_info.deinit();
- if (tty_color) {
- try out_stream.print(
- WHITE ++ "{}:{}:{}" ++ RESET ++ ": " ++ DIM ++ "0x{x} in ??? ({})" ++ RESET ++ "\n",
- line_info.file_name,
- line_info.line,
- line_info.column,
- address,
- compile_unit_name,
- );
- if (printLineFromFile(out_stream, line_info)) {
- if (line_info.column == 0) {
- try out_stream.write("\n");
- } else {
- {
- var col_i: usize = 1;
- while (col_i < line_info.column) : (col_i += 1) {
- try out_stream.writeByte(' ');
- }
- }
- try out_stream.write(GREEN ++ "^" ++ RESET ++ "\n");
- }
- } else |err| switch (err) {
- error.EndOfFile => {},
- else => return err,
- }
- } else {
- try out_stream.print(
- "{}:{}:{}: 0x{x} in ??? ({})\n",
- line_info.file_name,
- line_info.line,
- line_info.column,
- address,
- compile_unit_name,
- );
- }
- } else |err| switch (err) {
- error.MissingDebugInfo, error.InvalidDebugInfo => {
- try out_stream.print("0x{x} in ??? ({})\n", address, compile_unit_name);
- },
- else => return err,
+ else => return error.UnsupportedOperatingSystem,
+ }
+}
+
+fn machoSearchSymbols(symbols: []const MachoSymbol, address: usize) ?*const MachoSymbol {
+ var min: usize = 0;
+ var max: usize = symbols.len - 1; // Exclude sentinel.
+ while (min < max) {
+ const mid = min + (max - min) / 2;
+ const curr = &symbols[mid];
+ const next = &symbols[mid + 1];
+ if (address >= next.address()) {
+ min = mid + 1;
+ } else if (address < curr.address()) {
+ max = mid;
+ } else {
+ return curr;
+ }
+ }
+ return null;
+}
+
+fn printSourceAtAddressMacOs(di: *DebugInfo, out_stream: var, address: usize, tty_color: bool) !void {
+ const base_addr = @ptrToInt(&std.c._mh_execute_header);
+ const adjusted_addr = 0x100000000 + (address - base_addr);
+
+ const symbol = machoSearchSymbols(di.symbols, adjusted_addr) orelse {
+ if (tty_color) {
+ try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? (???)" ++ RESET ++ "\n\n\n", address);
+ } else {
+ try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", address);
+ }
+ return;
+ };
+
+ const symbol_name = mem.toSliceConst(u8, di.strings.ptr + symbol.nlist.n_strx);
+ const compile_unit_name = if (symbol.ofile) |ofile| blk: {
+ const ofile_path = mem.toSliceConst(u8, di.strings.ptr + ofile.n_strx);
+ break :blk os.path.basename(ofile_path);
+ } else "???";
+ if (getLineNumberInfoMacOs(di, symbol.*, adjusted_addr)) |line_info| {
+ defer line_info.deinit();
+ try printLineInfo(di, out_stream, line_info, address, symbol_name, compile_unit_name, tty_color);
+ } else |err| switch (err) {
+ error.MissingDebugInfo, error.InvalidDebugInfo => {
+ if (tty_color) {
+ try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in {} ({})" ++ RESET ++ "\n\n\n", address, symbol_name, compile_unit_name);
+ } else {
+ try out_stream.print("???:?:?: 0x{x} in {} ({})\n\n\n", address, symbol_name, compile_unit_name);
}
},
+ else => return err,
}
}
-pub fn openSelfDebugInfo(allocator: *mem.Allocator) !*ElfStackTrace {
- switch (builtin.object_format) {
- builtin.ObjectFormat.elf => {
- const st = try allocator.create(ElfStackTrace{
- .self_exe_file = undefined,
- .elf = undefined,
- .debug_info = undefined,
- .debug_abbrev = undefined,
- .debug_str = undefined,
- .debug_line = undefined,
- .debug_ranges = null,
- .abbrev_table_list = ArrayList(AbbrevTableHeader).init(allocator),
- .compile_unit_list = ArrayList(CompileUnit).init(allocator),
- });
- errdefer allocator.destroy(st);
- st.self_exe_file = try os.openSelfExe();
- errdefer st.self_exe_file.close();
-
- try st.elf.openFile(allocator, &st.self_exe_file);
- errdefer st.elf.close();
-
- st.debug_info = (try st.elf.findSection(".debug_info")) orelse return error.MissingDebugInfo;
- st.debug_abbrev = (try st.elf.findSection(".debug_abbrev")) orelse return error.MissingDebugInfo;
- st.debug_str = (try st.elf.findSection(".debug_str")) orelse return error.MissingDebugInfo;
- st.debug_line = (try st.elf.findSection(".debug_line")) orelse return error.MissingDebugInfo;
- st.debug_ranges = (try st.elf.findSection(".debug_ranges"));
- try scanAllCompileUnits(st);
- return st;
+pub fn printSourceAtAddressLinux(debug_info: *DebugInfo, out_stream: var, address: usize, tty_color: bool) !void {
+ const compile_unit = findCompileUnit(debug_info, address) catch {
+ if (tty_color) {
+ try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? (???)" ++ RESET ++ "\n\n\n", address);
+ } else {
+ try out_stream.print("???:?:?: 0x{x} in ??? (???)\n\n\n", address);
+ }
+ return;
+ };
+ const compile_unit_name = try compile_unit.die.getAttrString(debug_info, DW.AT_name);
+ if (getLineNumberInfoLinux(debug_info, compile_unit, address - 1)) |line_info| {
+ defer line_info.deinit();
+ const symbol_name = "???";
+ try printLineInfo(debug_info, out_stream, line_info, address, symbol_name, compile_unit_name, tty_color);
+ } else |err| switch (err) {
+ error.MissingDebugInfo, error.InvalidDebugInfo => {
+ if (tty_color) {
+ try out_stream.print("???:?:?: " ++ DIM ++ "0x{x} in ??? ({})" ++ RESET ++ "\n\n\n", address, compile_unit_name);
+ } else {
+ try out_stream.print("???:?:?: 0x{x} in ??? ({})\n\n\n", address, compile_unit_name);
+ }
},
- builtin.ObjectFormat.macho => {
- var exe_file = try os.openSelfExe();
- defer exe_file.close();
+ else => return err,
+ }
+}
- const st = try allocator.create(ElfStackTrace{ .symbol_table = try macho.loadSymbols(allocator, &io.FileInStream.init(&exe_file)) });
- errdefer allocator.destroy(st);
- return st;
- },
- builtin.ObjectFormat.coff => {
- return error.TodoSupportCoffDebugInfo;
- },
- builtin.ObjectFormat.wasm => {
- return error.TodoSupportCOFFDebugInfo;
- },
- builtin.ObjectFormat.unknown => {
- return error.UnknownObjectFormat;
+fn printLineInfo(
+ debug_info: *DebugInfo,
+ out_stream: var,
+ line_info: LineInfo,
+ address: usize,
+ symbol_name: []const u8,
+ compile_unit_name: []const u8,
+ tty_color: bool,
+) !void {
+ if (tty_color) {
+ try out_stream.print(
+ WHITE ++ "{}:{}:{}" ++ RESET ++ ": " ++ DIM ++ "0x{x} in {} ({})" ++ RESET ++ "\n",
+ line_info.file_name,
+ line_info.line,
+ line_info.column,
+ address,
+ symbol_name,
+ compile_unit_name,
+ );
+ if (printLineFromFile(out_stream, line_info)) {
+ if (line_info.column == 0) {
+ try out_stream.write("\n");
+ } else {
+ {
+ var col_i: usize = 1;
+ while (col_i < line_info.column) : (col_i += 1) {
+ try out_stream.writeByte(' ');
+ }
+ }
+ try out_stream.write(GREEN ++ "^" ++ RESET ++ "\n");
+ }
+ } else |err| switch (err) {
+ error.EndOfFile => {},
+ else => return err,
+ }
+ } else {
+ try out_stream.print(
+ "{}:{}:{}: 0x{x} in {} ({})\n",
+ line_info.file_name,
+ line_info.line,
+ line_info.column,
+ address,
+ symbol_name,
+ compile_unit_name,
+ );
+ }
+}
+
+// TODO use this
+pub const OpenSelfDebugInfoError = error{
+ MissingDebugInfo,
+ OutOfMemory,
+ UnsupportedOperatingSystem,
+};
+
+pub fn openSelfDebugInfo(allocator: *mem.Allocator) !DebugInfo {
+ switch (builtin.os) {
+ builtin.Os.linux => return openSelfDebugInfoLinux(allocator),
+ builtin.Os.macosx, builtin.Os.ios => return openSelfDebugInfoMacOs(allocator),
+ builtin.Os.windows => {
+ // TODO: https://github.com/ziglang/zig/issues/721
+ return error.UnsupportedOperatingSystem;
},
+ else => return error.UnsupportedOperatingSystem,
}
}
+fn openSelfDebugInfoLinux(allocator: *mem.Allocator) !DebugInfo {
+ var di = DebugInfo{
+ .self_exe_file = undefined,
+ .elf = undefined,
+ .debug_info = undefined,
+ .debug_abbrev = undefined,
+ .debug_str = undefined,
+ .debug_line = undefined,
+ .debug_ranges = null,
+ .abbrev_table_list = ArrayList(AbbrevTableHeader).init(allocator),
+ .compile_unit_list = ArrayList(CompileUnit).init(allocator),
+ };
+ di.self_exe_file = try os.openSelfExe();
+ errdefer di.self_exe_file.close();
+
+ try di.elf.openFile(allocator, &di.self_exe_file);
+ errdefer di.elf.close();
+
+ di.debug_info = (try di.elf.findSection(".debug_info")) orelse return error.MissingDebugInfo;
+ di.debug_abbrev = (try di.elf.findSection(".debug_abbrev")) orelse return error.MissingDebugInfo;
+ di.debug_str = (try di.elf.findSection(".debug_str")) orelse return error.MissingDebugInfo;
+ di.debug_line = (try di.elf.findSection(".debug_line")) orelse return error.MissingDebugInfo;
+ di.debug_ranges = (try di.elf.findSection(".debug_ranges"));
+ try scanAllCompileUnits(&di);
+ return di;
+}
+
+pub fn findElfSection(elf: *Elf, name: []const u8) ?*elf.Shdr {
+ var file_stream = io.FileInStream.init(elf.in_file);
+ const in = &file_stream.stream;
+
+ section_loop: for (elf.section_headers) |*elf_section| {
+ if (elf_section.sh_type == SHT_NULL) continue;
+
+ const name_offset = elf.string_section.offset + elf_section.name;
+ try elf.in_file.seekTo(name_offset);
+
+ for (name) |expected_c| {
+ const target_c = try in.readByte();
+ if (target_c == 0 or expected_c != target_c) continue :section_loop;
+ }
+
+ {
+ const null_byte = try in.readByte();
+ if (null_byte == 0) return elf_section;
+ }
+ }
+
+ return null;
+}
+
+fn openSelfDebugInfoMacOs(allocator: *mem.Allocator) !DebugInfo {
+ const hdr = &std.c._mh_execute_header;
+ assert(hdr.magic == std.macho.MH_MAGIC_64);
+
+ const hdr_base = @ptrCast([*]u8, hdr);
+ var ptr = hdr_base + @sizeOf(macho.mach_header_64);
+ var ncmd: u32 = hdr.ncmds;
+ const symtab = while (ncmd != 0) : (ncmd -= 1) {
+ const lc = @ptrCast(*std.macho.load_command, ptr);
+ switch (lc.cmd) {
+ std.macho.LC_SYMTAB => break @ptrCast(*std.macho.symtab_command, ptr),
+ else => {},
+ }
+ ptr += lc.cmdsize; // TODO https://github.com/ziglang/zig/issues/1403
+ } else {
+ return error.MissingDebugInfo;
+ };
+ const syms = @ptrCast([*]macho.nlist_64, hdr_base + symtab.symoff)[0..symtab.nsyms];
+ const strings = @ptrCast([*]u8, hdr_base + symtab.stroff)[0..symtab.strsize];
+
+ const symbols_buf = try allocator.alloc(MachoSymbol, syms.len);
+
+ var ofile: ?*macho.nlist_64 = null;
+ var reloc: u64 = 0;
+ var symbol_index: usize = 0;
+ var last_len: u64 = 0;
+ for (syms) |*sym| {
+ if (sym.n_type & std.macho.N_STAB != 0) {
+ switch (sym.n_type) {
+ std.macho.N_OSO => {
+ ofile = sym;
+ reloc = 0;
+ },
+ std.macho.N_FUN => {
+ if (sym.n_sect == 0) {
+ last_len = sym.n_value;
+ } else {
+ symbols_buf[symbol_index] = MachoSymbol{
+ .nlist = sym,
+ .ofile = ofile,
+ .reloc = reloc,
+ };
+ symbol_index += 1;
+ }
+ },
+ std.macho.N_BNSYM => {
+ if (reloc == 0) {
+ reloc = sym.n_value;
+ }
+ },
+ else => continue,
+ }
+ }
+ }
+ const sentinel = try allocator.createOne(macho.nlist_64);
+ sentinel.* = macho.nlist_64{
+ .n_strx = 0,
+ .n_type = 36,
+ .n_sect = 0,
+ .n_desc = 0,
+ .n_value = symbols_buf[symbol_index - 1].nlist.n_value + last_len,
+ };
+
+ const symbols = allocator.shrink(MachoSymbol, symbols_buf, symbol_index);
+
+ // Even though lld emits symbols in ascending order, this debug code
+ // should work for programs linked in any valid way.
+ // This sort is so that we can binary search later.
+ std.sort.sort(MachoSymbol, symbols, MachoSymbol.addressLessThan);
+
+ return DebugInfo{
+ .ofiles = DebugInfo.OFileTable.init(allocator),
+ .symbols = symbols,
+ .strings = strings,
+ };
+}
+
fn printLineFromFile(out_stream: var, line_info: *const LineInfo) !void {
var f = try os.File.openRead(line_info.file_name);
defer f.close();
@@ -372,12 +540,42 @@ fn printLineFromFile(out_stream: var, line_info: *const LineInfo) !void {
}
}
-pub const ElfStackTrace = switch (builtin.os) {
- builtin.Os.macosx => struct {
- symbol_table: macho.SymbolTable,
+const MachoSymbol = struct {
+ nlist: *macho.nlist_64,
+ ofile: ?*macho.nlist_64,
+ reloc: u64,
+
+ /// Returns the address from the macho file
+ fn address(self: MachoSymbol) u64 {
+ return self.nlist.n_value;
+ }
+
+ fn addressLessThan(lhs: MachoSymbol, rhs: MachoSymbol) bool {
+ return lhs.address() < rhs.address();
+ }
+};
+
+const MachOFile = struct {
+ bytes: []align(@alignOf(macho.mach_header_64)) const u8,
+ sect_debug_info: ?*const macho.section_64,
+ sect_debug_line: ?*const macho.section_64,
+};
- pub fn close(self: *ElfStackTrace) void {
- self.symbol_table.deinit();
+pub const DebugInfo = switch (builtin.os) {
+ builtin.Os.macosx => struct {
+ symbols: []const MachoSymbol,
+ strings: []const u8,
+ ofiles: OFileTable,
+
+ const OFileTable = std.HashMap(
+ *macho.nlist_64,
+ MachOFile,
+ std.hash_map.getHashPtrAddrFn(*macho.nlist_64),
+ std.hash_map.getTrivialEqlFn(*macho.nlist_64),
+ );
+
+ pub fn allocator(self: DebugInfo) *mem.Allocator {
+ return self.ofiles.allocator;
}
},
else => struct {
@@ -391,17 +589,17 @@ pub const ElfStackTrace = switch (builtin.os) {
abbrev_table_list: ArrayList(AbbrevTableHeader),
compile_unit_list: ArrayList(CompileUnit),
- pub fn allocator(self: *const ElfStackTrace) *mem.Allocator {
+ pub fn allocator(self: DebugInfo) *mem.Allocator {
return self.abbrev_table_list.allocator;
}
- pub fn readString(self: *ElfStackTrace) ![]u8 {
+ pub fn readString(self: *DebugInfo) ![]u8 {
var in_file_stream = io.FileInStream.init(&self.self_exe_file);
const in_stream = &in_file_stream.stream;
return readStringRaw(self.allocator(), in_stream);
}
- pub fn close(self: *ElfStackTrace) void {
+ pub fn close(self: *DebugInfo) void {
self.self_exe_file.close();
self.elf.close();
}
@@ -508,7 +706,7 @@ const Die = struct {
};
}
- fn getAttrString(self: *const Die, st: *ElfStackTrace, id: u64) ![]u8 {
+ fn getAttrString(self: *const Die, st: *DebugInfo, id: u64) ![]u8 {
const form_value = self.getAttr(id) orelse return error.MissingDebugInfo;
return switch (form_value.*) {
FormValue.String => |value| value,
@@ -623,7 +821,7 @@ fn readStringRaw(allocator: *mem.Allocator, in_stream: var) ![]u8 {
return buf.toSlice();
}
-fn getString(st: *ElfStackTrace, offset: u64) ![]u8 {
+fn getString(st: *DebugInfo, offset: u64) ![]u8 {
const pos = st.debug_str.offset + offset;
try st.self_exe_file.seekTo(pos);
return st.readString();
@@ -730,7 +928,7 @@ fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, is_64
};
}
-fn parseAbbrevTable(st: *ElfStackTrace) !AbbrevTable {
+fn parseAbbrevTable(st: *DebugInfo) !AbbrevTable {
const in_file = &st.self_exe_file;
var in_file_stream = io.FileInStream.init(in_file);
const in_stream = &in_file_stream.stream;
@@ -760,7 +958,7 @@ fn parseAbbrevTable(st: *ElfStackTrace) !AbbrevTable {
/// Gets an already existing AbbrevTable given the abbrev_offset, or if not found,
/// seeks in the stream and parses it.
-fn getAbbrevTable(st: *ElfStackTrace, abbrev_offset: u64) !*const AbbrevTable {
+fn getAbbrevTable(st: *DebugInfo, abbrev_offset: u64) !*const AbbrevTable {
for (st.abbrev_table_list.toSlice()) |*header| {
if (header.offset == abbrev_offset) {
return &header.table;
@@ -781,7 +979,7 @@ fn getAbbrevTableEntry(abbrev_table: *const AbbrevTable, abbrev_code: u64) ?*con
return null;
}
-fn parseDie(st: *ElfStackTrace, abbrev_table: *const AbbrevTable, is_64: bool) !Die {
+fn parseDie(st: *DebugInfo, abbrev_table: *const AbbrevTable, is_64: bool) !Die {
const in_file = &st.self_exe_file;
var in_file_stream = io.FileInStream.init(in_file);
const in_stream = &in_file_stream.stream;
@@ -803,12 +1001,210 @@ fn parseDie(st: *ElfStackTrace, abbrev_table: *const AbbrevTable, is_64: bool) !
return result;
}
-fn getLineNumberInfo(st: *ElfStackTrace, compile_unit: *const CompileUnit, target_address: usize) !LineInfo {
- const compile_unit_cwd = try compile_unit.die.getAttrString(st, DW.AT_comp_dir);
+fn getLineNumberInfoMacOs(di: *DebugInfo, symbol: MachoSymbol, target_address: usize) !LineInfo {
+ const ofile = symbol.ofile orelse return error.MissingDebugInfo;
+ const gop = try di.ofiles.getOrPut(ofile);
+ const mach_o_file = if (gop.found_existing) &gop.kv.value else blk: {
+ errdefer _ = di.ofiles.remove(ofile);
+ const ofile_path = mem.toSliceConst(u8, di.strings.ptr + ofile.n_strx);
+
+ gop.kv.value = MachOFile{
+ .bytes = try std.io.readFileAllocAligned(di.ofiles.allocator, ofile_path, @alignOf(macho.mach_header_64)),
+ .sect_debug_info = null,
+ .sect_debug_line = null,
+ };
+ const hdr = @ptrCast(*const macho.mach_header_64, gop.kv.value.bytes.ptr);
+ if (hdr.magic != std.macho.MH_MAGIC_64) return error.InvalidDebugInfo;
+
+ const hdr_base = @ptrCast([*]const u8, hdr);
+ var ptr = hdr_base + @sizeOf(macho.mach_header_64);
+ var ncmd: u32 = hdr.ncmds;
+ const segcmd = while (ncmd != 0) : (ncmd -= 1) {
+ const lc = @ptrCast(*const std.macho.load_command, ptr);
+ switch (lc.cmd) {
+ std.macho.LC_SEGMENT_64 => break @ptrCast(*const std.macho.segment_command_64, ptr),
+ else => {},
+ }
+ ptr += lc.cmdsize; // TODO https://github.com/ziglang/zig/issues/1403
+ } else {
+ return error.MissingDebugInfo;
+ };
+ const sections = @alignCast(@alignOf(macho.section_64), @ptrCast([*]const macho.section_64, ptr + @sizeOf(std.macho.segment_command_64)))[0..segcmd.nsects];
+ for (sections) |*sect| {
+ if (sect.flags & macho.SECTION_TYPE == macho.S_REGULAR and
+ (sect.flags & macho.SECTION_ATTRIBUTES) & macho.S_ATTR_DEBUG == macho.S_ATTR_DEBUG)
+ {
+ const sect_name = mem.toSliceConst(u8, &sect.sectname);
+ if (mem.eql(u8, sect_name, "__debug_line")) {
+ gop.kv.value.sect_debug_line = sect;
+ } else if (mem.eql(u8, sect_name, "__debug_info")) {
+ gop.kv.value.sect_debug_info = sect;
+ }
+ }
+ }
- const in_file = &st.self_exe_file;
- const debug_line_end = st.debug_line.offset + st.debug_line.size;
- var this_offset = st.debug_line.offset;
+ break :blk &gop.kv.value;
+ };
+
+ const sect_debug_line = mach_o_file.sect_debug_line orelse return error.MissingDebugInfo;
+ var ptr = mach_o_file.bytes.ptr + sect_debug_line.offset;
+
+ var is_64: bool = undefined;
+ const unit_length = try readInitialLengthMem(&ptr, &is_64);
+ if (unit_length == 0) return error.MissingDebugInfo;
+
+ const version = readIntMem(&ptr, u16, builtin.Endian.Little);
+ // TODO support 3 and 5
+ if (version != 2 and version != 4) return error.InvalidDebugInfo;
+
+ const prologue_length = if (is_64)
+ readIntMem(&ptr, u64, builtin.Endian.Little)
+ else
+ readIntMem(&ptr, u32, builtin.Endian.Little);
+ const prog_start = ptr + prologue_length;
+
+ const minimum_instruction_length = readByteMem(&ptr);
+ if (minimum_instruction_length == 0) return error.InvalidDebugInfo;
+
+ if (version >= 4) {
+ // maximum_operations_per_instruction
+ ptr += 1;
+ }
+
+ const default_is_stmt = readByteMem(&ptr) != 0;
+ const line_base = readByteSignedMem(&ptr);
+
+ const line_range = readByteMem(&ptr);
+ if (line_range == 0) return error.InvalidDebugInfo;
+
+ const opcode_base = readByteMem(&ptr);
+
+ const standard_opcode_lengths = ptr[0 .. opcode_base - 1];
+ ptr += opcode_base - 1;
+
+ var include_directories = ArrayList([]const u8).init(di.allocator());
+ try include_directories.append("");
+ while (true) {
+ const dir = readStringMem(&ptr);
+ if (dir.len == 0) break;
+ try include_directories.append(dir);
+ }
+
+ var file_entries = ArrayList(FileEntry).init(di.allocator());
+ var prog = LineNumberProgram.init(default_is_stmt, include_directories.toSliceConst(), &file_entries, target_address);
+
+ while (true) {
+ const file_name = readStringMem(&ptr);
+ if (file_name.len == 0) break;
+ const dir_index = try readULeb128Mem(&ptr);
+ const mtime = try readULeb128Mem(&ptr);
+ const len_bytes = try readULeb128Mem(&ptr);
+ try file_entries.append(FileEntry{
+ .file_name = file_name,
+ .dir_index = dir_index,
+ .mtime = mtime,
+ .len_bytes = len_bytes,
+ });
+ }
+
+ ptr = prog_start;
+ while (true) {
+ const opcode = readByteMem(&ptr);
+
+ if (opcode == DW.LNS_extended_op) {
+ const op_size = try readULeb128Mem(&ptr);
+ if (op_size < 1) return error.InvalidDebugInfo;
+ var sub_op = readByteMem(&ptr);
+ switch (sub_op) {
+ DW.LNE_end_sequence => {
+ prog.end_sequence = true;
+ if (try prog.checkLineMatch()) |info| return info;
+ return error.MissingDebugInfo;
+ },
+ DW.LNE_set_address => {
+ const addr = readIntMem(&ptr, usize, builtin.Endian.Little);
+ prog.address = symbol.reloc + addr;
+ },
+ DW.LNE_define_file => {
+ const file_name = readStringMem(&ptr);
+ const dir_index = try readULeb128Mem(&ptr);
+ const mtime = try readULeb128Mem(&ptr);
+ const len_bytes = try readULeb128Mem(&ptr);
+ try file_entries.append(FileEntry{
+ .file_name = file_name,
+ .dir_index = dir_index,
+ .mtime = mtime,
+ .len_bytes = len_bytes,
+ });
+ },
+ else => {
+ ptr += op_size - 1;
+ },
+ }
+ } else if (opcode >= opcode_base) {
+ // special opcodes
+ const adjusted_opcode = opcode - opcode_base;
+ const inc_addr = minimum_instruction_length * (adjusted_opcode / line_range);
+ const inc_line = i32(line_base) + i32(adjusted_opcode % line_range);
+ prog.line += inc_line;
+ prog.address += inc_addr;
+ if (try prog.checkLineMatch()) |info| return info;
+ prog.basic_block = false;
+ } else {
+ switch (opcode) {
+ DW.LNS_copy => {
+ if (try prog.checkLineMatch()) |info| return info;
+ prog.basic_block = false;
+ },
+ DW.LNS_advance_pc => {
+ const arg = try readULeb128Mem(&ptr);
+ prog.address += arg * minimum_instruction_length;
+ },
+ DW.LNS_advance_line => {
+ const arg = try readILeb128Mem(&ptr);
+ prog.line += arg;
+ },
+ DW.LNS_set_file => {
+ const arg = try readULeb128Mem(&ptr);
+ prog.file = arg;
+ },
+ DW.LNS_set_column => {
+ const arg = try readULeb128Mem(&ptr);
+ prog.column = arg;
+ },
+ DW.LNS_negate_stmt => {
+ prog.is_stmt = !prog.is_stmt;
+ },
+ DW.LNS_set_basic_block => {
+ prog.basic_block = true;
+ },
+ DW.LNS_const_add_pc => {
+ const inc_addr = minimum_instruction_length * ((255 - opcode_base) / line_range);
+ prog.address += inc_addr;
+ },
+ DW.LNS_fixed_advance_pc => {
+ const arg = readIntMem(&ptr, u16, builtin.Endian.Little);
+ prog.address += arg;
+ },
+ DW.LNS_set_prologue_end => {},
+ else => {
+ if (opcode - 1 >= standard_opcode_lengths.len) return error.InvalidDebugInfo;
+ const len_bytes = standard_opcode_lengths[opcode - 1];
+ ptr += len_bytes;
+ },
+ }
+ }
+ }
+
+ return error.MissingDebugInfo;
+}
+
+fn getLineNumberInfoLinux(di: *DebugInfo, compile_unit: *const CompileUnit, target_address: usize) !LineInfo {
+ const compile_unit_cwd = try compile_unit.die.getAttrString(di, DW.AT_comp_dir);
+
+ const in_file = &di.self_exe_file;
+ const debug_line_end = di.debug_line.offset + di.debug_line.size;
+ var this_offset = di.debug_line.offset;
var this_index: usize = 0;
var in_file_stream = io.FileInStream.init(in_file);
@@ -827,11 +1223,11 @@ fn getLineNumberInfo(st: *ElfStackTrace, compile_unit: *const CompileUnit, targe
continue;
}
- const version = try in_stream.readInt(st.elf.endian, u16);
+ const version = try in_stream.readInt(di.elf.endian, u16);
// TODO support 3 and 5
if (version != 2 and version != 4) return error.InvalidDebugInfo;
- const prologue_length = if (is_64) try in_stream.readInt(st.elf.endian, u64) else try in_stream.readInt(st.elf.endian, u32);
+ const prologue_length = if (is_64) try in_stream.readInt(di.elf.endian, u64) else try in_stream.readInt(di.elf.endian, u32);
const prog_start_offset = (try in_file.getPos()) + prologue_length;
const minimum_instruction_length = try in_stream.readByte();
@@ -850,7 +1246,7 @@ fn getLineNumberInfo(st: *ElfStackTrace, compile_unit: *const CompileUnit, targe
const opcode_base = try in_stream.readByte();
- const standard_opcode_lengths = try st.allocator().alloc(u8, opcode_base - 1);
+ const standard_opcode_lengths = try di.allocator().alloc(u8, opcode_base - 1);
{
var i: usize = 0;
@@ -859,19 +1255,19 @@ fn getLineNumberInfo(st: *ElfStackTrace, compile_unit: *const CompileUnit, targe
}
}
- var include_directories = ArrayList([]u8).init(st.allocator());
+ var include_directories = ArrayList([]u8).init(di.allocator());
try include_directories.append(compile_unit_cwd);
while (true) {
- const dir = try st.readString();
+ const dir = try di.readString();
if (dir.len == 0) break;
try include_directories.append(dir);
}
- var file_entries = ArrayList(FileEntry).init(st.allocator());
+ var file_entries = ArrayList(FileEntry).init(di.allocator());
var prog = LineNumberProgram.init(default_is_stmt, include_directories.toSliceConst(), &file_entries, target_address);
while (true) {
- const file_name = try st.readString();
+ const file_name = try di.readString();
if (file_name.len == 0) break;
const dir_index = try readULeb128(in_stream);
const mtime = try readULeb128(in_stream);
@@ -900,11 +1296,11 @@ fn getLineNumberInfo(st: *ElfStackTrace, compile_unit: *const CompileUnit, targe
return error.MissingDebugInfo;
},
DW.LNE_set_address => {
- const addr = try in_stream.readInt(st.elf.endian, usize);
+ const addr = try in_stream.readInt(di.elf.endian, usize);
prog.address = addr;
},
DW.LNE_define_file => {
- const file_name = try st.readString();
+ const file_name = try di.readString();
const dir_index = try readULeb128(in_stream);
const mtime = try readULeb128(in_stream);
const len_bytes = try readULeb128(in_stream);
@@ -962,7 +1358,7 @@ fn getLineNumberInfo(st: *ElfStackTrace, compile_unit: *const CompileUnit, targe
prog.address += inc_addr;
},
DW.LNS_fixed_advance_pc => {
- const arg = try in_stream.readInt(st.elf.endian, u16);
+ const arg = try in_stream.readInt(di.elf.endian, u16);
prog.address += arg;
},
DW.LNS_set_prologue_end => {},
@@ -981,7 +1377,7 @@ fn getLineNumberInfo(st: *ElfStackTrace, compile_unit: *const CompileUnit, targe
return error.MissingDebugInfo;
}
-fn scanAllCompileUnits(st: *ElfStackTrace) !void {
+fn scanAllCompileUnits(st: *DebugInfo) !void {
const debug_info_end = st.debug_info.offset + st.debug_info.size;
var this_unit_offset = st.debug_info.offset;
var cu_index: usize = 0;
@@ -1051,7 +1447,7 @@ fn scanAllCompileUnits(st: *ElfStackTrace) !void {
}
}
-fn findCompileUnit(st: *ElfStackTrace, target_address: u64) !*const CompileUnit {
+fn findCompileUnit(st: *DebugInfo, target_address: u64) !*const CompileUnit {
var in_file_stream = io.FileInStream.init(&st.self_exe_file);
const in_stream = &in_file_stream.stream;
for (st.compile_unit_list.toSlice()) |*compile_unit| {
@@ -1085,6 +1481,89 @@ fn findCompileUnit(st: *ElfStackTrace, target_address: u64) !*const CompileUnit
return error.MissingDebugInfo;
}
+fn readIntMem(ptr: *[*]const u8, comptime T: type, endian: builtin.Endian) T {
+ const result = mem.readInt(ptr.*[0..@sizeOf(T)], T, endian);
+ ptr.* += @sizeOf(T);
+ return result;
+}
+
+fn readByteMem(ptr: *[*]const u8) u8 {
+ const result = ptr.*[0];
+ ptr.* += 1;
+ return result;
+}
+
+fn readByteSignedMem(ptr: *[*]const u8) i8 {
+ return @bitCast(i8, readByteMem(ptr));
+}
+
+fn readInitialLengthMem(ptr: *[*]const u8, is_64: *bool) !u64 {
+ const first_32_bits = mem.readIntLE(u32, ptr.*[0..4]);
+ is_64.* = (first_32_bits == 0xffffffff);
+ if (is_64.*) {
+ ptr.* += 4;
+ const result = mem.readIntLE(u64, ptr.*[0..8]);
+ ptr.* += 8;
+ return result;
+ } else {
+ if (first_32_bits >= 0xfffffff0) return error.InvalidDebugInfo;
+ ptr.* += 4;
+ return u64(first_32_bits);
+ }
+}
+
+fn readStringMem(ptr: *[*]const u8) []const u8 {
+ const result = mem.toSliceConst(u8, ptr.*);
+ ptr.* += result.len + 1;
+ return result;
+}
+
+fn readULeb128Mem(ptr: *[*]const u8) !u64 {
+ var result: u64 = 0;
+ var shift: usize = 0;
+ var i: usize = 0;
+
+ while (true) {
+ const byte = ptr.*[i];
+ i += 1;
+
+ var operand: u64 = undefined;
+
+ if (@shlWithOverflow(u64, byte & 0b01111111, @intCast(u6, shift), &operand)) return error.InvalidDebugInfo;
+
+ result |= operand;
+
+ if ((byte & 0b10000000) == 0) {
+ ptr.* += i;
+ return result;
+ }
+
+ shift += 7;
+ }
+}
+fn readILeb128Mem(ptr: *[*]const u8) !i64 {
+ var result: i64 = 0;
+ var shift: usize = 0;
+ var i: usize = 0;
+
+ while (true) {
+ const byte = ptr.*[i];
+ i += 1;
+
+ var operand: i64 = undefined;
+ if (@shlWithOverflow(i64, byte & 0b01111111, @intCast(u6, shift), &operand)) return error.InvalidDebugInfo;
+
+ result |= operand;
+ shift += 7;
+
+ if ((byte & 0b10000000) == 0) {
+ if (shift < @sizeOf(i64) * 8 and (byte & 0b01000000) != 0) result |= -(i64(1) << @intCast(u6, shift));
+ ptr.* += i;
+ return result;
+ }
+ }
+}
+
fn readInitialLength(comptime E: type, in_stream: *io.InStream(E), is_64: *bool) !u64 {
const first_32_bits = try in_stream.readIntLe(u32);
is_64.* = (first_32_bits == 0xffffffff);
@@ -1141,7 +1620,7 @@ pub const global_allocator = &global_fixed_allocator.allocator;
var global_fixed_allocator = std.heap.ThreadSafeFixedBufferAllocator.init(global_allocator_mem[0..]);
var global_allocator_mem: [100 * 1024]u8 = undefined;
-// TODO make thread safe
+/// TODO multithreaded awareness
var debug_info_allocator: ?*mem.Allocator = null;
var debug_info_direct_allocator: std.heap.DirectAllocator = undefined;
var debug_info_arena_allocator: std.heap.ArenaAllocator = undefined;
diff --git a/std/elf.zig b/std/elf.zig
index 8e6445c631..3d81555319 100644
--- a/std/elf.zig
+++ b/std/elf.zig
@@ -869,6 +869,11 @@ pub const Phdr = switch (@sizeOf(usize)) {
8 => Elf64_Phdr,
else => @compileError("expected pointer size of 32 or 64"),
};
+pub const Shdr = switch (@sizeOf(usize)) {
+ 4 => Elf32_Shdr,
+ 8 => Elf64_Shdr,
+ else => @compileError("expected pointer size of 32 or 64"),
+};
pub const Sym = switch (@sizeOf(usize)) {
4 => Elf32_Sym,
8 => Elf64_Sym,
diff --git a/std/hash_map.zig b/std/hash_map.zig
index 0c100e15d9..9654d612a5 100644
--- a/std/hash_map.zig
+++ b/std/hash_map.zig
@@ -408,6 +408,22 @@ test "iterator hash map" {
assert(entry.value == values[0]);
}
+pub fn getHashPtrAddrFn(comptime K: type) (fn (K) u32) {
+ return struct {
+ fn hash(key: K) u32 {
+ return getAutoHashFn(usize)(@ptrToInt(key));
+ }
+ }.hash;
+}
+
+pub fn getTrivialEqlFn(comptime K: type) (fn (K, K) bool) {
+ return struct {
+ fn eql(a: K, b: K) bool {
+ return a == b;
+ }
+ }.eql;
+}
+
pub fn getAutoHashFn(comptime K: type) (fn (K) u32) {
return struct {
fn hash(key: K) u32 {
diff --git a/std/index.zig b/std/index.zig
index 59f54fa9d7..8dfc59b1d2 100644
--- a/std/index.zig
+++ b/std/index.zig
@@ -24,6 +24,7 @@ pub const empty_import = @import("empty.zig");
pub const event = @import("event.zig");
pub const fmt = @import("fmt/index.zig");
pub const hash = @import("hash/index.zig");
+pub const hash_map = @import("hash_map.zig");
pub const heap = @import("heap.zig");
pub const io = @import("io.zig");
pub const json = @import("json.zig");
diff --git a/std/io.zig b/std/io.zig
index c7154065cb..369f6eede3 100644
--- a/std/io.zig
+++ b/std/io.zig
@@ -207,6 +207,12 @@ pub fn InStream(comptime ReadError: type) type {
_ = try self.readByte();
}
}
+
+ pub fn readStruct(self: *Self, comptime T: type, ptr: *T) !void {
+ // Only extern and packed structs have defined in-memory layout.
+ assert(@typeInfo(T).Struct.layout != builtin.TypeInfo.ContainerLayout.Auto);
+ return self.readNoEof(@sliceToBytes((*[1]T)(ptr)[0..]));
+ }
};
}
diff --git a/std/macho.zig b/std/macho.zig
index ddc4d334e4..4325810b03 100644
--- a/std/macho.zig
+++ b/std/macho.zig
@@ -1,16 +1,18 @@
-const builtin = @import("builtin");
-const std = @import("index.zig");
-const io = std.io;
-const mem = std.mem;
-const MH_MAGIC_64 = 0xFEEDFACF;
-const MH_PIE = 0x200000;
-const LC_SYMTAB = 2;
+pub const mach_header = extern struct {
+ magic: u32,
+ cputype: cpu_type_t,
+ cpusubtype: cpu_subtype_t,
+ filetype: u32,
+ ncmds: u32,
+ sizeofcmds: u32,
+ flags: u32,
+};
-const MachHeader64 = packed struct {
+pub const mach_header_64 = extern struct {
magic: u32,
- cputype: u32,
- cpusubtype: u32,
+ cputype: cpu_type_t,
+ cpusubtype: cpu_subtype_t,
filetype: u32,
ncmds: u32,
sizeofcmds: u32,
@@ -18,19 +20,138 @@ const MachHeader64 = packed struct {
reserved: u32,
};
-const LoadCommand = packed struct {
+pub const load_command = extern struct {
cmd: u32,
cmdsize: u32,
};
-const SymtabCommand = packed struct {
- symoff: u32,
- nsyms: u32,
- stroff: u32,
- strsize: u32,
+
+/// The symtab_command contains the offsets and sizes of the link-edit 4.3BSD
+/// "stab" style symbol table information as described in the header files
+/// <nlist.h> and <stab.h>.
+pub const symtab_command = extern struct {
+ cmd: u32, /// LC_SYMTAB
+ cmdsize: u32, /// sizeof(struct symtab_command)
+ symoff: u32, /// symbol table offset
+ nsyms: u32, /// number of symbol table entries
+ stroff: u32, /// string table offset
+ strsize: u32, /// string table size in bytes
+};
+
+/// The linkedit_data_command contains the offsets and sizes of a blob
+/// of data in the __LINKEDIT segment.
+const linkedit_data_command = extern struct {
+ cmd: u32,/// LC_CODE_SIGNATURE, LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE, LC_DYLIB_CODE_SIGN_DRS or LC_LINKER_OPTIMIZATION_HINT.
+ cmdsize: u32, /// sizeof(struct linkedit_data_command)
+ dataoff: u32 , /// file offset of data in __LINKEDIT segment
+ datasize: u32 , /// file size of data in __LINKEDIT segment
+};
+
+/// The segment load command indicates that a part of this file is to be
+/// mapped into the task's address space. The size of this segment in memory,
+/// vmsize, maybe equal to or larger than the amount to map from this file,
+/// filesize. The file is mapped starting at fileoff to the beginning of
+/// the segment in memory, vmaddr. The rest of the memory of the segment,
+/// if any, is allocated zero fill on demand. The segment's maximum virtual
+/// memory protection and initial virtual memory protection are specified
+/// by the maxprot and initprot fields. If the segment has sections then the
+/// section structures directly follow the segment command and their size is
+/// reflected in cmdsize.
+pub const segment_command = extern struct {
+ cmd: u32,/// LC_SEGMENT
+ cmdsize: u32,/// includes sizeof section structs
+ segname: [16]u8,/// segment name
+ vmaddr: u32,/// memory address of this segment
+ vmsize: u32,/// memory size of this segment
+ fileoff: u32,/// file offset of this segment
+ filesize: u32,/// amount to map from the file
+ maxprot: vm_prot_t,/// maximum VM protection
+ initprot: vm_prot_t,/// initial VM protection
+ nsects: u32,/// number of sections in segment
+ flags: u32,
+};
+
+/// The 64-bit segment load command indicates that a part of this file is to be
+/// mapped into a 64-bit task's address space. If the 64-bit segment has
+/// sections then section_64 structures directly follow the 64-bit segment
+/// command and their size is reflected in cmdsize.
+pub const segment_command_64 = extern struct {
+ cmd: u32, /// LC_SEGMENT_64
+ cmdsize: u32, /// includes sizeof section_64 structs
+ segname: [16]u8, /// segment name
+ vmaddr: u64, /// memory address of this segment
+ vmsize: u64, /// memory size of this segment
+ fileoff: u64, /// file offset of this segment
+ filesize: u64, /// amount to map from the file
+ maxprot: vm_prot_t, /// maximum VM protection
+ initprot: vm_prot_t, /// initial VM protection
+ nsects: u32, /// number of sections in segment
+ flags: u32,
+};
+
+/// A segment is made up of zero or more sections. Non-MH_OBJECT files have
+/// all of their segments with the proper sections in each, and padded to the
+/// specified segment alignment when produced by the link editor. The first
+/// segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header
+/// and load commands of the object file before its first section. The zero
+/// fill sections are always last in their segment (in all formats). This
+/// allows the zeroed segment padding to be mapped into memory where zero fill
+/// sections might be. The gigabyte zero fill sections, those with the section
+/// type S_GB_ZEROFILL, can only be in a segment with sections of this type.
+/// These segments are then placed after all other segments.
+///
+/// The MH_OBJECT format has all of its sections in one segment for
+/// compactness. There is no padding to a specified segment boundary and the
+/// mach_header and load commands are not part of the segment.
+///
+/// Sections with the same section name, sectname, going into the same segment,
+/// segname, are combined by the link editor. The resulting section is aligned
+/// to the maximum alignment of the combined sections and is the new section's
+/// alignment. The combined sections are aligned to their original alignment in
+/// the combined section. Any padded bytes to get the specified alignment are
+/// zeroed.
+///
+/// The format of the relocation entries referenced by the reloff and nreloc
+/// fields of the section structure for mach object files is described in the
+/// header file <reloc.h>.
+pub const @"section" = extern struct {
+ sectname: [16]u8, /// name of this section
+ segname: [16]u8, /// segment this section goes in
+ addr: u32, /// memory address of this section
+ size: u32, /// size in bytes of this section
+ offset: u32, /// file offset of this section
+ @"align": u32, /// section alignment (power of 2)
+ reloff: u32, /// file offset of relocation entries
+ nreloc: u32, /// number of relocation entries
+ flags: u32, /// flags (section type and attributes
+ reserved1: u32, /// reserved (for offset or index)
+ reserved2: u32, /// reserved (for count or sizeof)
+};
+
+pub const section_64 = extern struct {
+ sectname: [16]u8, /// name of this section
+ segname: [16]u8, /// segment this section goes in
+ addr: u64, /// memory address of this section
+ size: u64, /// size in bytes of this section
+ offset: u32, /// file offset of this section
+ @"align": u32, /// section alignment (power of 2)
+ reloff: u32, /// file offset of relocation entries
+ nreloc: u32, /// number of relocation entries
+ flags: u32, /// flags (section type and attributes
+ reserved1: u32, /// reserved (for offset or index)
+ reserved2: u32, /// reserved (for count or sizeof)
+ reserved3: u32, /// reserved
+};
+
+pub const nlist = extern struct {
+ n_strx: u32,
+ n_type: u8,
+ n_sect: u8,
+ n_desc: i16,
+ n_value: u32,
};
-const Nlist64 = packed struct {
+pub const nlist_64 = extern struct {
n_strx: u32,
n_type: u8,
n_sect: u8,
@@ -38,135 +159,190 @@ const Nlist64 = packed struct {
n_value: u64,
};
-pub const Symbol = struct {
- name: []const u8,
- address: u64,
+/// After MacOS X 10.1 when a new load command is added that is required to be
+/// understood by the dynamic linker for the image to execute properly the
+/// LC_REQ_DYLD bit will be or'ed into the load command constant. If the dynamic
+/// linker sees such a load command it it does not understand will issue a
+/// "unknown load command required for execution" error and refuse to use the
+/// image. Other load commands without this bit that are not understood will
+/// simply be ignored.
+pub const LC_REQ_DYLD = 0x80000000;
- fn addressLessThan(lhs: Symbol, rhs: Symbol) bool {
- return lhs.address < rhs.address;
- }
-};
+pub const LC_SEGMENT = 0x1; /// segment of this file to be mapped
+pub const LC_SYMTAB = 0x2; /// link-edit stab symbol table info
+pub const LC_SYMSEG = 0x3; /// link-edit gdb symbol table info (obsolete)
+pub const LC_THREAD = 0x4; /// thread
+pub const LC_UNIXTHREAD = 0x5; /// unix thread (includes a stack)
+pub const LC_LOADFVMLIB = 0x6; /// load a specified fixed VM shared library
+pub const LC_IDFVMLIB = 0x7; /// fixed VM shared library identification
+pub const LC_IDENT = 0x8; /// object identification info (obsolete)
+pub const LC_FVMFILE = 0x9; /// fixed VM file inclusion (internal use)
+pub const LC_PREPAGE = 0xa; /// prepage command (internal use)
+pub const LC_DYSYMTAB = 0xb; /// dynamic link-edit symbol table info
+pub const LC_LOAD_DYLIB = 0xc; /// load a dynamically linked shared library
+pub const LC_ID_DYLIB = 0xd; /// dynamically linked shared lib ident
+pub const LC_LOAD_DYLINKER = 0xe; /// load a dynamic linker
+pub const LC_ID_DYLINKER = 0xf; /// dynamic linker identification
+pub const LC_PREBOUND_DYLIB = 0x10; /// modules prebound for a dynamically
+pub const LC_ROUTINES = 0x11; /// image routines
+pub const LC_SUB_FRAMEWORK = 0x12; /// sub framework
+pub const LC_SUB_UMBRELLA = 0x13; /// sub umbrella
+pub const LC_SUB_CLIENT = 0x14; /// sub client
+pub const LC_SUB_LIBRARY = 0x15; /// sub library
+pub const LC_TWOLEVEL_HINTS = 0x16; /// two-level namespace lookup hints
+pub const LC_PREBIND_CKSUM = 0x17; /// prebind checksum
-pub const SymbolTable = struct {
- allocator: *mem.Allocator,
- symbols: []const Symbol,
- strings: []const u8,
-
- // Doubles as an eyecatcher to calculate the PIE slide, see loadSymbols().
- // Ideally we'd use _mh_execute_header because it's always at 0x100000000
- // in the image but as it's located in a different section than executable
- // code, its displacement is different.
- pub fn deinit(self: *SymbolTable) void {
- self.allocator.free(self.symbols);
- self.symbols = []const Symbol{};
-
- self.allocator.free(self.strings);
- self.strings = []const u8{};
- }
-
- pub fn search(self: *const SymbolTable, address: usize) ?*const Symbol {
- var min: usize = 0;
- var max: usize = self.symbols.len - 1; // Exclude sentinel.
- while (min < max) {
- const mid = min + (max - min) / 2;
- const curr = &self.symbols[mid];
- const next = &self.symbols[mid + 1];
- if (address >= next.address) {
- min = mid + 1;
- } else if (address < curr.address) {
- max = mid;
- } else {
- return curr;
- }
- }
- return null;
- }
-};
+/// load a dynamically linked shared library that is allowed to be missing
+/// (all symbols are weak imported).
+pub const LC_LOAD_WEAK_DYLIB = (0x18 | LC_REQ_DYLD);
+
+pub const LC_SEGMENT_64 = 0x19; /// 64-bit segment of this file to be mapped
+pub const LC_ROUTINES_64 = 0x1a; /// 64-bit image routines
+pub const LC_UUID = 0x1b; /// the uuid
+pub const LC_RPATH = (0x1c | LC_REQ_DYLD); /// runpath additions
+pub const LC_CODE_SIGNATURE = 0x1d; /// local of code signature
+pub const LC_SEGMENT_SPLIT_INFO = 0x1e; /// local of info to split segments
+pub const LC_REEXPORT_DYLIB = (0x1f | LC_REQ_DYLD); /// load and re-export dylib
+pub const LC_LAZY_LOAD_DYLIB = 0x20; /// delay load of dylib until first use
+pub const LC_ENCRYPTION_INFO = 0x21; /// encrypted segment information
+pub const LC_DYLD_INFO = 0x22; /// compressed dyld information
+pub const LC_DYLD_INFO_ONLY = (0x22|LC_REQ_DYLD); /// compressed dyld information only
+pub const LC_LOAD_UPWARD_DYLIB = (0x23 | LC_REQ_DYLD); /// load upward dylib
+pub const LC_VERSION_MIN_MACOSX = 0x24; /// build for MacOSX min OS version
+pub const LC_VERSION_MIN_IPHONEOS = 0x25; /// build for iPhoneOS min OS version
+pub const LC_FUNCTION_STARTS = 0x26; /// compressed table of function start addresses
+pub const LC_DYLD_ENVIRONMENT = 0x27; /// string for dyld to treat like environment variable
+pub const LC_MAIN = (0x28|LC_REQ_DYLD); /// replacement for LC_UNIXTHREAD
+pub const LC_DATA_IN_CODE = 0x29; /// table of non-instructions in __text
+pub const LC_SOURCE_VERSION = 0x2A; /// source version used to build binary
+pub const LC_DYLIB_CODE_SIGN_DRS = 0x2B; /// Code signing DRs copied from linked dylibs
+pub const LC_ENCRYPTION_INFO_64 = 0x2C; /// 64-bit encrypted segment information
+pub const LC_LINKER_OPTION = 0x2D; /// linker options in MH_OBJECT files
+pub const LC_LINKER_OPTIMIZATION_HINT = 0x2E; /// optimization hints in MH_OBJECT files
+pub const LC_VERSION_MIN_TVOS = 0x2F; /// build for AppleTV min OS version
+pub const LC_VERSION_MIN_WATCHOS = 0x30; /// build for Watch min OS version
+pub const LC_NOTE = 0x31; /// arbitrary data included within a Mach-O file
+pub const LC_BUILD_VERSION = 0x32; /// build for platform min OS version
+
+pub const MH_MAGIC = 0xfeedface; /// the mach magic number
+pub const MH_CIGAM = 0xcefaedfe; /// NXSwapInt(MH_MAGIC)
+
+pub const MH_MAGIC_64 = 0xfeedfacf; /// the 64-bit mach magic number
+pub const MH_CIGAM_64 = 0xcffaedfe; /// NXSwapInt(MH_MAGIC_64)
+
+pub const MH_OBJECT = 0x1; /// relocatable object file
+pub const MH_EXECUTE = 0x2; /// demand paged executable file
+pub const MH_FVMLIB = 0x3; /// fixed VM shared library file
+pub const MH_CORE = 0x4; /// core file
+pub const MH_PRELOAD = 0x5; /// preloaded executable file
+pub const MH_DYLIB = 0x6; /// dynamically bound shared library
+pub const MH_DYLINKER = 0x7; /// dynamic link editor
+pub const MH_BUNDLE = 0x8; /// dynamically bound bundle file
+pub const MH_DYLIB_STUB = 0x9; /// shared library stub for static linking only, no section contents
+pub const MH_DSYM = 0xa; /// companion file with only debug sections
+pub const MH_KEXT_BUNDLE = 0xb; /// x86_64 kexts
+
+// Constants for the flags field of the mach_header
+
+pub const MH_NOUNDEFS = 0x1; /// the object file has no undefined references
+pub const MH_INCRLINK = 0x2; /// the object file is the output of an incremental link against a base file and can't be link edited again
+pub const MH_DYLDLINK = 0x4; /// the object file is input for the dynamic linker and can't be staticly link edited again
+pub const MH_BINDATLOAD = 0x8; /// the object file's undefined references are bound by the dynamic linker when loaded.
+pub const MH_PREBOUND = 0x10; /// the file has its dynamic undefined references prebound.
+pub const MH_SPLIT_SEGS = 0x20; /// the file has its read-only and read-write segments split
+pub const MH_LAZY_INIT = 0x40; /// the shared library init routine is to be run lazily via catching memory faults to its writeable segments (obsolete)
+pub const MH_TWOLEVEL = 0x80; /// the image is using two-level name space bindings
+pub const MH_FORCE_FLAT = 0x100; /// the executable is forcing all images to use flat name space bindings
+pub const MH_NOMULTIDEFS = 0x200; /// this umbrella guarantees no multiple defintions of symbols in its sub-images so the two-level namespace hints can always be used.
+pub const MH_NOFIXPREBINDING = 0x400; /// do not have dyld notify the prebinding agent about this executable
+pub const MH_PREBINDABLE = 0x800; /// the binary is not prebound but can have its prebinding redone. only used when MH_PREBOUND is not set.
+pub const MH_ALLMODSBOUND = 0x1000; /// indicates that this binary binds to all two-level namespace modules of its dependent libraries. only used when MH_PREBINDABLE and MH_TWOLEVEL are both set.
+pub const MH_SUBSECTIONS_VIA_SYMBOLS = 0x2000;/// safe to divide up the sections into sub-sections via symbols for dead code stripping
+pub const MH_CANONICAL = 0x4000; /// the binary has been canonicalized via the unprebind operation
+pub const MH_WEAK_DEFINES = 0x8000; /// the final linked image contains external weak symbols
+pub const MH_BINDS_TO_WEAK = 0x10000; /// the final linked image uses weak symbols
+
+pub const MH_ALLOW_STACK_EXECUTION = 0x20000;/// When this bit is set, all stacks in the task will be given stack execution privilege. Only used in MH_EXECUTE filetypes.
+pub const MH_ROOT_SAFE = 0x40000; /// When this bit is set, the binary declares it is safe for use in processes with uid zero
+
+pub const MH_SETUID_SAFE = 0x80000; /// When this bit is set, the binary declares it is safe for use in processes when issetugid() is true
+
+pub const MH_NO_REEXPORTED_DYLIBS = 0x100000; /// When this bit is set on a dylib, the static linker does not need to examine dependent dylibs to see if any are re-exported
+pub const MH_PIE = 0x200000; /// When this bit is set, the OS will load the main executable at a random address. Only used in MH_EXECUTE filetypes.
+pub const MH_DEAD_STRIPPABLE_DYLIB = 0x400000; /// Only for use on dylibs. When linking against a dylib that has this bit set, the static linker will automatically not create a LC_LOAD_DYLIB load command to the dylib if no symbols are being referenced from the dylib.
+pub const MH_HAS_TLV_DESCRIPTORS = 0x800000; /// Contains a section of type S_THREAD_LOCAL_VARIABLES
+
+pub const MH_NO_HEAP_EXECUTION = 0x1000000; /// When this bit is set, the OS will run the main executable with a non-executable heap even on platforms (e.g. i386) that don't require it. Only used in MH_EXECUTE filetypes.
+
+pub const MH_APP_EXTENSION_SAFE = 0x02000000; /// The code was linked for use in an application extension.
+
+pub const MH_NLIST_OUTOFSYNC_WITH_DYLDINFO = 0x04000000; /// The external symbols listed in the nlist symbol table do not include all the symbols listed in the dyld info.
+
+
+/// The flags field of a section structure is separated into two parts a section
+/// type and section attributes. The section types are mutually exclusive (it
+/// can only have one type) but the section attributes are not (it may have more
+/// than one attribute).
+/// 256 section types
+pub const SECTION_TYPE = 0x000000ff;
+pub const SECTION_ATTRIBUTES = 0xffffff00; /// 24 section attributes
+
+pub const S_REGULAR = 0x0; /// regular section
+pub const S_ZEROFILL = 0x1; /// zero fill on demand section
+pub const S_CSTRING_LITERALS = 0x2; /// section with only literal C string
+pub const S_4BYTE_LITERALS = 0x3; /// section with only 4 byte literals
+pub const S_8BYTE_LITERALS = 0x4; /// section with only 8 byte literals
+pub const S_LITERAL_POINTERS = 0x5; /// section with only pointers to
+
+
+pub const N_STAB = 0xe0; /// if any of these bits set, a symbolic debugging entry
+pub const N_PEXT = 0x10; /// private external symbol bit
+pub const N_TYPE = 0x0e; /// mask for the type bits
+pub const N_EXT = 0x01; /// external symbol bit, set for external symbols
+
+
+pub const N_GSYM = 0x20; /// global symbol: name,,NO_SECT,type,0
+pub const N_FNAME = 0x22; /// procedure name (f77 kludge): name,,NO_SECT,0,0
+pub const N_FUN = 0x24; /// procedure: name,,n_sect,linenumber,address
+pub const N_STSYM = 0x26; /// static symbol: name,,n_sect,type,address
+pub const N_LCSYM = 0x28; /// .lcomm symbol: name,,n_sect,type,address
+pub const N_BNSYM = 0x2e; /// begin nsect sym: 0,,n_sect,0,address
+pub const N_AST = 0x32; /// AST file path: name,,NO_SECT,0,0
+pub const N_OPT = 0x3c; /// emitted with gcc2_compiled and in gcc source
+pub const N_RSYM = 0x40; /// register sym: name,,NO_SECT,type,register
+pub const N_SLINE = 0x44; /// src line: 0,,n_sect,linenumber,address
+pub const N_ENSYM = 0x4e; /// end nsect sym: 0,,n_sect,0,address
+pub const N_SSYM = 0x60; /// structure elt: name,,NO_SECT,type,struct_offset
+pub const N_SO = 0x64; /// source file name: name,,n_sect,0,address
+pub const N_OSO = 0x66; /// object file name: name,,0,0,st_mtime
+pub const N_LSYM = 0x80; /// local sym: name,,NO_SECT,type,offset
+pub const N_BINCL = 0x82; /// include file beginning: name,,NO_SECT,0,sum
+pub const N_SOL = 0x84; /// #included file name: name,,n_sect,0,address
+pub const N_PARAMS = 0x86; /// compiler parameters: name,,NO_SECT,0,0
+pub const N_VERSION = 0x88; /// compiler version: name,,NO_SECT,0,0
+pub const N_OLEVEL = 0x8A; /// compiler -O level: name,,NO_SECT,0,0
+pub const N_PSYM = 0xa0; /// parameter: name,,NO_SECT,type,offset
+pub const N_EINCL = 0xa2; /// include file end: name,,NO_SECT,0,0
+pub const N_ENTRY = 0xa4; /// alternate entry: name,,n_sect,linenumber,address
+pub const N_LBRAC = 0xc0; /// left bracket: 0,,NO_SECT,nesting level,address
+pub const N_EXCL = 0xc2; /// deleted include file: name,,NO_SECT,0,sum
+pub const N_RBRAC = 0xe0; /// right bracket: 0,,NO_SECT,nesting level,address
+pub const N_BCOMM = 0xe2; /// begin common: name,,NO_SECT,0,0
+pub const N_ECOMM = 0xe4; /// end common: name,,n_sect,0,0
+pub const N_ECOML = 0xe8; /// end common (local name): 0,,n_sect,0,address
+pub const N_LENG = 0xfe; /// second stab entry with length information
+
+/// If a segment contains any sections marked with S_ATTR_DEBUG then all
+/// sections in that segment must have this attribute. No section other than
+/// a section marked with this attribute may reference the contents of this
+/// section. A section with this attribute may contain no symbols and must have
+/// a section type S_REGULAR. The static linker will not copy section contents
+/// from sections with this attribute into its output file. These sections
+/// generally contain DWARF debugging info.
+pub const S_ATTR_DEBUG = 0x02000000; /// a debug section
+
+pub const cpu_type_t = integer_t;
+pub const cpu_subtype_t = integer_t;
+pub const integer_t = c_int;
+pub const vm_prot_t = c_int;
-pub fn loadSymbols(allocator: *mem.Allocator, in: *io.FileInStream) !SymbolTable {
- var file = in.file;
- try file.seekTo(0);
-
- var hdr: MachHeader64 = undefined;
- try readOneNoEof(in, MachHeader64, &hdr);
- if (hdr.magic != MH_MAGIC_64) return error.MissingDebugInfo;
- const is_pie = MH_PIE == (hdr.flags & MH_PIE);
-
- var pos: usize = @sizeOf(@typeOf(hdr));
- var ncmd: u32 = hdr.ncmds;
- while (ncmd != 0) : (ncmd -= 1) {
- try file.seekTo(pos);
- var lc: LoadCommand = undefined;
- try readOneNoEof(in, LoadCommand, &lc);
- if (lc.cmd == LC_SYMTAB) break;
- pos += lc.cmdsize;
- } else {
- return error.MissingDebugInfo;
- }
-
- var cmd: SymtabCommand = undefined;
- try readOneNoEof(in, SymtabCommand, &cmd);
-
- try file.seekTo(cmd.symoff);
- var syms = try allocator.alloc(Nlist64, cmd.nsyms);
- defer allocator.free(syms);
- try readNoEof(in, Nlist64, syms);
-
- try file.seekTo(cmd.stroff);
- var strings = try allocator.alloc(u8, cmd.strsize);
- errdefer allocator.free(strings);
- try in.stream.readNoEof(strings);
-
- var nsyms: usize = 0;
- for (syms) |sym|
- if (isSymbol(sym)) nsyms += 1;
- if (nsyms == 0) return error.MissingDebugInfo;
-
- var symbols = try allocator.alloc(Symbol, nsyms + 1); // Room for sentinel.
- errdefer allocator.free(symbols);
-
- var pie_slide: usize = 0;
- var nsym: usize = 0;
- for (syms) |sym| {
- if (!isSymbol(sym)) continue;
- const start = sym.n_strx;
- const end = mem.indexOfScalarPos(u8, strings, start, 0).?;
- const name = strings[start..end];
- const address = sym.n_value;
- symbols[nsym] = Symbol{ .name = name, .address = address };
- nsym += 1;
- if (is_pie and mem.eql(u8, name, "_SymbolTable_deinit")) {
- pie_slide = @ptrToInt(SymbolTable.deinit) - address;
- }
- }
-
- // Effectively a no-op, lld emits symbols in ascending order.
- std.sort.sort(Symbol, symbols[0..nsyms], Symbol.addressLessThan);
-
- // Insert the sentinel. Since we don't know where the last function ends,
- // we arbitrarily limit it to the start address + 4 KB.
- const top = symbols[nsyms - 1].address + 4096;
- symbols[nsyms] = Symbol{ .name = "", .address = top };
-
- if (pie_slide != 0) {
- for (symbols) |*symbol|
- symbol.address += pie_slide;
- }
-
- return SymbolTable{
- .allocator = allocator,
- .symbols = symbols,
- .strings = strings,
- };
-}
-
-fn readNoEof(in: *io.FileInStream, comptime T: type, result: []T) !void {
- return in.stream.readNoEof(@sliceToBytes(result));
-}
-fn readOneNoEof(in: *io.FileInStream, comptime T: type, result: *T) !void {
- return readNoEof(in, T, (*[1]T)(result)[0..]);
-}
-
-fn isSymbol(sym: *const Nlist64) bool {
- return sym.n_value != 0 and sym.n_desc == 0;
-}
diff --git a/std/os/index.zig b/std/os/index.zig
index a0b6e6bf45..29d887e214 100644
--- a/std/os/index.zig
+++ b/std/os/index.zig
@@ -635,6 +635,35 @@ fn posixExecveErrnoToErr(err: usize) PosixExecveError {
pub var linux_aux_raw = []usize{0} ** 38;
pub var posix_environ_raw: [][*]u8 = undefined;
+/// See std.elf for the constants.
+pub fn linuxGetAuxVal(index: usize) usize {
+ if (builtin.link_libc) {
+ return usize(std.c.getauxval(index));
+ } else {
+ return linux_aux_raw[index];
+ }
+}
+
+pub fn getBaseAddress() usize {
+ switch (builtin.os) {
+ builtin.Os.linux => {
+ const base = linuxGetAuxVal(std.elf.AT_BASE);
+ if (base != 0) {
+ return base;
+ }
+ const phdr = linuxGetAuxVal(std.elf.AT_PHDR);
+ const ElfHeader = switch (@sizeOf(usize)) {
+ 4 => std.elf.Elf32_Ehdr,
+ 8 => std.elf.Elf64_Ehdr,
+ else => @compileError("Unsupported architecture"),
+ };
+ return phdr - @sizeOf(ElfHeader);
+ },
+ builtin.Os.macosx => return @ptrToInt(&std.c._mh_execute_header),
+ else => @compileError("Unsupported OS"),
+ }
+}
+
/// Caller must free result when done.
/// TODO make this go through libc when we have it
pub fn getEnvMap(allocator: *Allocator) !BufMap {
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-27 21:06:21 +0000