jimzah/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-11-26 23:22:44 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

@import("builtin") instead of @compileVar

Browse Source 
See #226
Closes #220
This commit is contained in:
Andrew Kelley 2017-05-01 13:12:38 -04:00
parent c5dd536845
commit 17b935325e
33 changed files with 317 additions and 421 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
doc/langref.md
View File

@ -446,23 +446,6 @@ This function can only occur inside `@c_import`.
This appends `#undef $name` to the `c_import` temporary buffer.
### @compileVar(comptime name: []u8) -> (varying type)
This function returns a compile-time variable. There are built in compile
variables:
* "is_big_endian" `bool` - either `true` for big endian or `false` for little endian.
* "is_release" `bool`- either `true` for release mode builds or `false` for debug mode builds.
* "is_test" `bool`- either `true` for test builds or `false` otherwise.
* "os" `Os` - use `zig targets` to see what enum values are possible here.
* "arch" `Arch` - use `zig targets` to see what enum values are possible here.
* "environ" `Environ` - use `zig targets` to see what enum values are possible here.
Build scripts can set additional compile variables of any name and type.
The result of this function is a compile time constant that is marked as
depending on a compile variable.
### @generatedCode(expression) -> @typeOf(expression)
This function wraps an expression and returns the result of the expression

12
src/all_types.hpp
View File

@ -1173,7 +1173,6 @@ enum BuiltinFnId {
BuiltinFnIdCInclude,
BuiltinFnIdCDefine,
BuiltinFnIdCUndef,
BuiltinFnIdCompileVar,
BuiltinFnIdCompileErr,
BuiltinFnIdCompileLog,
BuiltinFnIdGeneratedCode,
@ -1323,7 +1322,6 @@ struct CodeGen {
HashMap<GenericFnTypeId *, FnTableEntry *, generic_fn_type_id_hash, generic_fn_type_id_eql> generic_table;
HashMap<Scope *, IrInstruction *, fn_eval_hash, fn_eval_eql> memoized_fn_eval_table;
HashMap<ZigLLVMFnKey, LLVMValueRef, zig_llvm_fn_key_hash, zig_llvm_fn_key_eql> llvm_fn_table;
HashMap<Buf *, ConstExprValue *, buf_hash, buf_eql_buf> compile_vars;
HashMap<Buf *, Tld *, buf_hash, buf_eql_buf> exported_symbol_names;
HashMap<Buf *, Tld *, buf_hash, buf_eql_buf> external_prototypes;
@ -1407,6 +1405,8 @@ struct CodeGen {
PackageTableEntry *std_package;
PackageTableEntry *zigrt_package;
PackageTableEntry *test_runner_package;
PackageTableEntry *compile_var_package;
ImportTableEntry *compile_var_import;
Buf *root_out_name;
bool windows_subsystem_windows;
bool windows_subsystem_console;
@ -1635,6 +1635,7 @@ struct ScopeFnDef {
FnTableEntry *fn_entry;
};
// synchronized with code in define_builtin_compile_vars
enum AtomicOrder {
AtomicOrderUnordered,
AtomicOrderMonotonic,
@ -1706,7 +1707,6 @@ enum IrInstructionId {
IrInstructionIdArrayType,
IrInstructionIdSliceType,
IrInstructionIdAsm,
IrInstructionIdCompileVar,
IrInstructionIdSizeOf,
IrInstructionIdTestNonNull,
IrInstructionIdUnwrapMaybe,
@ -2085,12 +2085,6 @@ struct IrInstructionAsm {
bool has_side_effects;
};
struct IrInstructionCompileVar {
IrInstruction base;
IrInstruction *name;
};
struct IrInstructionSizeOf {
IrInstruction base;

10
src/analyze.cpp
View File

@ -2084,6 +2084,14 @@ void init_tld(Tld *tld, TldId id, Buf *name, VisibMod visib_mod, AstNode *source
tld->parent_scope = parent_scope;
}
void update_compile_var(CodeGen *g, Buf *name, ConstExprValue *value) {
Tld *tld = g->compile_var_import->decls_scope->decl_table.get(name);
resolve_top_level_decl(g, tld, false);
assert(tld->id == TldIdVar);
TldVar *tld_var = (TldVar *)tld;
tld_var->var->value = value;
}
void scan_decls(CodeGen *g, ScopeDecls *decls_scope, AstNode *node) {
switch (node->type) {
case NodeTypeRoot:
@ -2122,7 +2130,7 @@ void scan_decls(CodeGen *g, ScopeDecls *decls_scope, AstNode *node) {
if (import == g->root_import && scope_is_root_decls(&decls_scope->base) &&
buf_eql_str(fn_name, "panic"))
{
g->compile_vars.put(buf_create_from_str("panic_implementation_provided"),
update_compile_var(g, buf_create_from_str("__zig_panic_implementation_provided"),
create_const_bool(g, true));
}

1
src/analyze.hpp
View File

@ -152,5 +152,6 @@ ConstParent *get_const_val_parent(CodeGen *g, ConstExprValue *value);
FnTableEntry *get_extern_panic_fn(CodeGen *g);
TypeTableEntry *create_enum_tag_type(CodeGen *g, TypeTableEntry *enum_type, TypeTableEntry *int_type);
void expand_undef_array(CodeGen *g, ConstExprValue *const_val);
void update_compile_var(CodeGen *g, Buf *name, ConstExprValue *value);
#endif

399
src/codegen.cpp
View File

@ -47,7 +47,7 @@ static void init_darwin_native(CodeGen *g) {
}
}
PackageTableEntry *new_package(const char *root_src_dir, const char *root_src_path) {
static PackageTableEntry *new_package(const char *root_src_dir, const char *root_src_path) {
PackageTableEntry *entry = allocate<PackageTableEntry>(1);
entry->package_table.init(4);
buf_init_from_str(&entry->root_src_dir, root_src_dir);
@ -70,7 +70,6 @@ CodeGen *codegen_create(Buf *root_src_path, const ZigTarget *target, OutType out
g->generic_table.init(16);
g->llvm_fn_table.init(16);
g->memoized_fn_eval_table.init(16);
g->compile_vars.init(16);
g->exported_symbol_names.init(8);
g->external_prototypes.init(8);
g->is_release_build = false;
@ -2883,7 +2882,6 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
case IrInstructionIdSetDebugSafety:
case IrInstructionIdArrayType:
case IrInstructionIdSliceType:
case IrInstructionIdCompileVar:
case IrInstructionIdSizeOf:
case IrInstructionIdSwitchTarget:
case IrInstructionIdContainerInitFields:
@ -3627,6 +3625,13 @@ static LLVMValueRef build_alloca(CodeGen *g, TypeTableEntry *type_entry, const c
return result;
}
static void ensure_cache_dir(CodeGen *g) {
int err;
if ((err = os_make_path(g->cache_dir))) {
zig_panic("unable to make cache dir: %s", err_str(err));
}
}
static void do_code_gen(CodeGen *g) {
if (g->verbose) {
fprintf(stderr, "\nCode Generation:\n");
@ -3919,10 +3924,7 @@ static void do_code_gen(CodeGen *g) {
buf_append_str(o_basename, o_ext);
Buf *output_path = buf_alloc();
os_path_join(g->cache_dir, o_basename, output_path);
int err;
if ((err = os_make_path(g->cache_dir))) {
zig_panic("unable to make cache dir: %s", err_str(err));
}
ensure_cache_dir(g);
if (ZigLLVMTargetMachineEmitToFile(g->target_machine, g->module, buf_ptr(output_path),
LLVMObjectFile, &err_msg, !g->is_release_build))
{
@ -3970,36 +3972,6 @@ static const GlobalLinkageValue global_linkage_values[] = {
{GlobalLinkageIdLinkOnce, "LinkOnce"},
};
static void init_enum_debug_info(CodeGen *g, TypeTableEntry *enum_type) {
uint32_t field_count = enum_type->data.enumeration.src_field_count;
TypeTableEntry *tag_int_type = get_smallest_unsigned_int_type(g, field_count);
TypeTableEntry *tag_type_entry = create_enum_tag_type(g, enum_type, tag_int_type);
enum_type->data.enumeration.tag_type = tag_type_entry;
ZigLLVMDIEnumerator **di_enumerators = allocate<ZigLLVMDIEnumerator*>(field_count);
for (uint32_t i = 0; i < field_count; i += 1) {
TypeEnumField *field = &enum_type->data.enumeration.fields[i];
di_enumerators[i] = ZigLLVMCreateDebugEnumerator(g->dbuilder, buf_ptr(field->name), i);
}
// create debug type for tag
uint64_t tag_debug_size_in_bits = 8*LLVMStoreSizeOfType(g->target_data_ref, tag_type_entry->type_ref);
uint64_t tag_debug_align_in_bits = 8*LLVMABISizeOfType(g->target_data_ref, tag_type_entry->type_ref);
enum_type->di_type = ZigLLVMCreateDebugEnumerationType(g->dbuilder,
nullptr, buf_ptr(&enum_type->name),
nullptr, 0,
tag_debug_size_in_bits,
tag_debug_align_in_bits,
di_enumerators, field_count,
tag_type_entry->di_type, "");
enum_type->type_ref = tag_type_entry->type_ref;
enum_type->data.enumeration.complete = true;
enum_type->data.enumeration.zero_bits_known = true;
}
static void define_builtin_types(CodeGen *g) {
{
// if this type is anywhere in the AST, we should never hit codegen.
@ -4218,167 +4190,6 @@ static void define_builtin_types(CodeGen *g) {
g->primitive_type_table.put(&entry->name, entry);
}
{
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdEnum);
buf_init_from_str(&entry->name, "Os");
uint32_t field_count = (uint32_t)target_os_count();
entry->data.enumeration.src_field_count = field_count;
entry->data.enumeration.fields = allocate<TypeEnumField>(field_count);
for (uint32_t i = 0; i < field_count; i += 1) {
TypeEnumField *type_enum_field = &entry->data.enumeration.fields[i];
ZigLLVM_OSType os_type = get_target_os(i);
type_enum_field->name = buf_create_from_str(get_target_os_name(os_type));
type_enum_field->value = i;
type_enum_field->type_entry = g->builtin_types.entry_void;
if (os_type == g->zig_target.os) {
g->target_os_index = i;
}
}
init_enum_debug_info(g, entry);
g->builtin_types.entry_os_enum = entry;
g->primitive_type_table.put(&entry->name, entry);
}
{
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdEnum);
buf_init_from_str(&entry->name, "Arch");
uint32_t field_count = (uint32_t)target_arch_count();
entry->data.enumeration.src_field_count = field_count;
entry->data.enumeration.fields = allocate<TypeEnumField>(field_count);
for (uint32_t i = 0; i < field_count; i += 1) {
TypeEnumField *type_enum_field = &entry->data.enumeration.fields[i];
const ArchType *arch_type = get_target_arch(i);
type_enum_field->name = buf_alloc();
buf_resize(type_enum_field->name, 50);
get_arch_name(buf_ptr(type_enum_field->name), arch_type);
buf_resize(type_enum_field->name, strlen(buf_ptr(type_enum_field->name)));
type_enum_field->value = i;
type_enum_field->type_entry = g->builtin_types.entry_void;
if (arch_type->arch == g->zig_target.arch.arch &&
arch_type->sub_arch == g->zig_target.arch.sub_arch)
{
g->target_arch_index = i;
}
}
init_enum_debug_info(g, entry);
g->builtin_types.entry_arch_enum = entry;
g->primitive_type_table.put(&entry->name, entry);
}
{
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdEnum);
buf_init_from_str(&entry->name, "Environ");
uint32_t field_count = (uint32_t)target_environ_count();
entry->data.enumeration.src_field_count = field_count;
entry->data.enumeration.fields = allocate<TypeEnumField>(field_count);
for (uint32_t i = 0; i < field_count; i += 1) {
TypeEnumField *type_enum_field = &entry->data.enumeration.fields[i];
ZigLLVM_EnvironmentType environ_type = get_target_environ(i);
type_enum_field->name = buf_create_from_str(ZigLLVMGetEnvironmentTypeName(environ_type));
type_enum_field->value = i;
type_enum_field->type_entry = g->builtin_types.entry_void;
if (environ_type == g->zig_target.env_type) {
g->target_environ_index = i;
}
}
init_enum_debug_info(g, entry);
g->builtin_types.entry_environ_enum = entry;
g->primitive_type_table.put(&entry->name, entry);
}
{
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdEnum);
buf_init_from_str(&entry->name, "ObjectFormat");
uint32_t field_count = (uint32_t)target_oformat_count();
entry->data.enumeration.src_field_count = field_count;
entry->data.enumeration.fields = allocate<TypeEnumField>(field_count);
for (uint32_t i = 0; i < field_count; i += 1) {
TypeEnumField *type_enum_field = &entry->data.enumeration.fields[i];
ZigLLVM_ObjectFormatType oformat = get_target_oformat(i);
type_enum_field->name = buf_create_from_str(get_target_oformat_name(oformat));
type_enum_field->value = i;
type_enum_field->type_entry = g->builtin_types.entry_void;
if (oformat == g->zig_target.oformat) {
g->target_oformat_index = i;
}
}
init_enum_debug_info(g, entry);
g->builtin_types.entry_oformat_enum = entry;
g->primitive_type_table.put(&entry->name, entry);
}
{
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdEnum);
entry->zero_bits = true; // only allowed at compile time
buf_init_from_str(&entry->name, "GlobalLinkage");
uint32_t field_count = array_length(global_linkage_values);
entry->data.enumeration.src_field_count = field_count;
entry->data.enumeration.fields = allocate<TypeEnumField>(field_count);
for (uint32_t i = 0; i < field_count; i += 1) {
TypeEnumField *type_enum_field = &entry->data.enumeration.fields[i];
const GlobalLinkageValue *value = &global_linkage_values[i];
type_enum_field->name = buf_create_from_str(value->name);
type_enum_field->value = i;
type_enum_field->type_entry = g->builtin_types.entry_void;
}
entry->data.enumeration.complete = true;
entry->data.enumeration.zero_bits_known = true;
TypeTableEntry *tag_type_entry = get_smallest_unsigned_int_type(g, field_count);
entry->data.enumeration.tag_type = tag_type_entry;
g->builtin_types.entry_global_linkage_enum = entry;
g->primitive_type_table.put(&entry->name, entry);
}
{
TypeTableEntry *entry = new_type_table_entry(TypeTableEntryIdEnum);
entry->zero_bits = true; // only allowed at compile time
buf_init_from_str(&entry->name, "AtomicOrder");
uint32_t field_count = 6;
entry->data.enumeration.src_field_count = field_count;
entry->data.enumeration.fields = allocate<TypeEnumField>(field_count);
entry->data.enumeration.fields[0].name = buf_create_from_str("Unordered");
entry->data.enumeration.fields[0].value = AtomicOrderUnordered;
entry->data.enumeration.fields[0].type_entry = g->builtin_types.entry_void;
entry->data.enumeration.fields[1].name = buf_create_from_str("Monotonic");
entry->data.enumeration.fields[1].value = AtomicOrderMonotonic;
entry->data.enumeration.fields[1].type_entry = g->builtin_types.entry_void;
entry->data.enumeration.fields[2].name = buf_create_from_str("Acquire");
entry->data.enumeration.fields[2].value = AtomicOrderAcquire;
entry->data.enumeration.fields[2].type_entry = g->builtin_types.entry_void;
entry->data.enumeration.fields[3].name = buf_create_from_str("Release");
entry->data.enumeration.fields[3].value = AtomicOrderRelease;
entry->data.enumeration.fields[3].type_entry = g->builtin_types.entry_void;
entry->data.enumeration.fields[4].name = buf_create_from_str("AcqRel");
entry->data.enumeration.fields[4].value = AtomicOrderAcqRel;
entry->data.enumeration.fields[4].type_entry = g->builtin_types.entry_void;
entry->data.enumeration.fields[5].name = buf_create_from_str("SeqCst");
entry->data.enumeration.fields[5].value = AtomicOrderSeqCst;
entry->data.enumeration.fields[5].type_entry = g->builtin_types.entry_void;
entry->data.enumeration.complete = true;
entry->data.enumeration.zero_bits_known = true;
TypeTableEntry *tag_type_entry = get_smallest_unsigned_int_type(g, field_count);
entry->data.enumeration.tag_type = tag_type_entry;
g->builtin_types.entry_atomic_order_enum = entry;
g->primitive_type_table.put(&entry->name, entry);
}
}
@ -4475,7 +4286,6 @@ static void define_builtin_fns(CodeGen *g) {
create_builtin_fn(g, BuiltinFnIdCInclude, "cInclude", 1);
create_builtin_fn(g, BuiltinFnIdCDefine, "cDefine", 2);
create_builtin_fn(g, BuiltinFnIdCUndef, "cUndef", 1);
create_builtin_fn(g, BuiltinFnIdCompileVar, "compileVar", 1);
create_builtin_fn(g, BuiltinFnIdGeneratedCode, "generatedCode", 1);
create_builtin_fn(g, BuiltinFnIdCtz, "ctz", 1);
create_builtin_fn(g, BuiltinFnIdClz, "clz", 1);
@ -4506,38 +4316,159 @@ static void define_builtin_fns(CodeGen *g) {
create_builtin_fn(g, BuiltinFnIdOffsetOf, "offsetOf", 2);
}
static void add_compile_var(CodeGen *g, const char *name, ConstExprValue *value) {
g->compile_vars.put_unique(buf_create_from_str(name), value);
static const char *bool_to_str(bool b) {
return b ? "true" : "false";
}
static void define_builtin_compile_vars(CodeGen *g) {
add_compile_var(g, "is_big_endian", create_const_bool(g, g->is_big_endian));
add_compile_var(g, "is_release", create_const_bool(g, g->is_release_build));
add_compile_var(g, "is_test", create_const_bool(g, g->is_test_build));
add_compile_var(g, "os", create_const_enum_tag(g->builtin_types.entry_os_enum, g->target_os_index));
add_compile_var(g, "arch", create_const_enum_tag(g->builtin_types.entry_arch_enum, g->target_arch_index));
add_compile_var(g, "environ", create_const_enum_tag(g->builtin_types.entry_environ_enum, g->target_environ_index));
add_compile_var(g, "object_format", create_const_enum_tag(
g->builtin_types.entry_oformat_enum, g->target_oformat_index));
if (g->std_package == nullptr)
return;
const char *builtin_zig_basename = "builtin.zig";
Buf *builtin_zig_path = buf_alloc();
os_path_join(g->cache_dir, buf_create_from_str(builtin_zig_basename), builtin_zig_path);
Buf *contents = buf_alloc();
const char *cur_os = nullptr;
{
TypeTableEntry *str_type = get_slice_type(g, g->builtin_types.entry_u8, true);
ConstExprValue *const_val = allocate<ConstExprValue>(1);
const_val->special = ConstValSpecialStatic;
const_val->type = get_array_type(g, str_type, g->link_libs.length);
const_val->data.x_array.s_none.elements = allocate<ConstExprValue>(g->link_libs.length);
for (size_t i = 0; i < g->link_libs.length; i += 1) {
Buf *link_lib_buf = g->link_libs.at(i);
ConstExprValue *array_val = create_const_str_lit(g, link_lib_buf);
init_const_slice(g, &const_val->data.x_array.s_none.elements[i], array_val, 0, buf_len(link_lib_buf), true);
buf_appendf(contents, "pub const Os = enum {\n");
uint32_t field_count = (uint32_t)target_os_count();
for (uint32_t i = 0; i < field_count; i += 1) {
ZigLLVM_OSType os_type = get_target_os(i);
const char *name = get_target_os_name(os_type);
buf_appendf(contents, " %s,\n", name);
if (os_type == g->zig_target.os) {
g->target_os_index = i;
cur_os = name;
}
}
buf_appendf(contents, "};\n\n");
}
assert(cur_os != nullptr);
const char *cur_arch = nullptr;
{
buf_appendf(contents, "pub const Arch = enum {\n");
uint32_t field_count = (uint32_t)target_arch_count();
for (uint32_t i = 0; i < field_count; i += 1) {
const ArchType *arch_type = get_target_arch(i);
Buf *arch_name = buf_alloc();
buf_resize(arch_name, 50);
get_arch_name(buf_ptr(arch_name), arch_type);
buf_resize(arch_name, strlen(buf_ptr(arch_name)));
buf_appendf(contents, " %s,\n", buf_ptr(arch_name));
if (arch_type->arch == g->zig_target.arch.arch &&
arch_type->sub_arch == g->zig_target.arch.sub_arch)
{
g->target_arch_index = i;
cur_arch = buf_ptr(arch_name);
}
}
buf_appendf(contents, "};\n\n");
}
assert(cur_arch != nullptr);
const char *cur_environ = nullptr;
{
buf_appendf(contents, "pub const Environ = enum {\n");
uint32_t field_count = (uint32_t)target_environ_count();
for (uint32_t i = 0; i < field_count; i += 1) {
ZigLLVM_EnvironmentType environ_type = get_target_environ(i);
const char *name = ZigLLVMGetEnvironmentTypeName(environ_type);
buf_appendf(contents, " %s,\n", name);
if (environ_type == g->zig_target.env_type) {
g->target_environ_index = i;
cur_environ = name;
}
}
buf_appendf(contents, "};\n\n");
}
assert(cur_environ != nullptr);
const char *cur_obj_fmt = nullptr;
{
buf_appendf(contents, "pub const ObjectFormat = enum {\n");
uint32_t field_count = (uint32_t)target_oformat_count();
for (uint32_t i = 0; i < field_count; i += 1) {
ZigLLVM_ObjectFormatType oformat = get_target_oformat(i);
const char *name = get_target_oformat_name(oformat);
buf_appendf(contents, " %s,\n", name);
if (oformat == g->zig_target.oformat) {
g->target_oformat_index = i;
cur_obj_fmt = name;
}
}
add_compile_var(g, "link_libs", const_val);
buf_appendf(contents, "};\n\n");
}
add_compile_var(g, "panic_implementation_provided", create_const_bool(g, false));
assert(cur_obj_fmt != nullptr);
{
buf_appendf(contents, "pub const GlobalLinkage = enum {\n");
uint32_t field_count = array_length(global_linkage_values);
for (uint32_t i = 0; i < field_count; i += 1) {
const GlobalLinkageValue *value = &global_linkage_values[i];
buf_appendf(contents, " %s,\n", value->name);
}
buf_appendf(contents, "};\n\n");
}
{
buf_appendf(contents,
"pub const AtomicOrder = enum {\n"
" Unordered,\n"
" Monotonic,\n"
" Acquire,\n"
" Release,\n"
" AcqRel,\n"
" SeqCst,\n"
"};\n\n");
}
buf_appendf(contents, "pub const is_big_endian = %s;\n", bool_to_str(g->is_big_endian));
buf_appendf(contents, "pub const is_release = %s;\n", bool_to_str(g->is_release_build));
buf_appendf(contents, "pub const is_test = %s;\n", bool_to_str(g->is_test_build));
buf_appendf(contents, "pub const os = Os.%s;\n", cur_os);
buf_appendf(contents, "pub const arch = Arch.%s;\n", cur_arch);
buf_appendf(contents, "pub const environ = Environ.%s;\n", cur_environ);
buf_appendf(contents, "pub const object_format = ObjectFormat.%s;\n", cur_obj_fmt);
{
buf_appendf(contents, "pub const link_libs = [][]const u8 {\n");
for (size_t i = 0; i < g->link_libs.length; i += 1) {
Buf *link_lib_buf = g->link_libs.at(i);
buf_appendf(contents, " \"%s\",\n", buf_ptr(link_lib_buf));
}
buf_appendf(contents, "};\n");
}
buf_appendf(contents, "pub const __zig_panic_implementation_provided = %s; // overwritten later\n",
bool_to_str(false));
buf_appendf(contents, "pub const __zig_test_fn_slice = {}; // overwritten later\n");
ensure_cache_dir(g);
os_write_file(builtin_zig_path, contents);
int err;
Buf *abs_full_path = buf_alloc();
if ((err = os_path_real(builtin_zig_path, abs_full_path))) {
zig_panic("unable to open '%s': %s", buf_ptr(builtin_zig_path), err_str(err));
}
assert(g->root_package);
assert(g->std_package);
g->compile_var_package = new_package(buf_ptr(g->cache_dir), builtin_zig_basename);
g->root_package->package_table.put(buf_create_from_str("builtin"), g->compile_var_package);
g->std_package->package_table.put(buf_create_from_str("builtin"), g->compile_var_package);
g->compile_var_import = add_source_file(g, g->compile_var_package, abs_full_path, contents);
}
static void init(CodeGen *g) {
if (g->module)
return;
assert(g->root_out_name);
g->module = LLVMModuleCreateWithName(buf_ptr(g->root_out_name));
@ -4600,14 +4531,15 @@ static void init(CodeGen *g) {
g->dummy_di_file = nullptr;
define_builtin_types(g);
define_builtin_fns(g);
define_builtin_compile_vars(g);
g->invalid_instruction = allocate<IrInstruction>(1);
g->invalid_instruction->value.type = g->builtin_types.entry_invalid;
g->const_void_val.special = ConstValSpecialStatic;
g->const_void_val.type = g->builtin_types.entry_void;
define_builtin_fns(g);
define_builtin_compile_vars(g);
}
void codegen_parseh(CodeGen *g, Buf *full_path) {
@ -4661,21 +4593,17 @@ static ImportTableEntry *add_special_code(CodeGen *g, PackageTableEntry *package
}
static PackageTableEntry *create_bootstrap_pkg(CodeGen *g, PackageTableEntry *pkg_with_main) {
PackageTableEntry *package = new_package(buf_ptr(g->zig_std_special_dir), "");
package->package_table.put(buf_create_from_str("std"), g->std_package);
PackageTableEntry *package = codegen_create_package(g, buf_ptr(g->zig_std_special_dir), "bootstrap.zig");
package->package_table.put(buf_create_from_str("@root"), pkg_with_main);
return package;
}
static PackageTableEntry *create_test_runner_pkg(CodeGen *g) {
PackageTableEntry *package = new_package(buf_ptr(g->zig_std_special_dir), "test_runner.zig");
package->package_table.put(buf_create_from_str("std"), g->std_package);
return package;
return codegen_create_package(g, buf_ptr(g->zig_std_special_dir), "test_runner.zig");
}
static PackageTableEntry *create_zigrt_pkg(CodeGen *g) {
PackageTableEntry *package = new_package(buf_ptr(g->zig_std_special_dir), "");
package->package_table.put(buf_create_from_str("std"), g->std_package);
PackageTableEntry *package = codegen_create_package(g, buf_ptr(g->zig_std_special_dir), "zigrt.zig");
package->package_table.put(buf_create_from_str("@root"), g->root_package);
return package;
}
@ -4723,7 +4651,7 @@ static void create_test_compile_var_and_add_test_runner(CodeGen *g) {
ConstExprValue *test_fn_slice = create_const_slice(g, test_fn_array, 0, g->test_fns.length, true);
g->compile_vars.put(buf_create_from_str("zig_test_fn_slice"), test_fn_slice);
update_compile_var(g, buf_create_from_str("__zig_test_fn_slice"), test_fn_slice);
g->test_runner_package = create_test_runner_pkg(g);
g->test_runner_import = add_special_code(g, g->test_runner_package, "test_runner.zig");
}
@ -5066,3 +4994,14 @@ void codegen_build(CodeGen *g) {
do_code_gen(g);
gen_h_file(g);
}
PackageTableEntry *codegen_create_package(CodeGen *g, const char *root_src_dir, const char *root_src_path) {
init(g);
PackageTableEntry *pkg = new_package(root_src_dir, root_src_path);
if (g->std_package != nullptr) {
assert(g->compile_var_package != nullptr);
pkg->package_table.put(buf_create_from_str("std"), g->std_package);
pkg->package_table.put(buf_create_from_str("builtin"), g->compile_var_package);
}
return pkg;
}

2
src/codegen.hpp
View File

@ -52,7 +52,7 @@ void codegen_add_time_event(CodeGen *g, const char *name);
void codegen_print_timing_report(CodeGen *g, FILE *f);
void codegen_build(CodeGen *g);
PackageTableEntry *new_package(const char *root_src_dir, const char *root_src_path);
PackageTableEntry *codegen_create_package(CodeGen *g, const char *root_src_dir, const char *root_src_path);
void codegen_add_assembly(CodeGen *g, Buf *path);
void codegen_add_object(CodeGen *g, Buf *object_path);

55
src/ir.cpp
View File

@ -294,10 +294,6 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionAsm *) {
return IrInstructionIdAsm;
}
static constexpr IrInstructionId ir_instruction_id(IrInstructionCompileVar *) {
return IrInstructionIdCompileVar;
}
static constexpr IrInstructionId ir_instruction_id(IrInstructionSizeOf *) {
return IrInstructionIdSizeOf;
}
@ -1249,15 +1245,6 @@ static IrInstruction *ir_build_asm_from(IrBuilder *irb, IrInstruction *old_instr
return new_instruction;
}
static IrInstruction *ir_build_compile_var(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *name) {
IrInstructionCompileVar *instruction = ir_build_instruction<IrInstructionCompileVar>(irb, scope, source_node);
instruction->name = name;
ir_ref_instruction(name, irb->current_basic_block);
return &instruction->base;
}
static IrInstruction *ir_build_size_of(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *type_value) {
IrInstructionSizeOf *instruction = ir_build_instruction<IrInstructionSizeOf>(irb, scope, source_node);
instruction->type_value = type_value;
@ -2431,13 +2418,6 @@ static IrInstruction *ir_instruction_asm_get_dep(IrInstructionAsm *instruction,
return nullptr;
}
static IrInstruction *ir_instruction_compilevar_get_dep(IrInstructionCompileVar *instruction, size_t index) {
switch (index) {
case 0: return instruction->name;
default: return nullptr;
}
}
static IrInstruction *ir_instruction_sizeof_get_dep(IrInstructionSizeOf *instruction, size_t index) {
switch (index) {
case 0: return instruction->type_value;
@ -2979,8 +2959,6 @@ static IrInstruction *ir_instruction_get_dep(IrInstruction *instruction, size_t
return ir_instruction_slicetype_get_dep((IrInstructionSliceType *) instruction, index);
case IrInstructionIdAsm:
return ir_instruction_asm_get_dep((IrInstructionAsm *) instruction, index);
case IrInstructionIdCompileVar:
return ir_instruction_compilevar_get_dep((IrInstructionCompileVar *) instruction, index);
case IrInstructionIdSizeOf:
return ir_instruction_sizeof_get_dep((IrInstructionSizeOf *) instruction, index);
case IrInstructionIdTestNonNull:
@ -3937,15 +3915,6 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
return ir_build_set_debug_safety(irb, scope, node, arg0_value, arg1_value);
}
case BuiltinFnIdCompileVar:
{
AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
if (arg0_value == irb->codegen->invalid_instruction)
return arg0_value;
return ir_build_compile_var(irb, scope, node, arg0_value);
}
case BuiltinFnIdSizeof:
{
AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
@ -10409,27 +10378,6 @@ static TypeTableEntry *ir_analyze_instruction_array_type(IrAnalyze *ira,
zig_unreachable();
}
static TypeTableEntry *ir_analyze_instruction_compile_var(IrAnalyze *ira,
IrInstructionCompileVar *compile_var_instruction)
{
IrInstruction *name_value = compile_var_instruction->name->other;
Buf *var_name = ir_resolve_str(ira, name_value);
if (!var_name)
return ira->codegen->builtin_types.entry_invalid;
ConstExprValue *out_val = ir_build_const_from(ira, &compile_var_instruction->base);
auto entry = ira->codegen->compile_vars.maybe_get(var_name);
if (entry) {
*out_val = *entry->value;
return out_val->type;
} else {
ir_add_error_node(ira, name_value->source_node,
buf_sprintf("unrecognized compile variable: '%s'", buf_ptr(var_name)));
return ira->codegen->builtin_types.entry_invalid;
}
zig_unreachable();
}
static TypeTableEntry *ir_analyze_instruction_size_of(IrAnalyze *ira,
IrInstructionSizeOf *size_of_instruction)
{
@ -13039,8 +12987,6 @@ static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructi
return ir_analyze_instruction_asm(ira, (IrInstructionAsm *)instruction);
case IrInstructionIdArrayType:
return ir_analyze_instruction_array_type(ira, (IrInstructionArrayType *)instruction);
case IrInstructionIdCompileVar:
return ir_analyze_instruction_compile_var(ira, (IrInstructionCompileVar *)instruction);
case IrInstructionIdSizeOf:
return ir_analyze_instruction_size_of(ira, (IrInstructionSizeOf *)instruction);
case IrInstructionIdTestNonNull:
@ -13292,7 +13238,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {
case IrInstructionIdEnumFieldPtr:
case IrInstructionIdArrayType:
case IrInstructionIdSliceType:
case IrInstructionIdCompileVar:
case IrInstructionIdSizeOf:
case IrInstructionIdTestNonNull:
case IrInstructionIdUnwrapMaybe:

9
src/ir_print.cpp
View File

@ -403,12 +403,6 @@ static void ir_print_asm(IrPrint *irp, IrInstructionAsm *instruction) {
fprintf(irp->f, ")");
}
static void ir_print_compile_var(IrPrint *irp, IrInstructionCompileVar *instruction) {
fprintf(irp->f, "@compileVar(");
ir_print_other_instruction(irp, instruction->name);
fprintf(irp->f, ")");
}
static void ir_print_size_of(IrPrint *irp, IrInstructionSizeOf *instruction) {
fprintf(irp->f, "@sizeOf(");
ir_print_other_instruction(irp, instruction->type_value);
@ -987,9 +981,6 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
case IrInstructionIdAsm:
ir_print_asm(irp, (IrInstructionAsm *)instruction);
break;
case IrInstructionIdCompileVar:
ir_print_compile_var(irp, (IrInstructionCompileVar *)instruction);
break;
case IrInstructionIdSizeOf:
ir_print_size_of(irp, (IrInstructionSizeOf *)instruction);
break;

4
src/main.cpp
View File

@ -263,8 +263,8 @@ int main(int argc, char **argv) {
return 1;
}
PackageTableEntry *build_pkg = new_package(buf_ptr(&build_file_dirname), buf_ptr(&build_file_basename));
build_pkg->package_table.put(buf_create_from_str("std"), g->std_package);
PackageTableEntry *build_pkg = codegen_create_package(g, buf_ptr(&build_file_dirname),
buf_ptr(&build_file_basename));
g->root_package->package_table.put(buf_create_from_str("@build"), build_pkg);
codegen_build(g);
codegen_link(g, buf_ptr(path_to_build_exe));

23
std/build.zig
View File

@ -1,3 +1,4 @@
const builtin = @import("builtin");
const io = @import("io.zig");
const mem = @import("mem.zig");
const debug = @import("debug.zig");
@ -625,9 +626,9 @@ const Version = struct {
};
const CrossTarget = struct {
arch: Arch,
os: Os,
environ: Environ,
arch: builtin.Arch,
os: builtin.Os,
environ: builtin.Environ,
};
const Target = enum {
@ -636,22 +637,22 @@ const Target = enum {
pub fn oFileExt(self: &const Target) -> []const u8 {
const environ = switch (*self) {
Target.Native => @compileVar("environ"),
Target.Native => builtin.environ,
Target.Cross => |t| t.environ,
};
return switch (environ) {
Environ.msvc => ".obj",
builtin.Environ.msvc => ".obj",
else => ".o",
};
}
pub fn exeFileExt(self: &const Target) -> []const u8 {
const target_os = switch (*self) {
Target.Native => @compileVar("os"),
Target.Native => builtin.os,
Target.Cross => |t| t.os,
};
return switch (target_os) {
Os.windows => ".exe",
builtin.Os.windows => ".exe",
else => "",
};
}
@ -761,7 +762,9 @@ pub const LibExeObjStep = struct {
}
}
pub fn setTarget(self: &LibExeObjStep, target_arch: Arch, target_os: Os, target_environ: Environ) {
pub fn setTarget(self: &LibExeObjStep, target_arch: builtin.Arch, target_os: builtin.Os,
target_environ: builtin.Environ)
{
self.target = Target.Cross {
CrossTarget {
.arch = target_arch,
@ -1392,7 +1395,9 @@ pub const CLibExeObjStep = struct {
}
}
pub fn setTarget(self: &CLibExeObjStep, target_arch: Arch, target_os: Os, target_environ: Environ) {
pub fn setTarget(self: &CLibExeObjStep, target_arch: builtin.Arch, target_os: builtin.Os,
target_environ: builtin.Environ)
{
self.target = Target.Cross {
CrossTarget {
.arch = target_arch,

4
std/c/index.zig
View File

@ -1,6 +1,8 @@
pub use @import("../os/errno.zig");
const builtin = @import("builtin");
const Os = builtin.Os;
pub use switch(@compileVar("os")) {
pub use switch(builtin.os) {
Os.linux => @import("linux.zig"),
Os.windows => @import("windows.zig"),
Os.darwin, Os.macosx, Os.ios => @import("darwin.zig"),

11
std/debug.zig
View File

@ -4,6 +4,7 @@ const os = @import("os/index.zig");
const elf = @import("elf.zig");
const DW = @import("dwarf.zig");
const List = @import("list.zig").List;
const builtin = @import("builtin");
error MissingDebugInfo;
error InvalidDebugInfo;
@ -50,8 +51,8 @@ pub var user_main_fn: ?fn() -> %void = null;
pub fn writeStackTrace(out_stream: &io.OutStream, allocator: &mem.Allocator, tty_color: bool,
ignore_frame_count: usize) -> %void
{
switch (@compileVar("object_format")) {
ObjectFormat.elf => {
switch (builtin.object_format) {
builtin.ObjectFormat.elf => {
var stack_trace = ElfStackTrace {
.self_exe_stream = undefined,
.elf = undefined,
@ -125,13 +126,13 @@ pub fn writeStackTrace(out_stream: &io.OutStream, allocator: &mem.Allocator, tty
%return out_stream.flush();
}
},
ObjectFormat.coff => {
builtin.ObjectFormat.coff => {
%return out_stream.write("(stack trace unavailable for COFF object format)\n");
},
ObjectFormat.macho => {
builtin.ObjectFormat.macho => {
%return out_stream.write("(stack trace unavailable for Mach-O object format)\n");
},
ObjectFormat.unknown => {
builtin.ObjectFormat.unknown => {
%return out_stream.write("(stack trace unavailable for unknown object format)\n");
},
}

24
std/elf.zig
View File

@ -36,9 +36,7 @@ pub const FileType = enum {
Core,
};
// TODO rename this to Arch when the builtin Arch enum is namespaced
// or make debug info work for builtin enums
pub const ElfArch = enum {
pub const Arch = enum {
Sparc,
x86,
Mips,
@ -69,7 +67,7 @@ pub const Elf = struct {
is_64: bool,
is_big_endian: bool,
file_type: FileType,
arch: ElfArch,
arch: Arch,
entry_addr: u64,
program_header_offset: u64,
section_header_offset: u64,
@ -123,15 +121,15 @@ pub const Elf = struct {
};
elf.arch = switch (%return elf.in_stream.readInt(elf.is_big_endian, u16)) {
0x02 => ElfArch.Sparc,
0x03 => ElfArch.x86,
0x08 => ElfArch.Mips,
0x14 => ElfArch.PowerPc,
0x28 => ElfArch.Arm,
0x2A => ElfArch.SuperH,
0x32 => ElfArch.IA_64,
0x3E => ElfArch.x86_64,
0xb7 => ElfArch.AArch64,
0x02 => Arch.Sparc,
0x03 => Arch.x86,
0x08 => Arch.Mips,
0x14 => Arch.PowerPc,
0x28 => Arch.Arm,
0x2A => Arch.SuperH,
0x32 => Arch.IA_64,
0x3E => Arch.x86_64,
0xb7 => Arch.AArch64,
else => return error.InvalidFormat,
};

3
std/endian.zig
View File

@ -1,4 +1,5 @@
const mem = @import("mem.zig");
const builtin = @import("builtin");
pub fn swapIfLe(comptime T: type, x: T) -> T {
swapIf(false, T, x)
@ -9,7 +10,7 @@ pub fn swapIfBe(comptime T: type, x: T) -> T {
}
pub fn swapIf(is_be: bool, comptime T: type, x: T) -> T {
if (@compileVar("is_big_endian") == is_be) swap(T, x) else x
if (builtin.is_big_endian == is_be) swap(T, x) else x
}
pub fn swap(comptime T: type, x: T) -> T {

3
std/hash_map.zig
View File

@ -3,8 +3,9 @@ const assert = debug.assert;
const math = @import("math.zig");
const mem = @import("mem.zig");
const Allocator = mem.Allocator;
const builtin = @import("builtin");
const want_modification_safety = !@compileVar("is_release");
const want_modification_safety = !builtin.is_release;
const debug_u32 = if (want_modification_safety) u32 else void;
pub fn HashMap(comptime K: type, comptime V: type,

20
std/io.zig
View File

@ -1,4 +1,6 @@
const system = switch(@compileVar("os")) {
const builtin = @import("builtin");
const Os = builtin.Os;
const system = switch(builtin.os) {
Os.linux => @import("os/linux.zig"),
Os.darwin => @import("os/darwin.zig"),
else => @compileError("Unsupported OS"),
@ -79,7 +81,7 @@ pub const OutStream = struct {
/// otherwise if the fixed size buffer is too small, allocator is used to obtain the needed memory.
/// Call close to clean up.
pub fn openMode(path: []const u8, mode: usize, allocator: ?&mem.Allocator) -> %OutStream {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin, Os.macosx, Os.ios => {
const flags = system.O_LARGEFILE|system.O_WRONLY|system.O_CREAT|system.O_CLOEXEC|system.O_TRUNC;
const fd = %return os.posixOpen(path, flags, mode, allocator);
@ -176,7 +178,7 @@ pub const InStream = struct {
/// otherwise if the fixed size buffer is too small, allocator is used to obtain the needed memory.
/// Call close to clean up.
pub fn open(path: []const u8, allocator: ?&mem.Allocator) -> %InStream {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin, Os.macosx, Os.ios => {
const flags = system.O_LARGEFILE|system.O_RDONLY;
const fd = %return os.posixOpen(path, flags, 0, allocator);
@ -191,7 +193,7 @@ pub const InStream = struct {
/// Upon success, the stream is in an uninitialized state. To continue using it,
/// you must use the open() function.
pub fn close(self: &InStream) {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin, Os.macosx, Os.ios => {
os.posixClose(self.fd);
},
@ -202,7 +204,7 @@ pub const InStream = struct {
/// Returns the number of bytes read. If the number read is smaller than buf.len, then
/// the stream reached End Of File.
pub fn read(is: &InStream, buf: []u8) -> %usize {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin => {
var index: usize = 0;
while (index < buf.len) {
@ -268,7 +270,7 @@ pub const InStream = struct {
}
pub fn seekForward(is: &InStream, amount: usize) -> %void {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin => {
const result = system.lseek(is.fd, amount, system.SEEK_CUR);
const err = system.getErrno(result);
@ -288,7 +290,7 @@ pub const InStream = struct {
}
pub fn seekTo(is: &InStream, pos: usize) -> %void {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin => {
const result = system.lseek(is.fd, pos, system.SEEK_SET);
const err = system.getErrno(result);
@ -308,7 +310,7 @@ pub const InStream = struct {
}
pub fn getPos(is: &InStream) -> %usize {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin => {
const result = system.lseek(is.fd, 0, system.SEEK_CUR);
const err = system.getErrno(result);
@ -365,7 +367,7 @@ pub const InStream = struct {
};
pub fn openSelfExe() -> %InStream {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux => {
return InStream.open("/proc/self/exe", null);
},

4
std/mem.zig
View File

@ -2,6 +2,8 @@ const assert = @import("debug.zig").assert;
const math = @import("math.zig");
const os = @import("os/index.zig");
const io = @import("io.zig");
const builtin = @import("builtin");
const Os = builtin.Os;
pub const Cmp = math.Cmp;
@ -53,7 +55,7 @@ pub const IncrementingAllocator = struct {
end_index: usize,
fn init(capacity: usize) -> %IncrementingAllocator {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin, Os.macosx, Os.ios => {
const p = os.posix;
const addr = p.mmap(null, capacity, p.PROT_READ|p.PROT_WRITE,

4
std/os/child_process.zig
View File

@ -7,6 +7,8 @@ const errno = @import("errno.zig");
const debug = @import("../debug.zig");
const assert = debug.assert;
const BufMap = @import("../buf_map.zig").BufMap;
const builtin = @import("builtin");
const Os = builtin.Os;
pub const ChildProcess = struct {
pid: i32,
@ -34,7 +36,7 @@ pub const ChildProcess = struct {
cwd: ?[]const u8, env_map: &const BufMap,
stdin: StdIo, stdout: StdIo, stderr: StdIo, allocator: &Allocator) -> %ChildProcess
{
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.macosx, Os.ios, Os.darwin => {
return spawnPosix(exe_path, args, cwd, env_map, stdin, stdout, stderr, allocator);
},

5
std/os/darwin.zig
View File

@ -1,6 +1,7 @@
const arch = switch (@compileVar("arch")) {
Arch.x86_64 => @import("darwin_x86_64.zig"),
const builtin = @import("builtin");
const arch = switch (builtin.arch) {
builtin.Arch.x86_64 => @import("darwin_x86_64.zig"),
else => @compileError("unsupported arch"),
};

10
std/os/index.zig
View File

@ -1,7 +1,9 @@
const builtin = @import("builtin");
const Os = builtin.Os;
pub const windows = @import("windows.zig");
pub const darwin = @import("darwin.zig");
pub const linux = @import("linux.zig");
pub const posix = switch(@compileVar("os")) {
pub const posix = switch(builtin.os) {
Os.linux => linux,
Os.darwin, Os.macosx, Os.ios => darwin,
Os.windows => windows,
@ -12,7 +14,7 @@ pub const max_noalloc_path_len = 1024;
pub const ChildProcess = @import("child_process.zig").ChildProcess;
pub const path = @import("path.zig");
pub const line_sep = switch (@compileVar("os")) {
pub const line_sep = switch (builtin.os) {
Os.windows => "\r\n",
else => "\n",
};
@ -56,7 +58,7 @@ error DirNotEmpty;
/// library implementation.
pub fn getRandomBytes(buf: []u8) -> %void {
while (true) {
const err = switch (@compileVar("os")) {
const err = switch (builtin.os) {
Os.linux => {
if (linking_libc) {
if (c.getrandom(buf.ptr, buf.len, 0) == -1) *c._errno() else 0
@ -104,7 +106,7 @@ pub coldcc fn abort() -> noreturn {
if (linking_libc) {
c.abort();
}
switch (@compileVar("os")) {
switch (builtin.os) {
Os.linux, Os.darwin, Os.macosx, Os.ios => {
_ = posix.raise(posix.SIGABRT);
_ = posix.raise(posix.SIGKILL);

7
std/os/linux.zig
View File

@ -1,6 +1,7 @@
const arch = switch (@compileVar("arch")) {
Arch.x86_64 => @import("linux_x86_64.zig"),
Arch.i386 => @import("linux_i386.zig"),
const builtin = @import("builtin");
const arch = switch (builtin.arch) {
builtin.Arch.x86_64 => @import("linux_x86_64.zig"),
builtin.Arch.i386 => @import("linux_i386.zig"),
else => @compileError("unsupported arch"),
};
const errno = @import("errno.zig");

8
std/os/path.zig
View File

@ -1,3 +1,5 @@
const builtin = @import("builtin");
const Os = builtin.Os;
const debug = @import("../debug.zig");
const assert = debug.assert;
const mem = @import("../mem.zig");
@ -7,11 +9,11 @@ const os = @import("index.zig");
const math = @import("../math.zig");
const posix = os.posix;
pub const sep = switch (@compileVar("os")) {
pub const sep = switch (builtin.os) {
Os.windows => '\\',
else => '/',
};
pub const delimiter = switch (@compileVar("os")) {
pub const delimiter = switch (builtin.os) {
Os.windows => ';',
else => ':',
};
@ -61,7 +63,7 @@ test "os.path.join" {
}
pub fn isAbsolute(path: []const u8) -> bool {
switch (@compileVar("os")) {
switch (builtin.os) {
Os.windows => @compileError("Unsupported OS"),
else => return path[0] == sep,
}

11
std/special/bootstrap.zig
View File

@ -3,6 +3,7 @@
const root = @import("@root");
const std = @import("std");
const builtin = @import("builtin");
const want_main_symbol = std.target.linking_libc;
const want_start_symbol = !want_main_symbol;
@ -13,15 +14,15 @@ var argc_ptr: &usize = undefined;
export nakedcc fn _start() -> noreturn {
if (!want_start_symbol) {
@setGlobalLinkage(_start, GlobalLinkage.Internal);
@setGlobalLinkage(_start, builtin.GlobalLinkage.Internal);
unreachable;
}
switch (@compileVar("arch")) {
Arch.x86_64 => {
switch (builtin.arch) {
builtin.Arch.x86_64 => {
argc_ptr = asm("lea (%%rsp), %[argc]": [argc] "=r" (-> &usize));
},
Arch.i386 => {
builtin.Arch.i386 => {
argc_ptr = asm("lea (%%esp), %[argc]": [argc] "=r" (-> &usize));
},
else => @compileError("unsupported arch"),
@ -51,7 +52,7 @@ fn callMain(argc: usize, argv: &&u8, envp: &?&u8) -> %void {
export fn main(c_argc: i32, c_argv: &&u8, c_envp: &?&u8) -> i32 {
if (!want_main_symbol) {
@setGlobalLinkage(main, GlobalLinkage.Internal);
@setGlobalLinkage(main, builtin.GlobalLinkage.Internal);
unreachable;
}

44
std/special/compiler_rt.zig
View File

@ -1,3 +1,5 @@
const builtin = @import("builtin");
const CHAR_BIT = 8;
const du_int = u64;
const di_int = i64;
@ -5,7 +7,7 @@ const si_int = c_int;
const su_int = c_uint;
const udwords = [2]su_int;
const low = if (@compileVar("is_big_endian")) 1 else 0;
const low = if (builtin.is_big_endian) 1 else 0;
const high = 1 - low;
export fn __udivdi3(a: du_int, b: du_int) -> du_int {
@ -213,25 +215,25 @@ export fn __umoddi3(a: du_int, b: du_int) -> du_int {
}
fn isArmArch() -> bool {
return switch (@compileVar("arch")) {
Arch.armv8_2a,
Arch.armv8_1a,
Arch.armv8,
Arch.armv8m_baseline,
Arch.armv8m_mainline,
Arch.armv7,
Arch.armv7em,
Arch.armv7m,
Arch.armv7s,
Arch.armv7k,
Arch.armv6,
Arch.armv6m,
Arch.armv6k,
Arch.armv6t2,
Arch.armv5,
Arch.armv5te,
Arch.armv4t,
Arch.armeb => true,
return switch (builtin.arch) {
builtin.Arch.armv8_2a,
builtin.Arch.armv8_1a,
builtin.Arch.armv8,
builtin.Arch.armv8m_baseline,
builtin.Arch.armv8m_mainline,
builtin.Arch.armv7,
builtin.Arch.armv7em,
builtin.Arch.armv7m,
builtin.Arch.armv7s,
builtin.Arch.armv7k,
builtin.Arch.armv6,
builtin.Arch.armv6m,
builtin.Arch.armv6k,
builtin.Arch.armv6t2,
builtin.Arch.armv5,
builtin.Arch.armv5te,
builtin.Arch.armv4t,
builtin.Arch.armeb => true,
else => false,
};
}
@ -252,7 +254,7 @@ export nakedcc fn __aeabi_uidivmod() {
unreachable;
}
@setGlobalLinkage(__aeabi_uidivmod, GlobalLinkage.Internal);
@setGlobalLinkage(__aeabi_uidivmod, builtin.GlobalLinkage.Internal);
}
export fn __udivmodsi4(a: su_int, b: su_int, rem: &su_int) -> su_int {

3
std/special/test_runner.zig
View File

@ -1,5 +1,6 @@
const io = @import("std").io;
const test_fn_list = @compileVar("zig_test_fn_slice");
const builtin = @import("builtin");
const test_fn_list = builtin.__zig_test_fn_slice;
pub fn main() -> %void {
for (test_fn_list) |test_fn, i| {

8
std/special/zigrt.zig
View File

@ -2,13 +2,15 @@
// multiple .o files. The symbols are defined Weak so that multiple
// instances of zig_rt.zig do not conflict with each other.
const builtin = @import("builtin");
export coldcc fn __zig_panic(message_ptr: &const u8, message_len: usize) -> noreturn {
@setGlobalLinkage(__zig_panic, GlobalLinkage.Weak);
@setGlobalLinkage(__zig_panic, builtin.GlobalLinkage.Weak);
@setDebugSafety(this, false);
if (@compileVar("panic_implementation_provided")) {
if (builtin.__zig_panic_implementation_provided) {
@import("@root").panic(message_ptr[0...message_len]);
} else if (@compileVar("os") == Os.freestanding) {
} else if (builtin.os == builtin.Os.freestanding) {
while (true) {}
} else {
@import("std").debug.panic("{}", message_ptr[0...message_len]);

5
std/target.zig
View File

@ -1,11 +1,12 @@
const mem = @import("mem.zig");
const builtin = @import("builtin");
pub const linking_libc = linkingLibrary("c");
pub fn linkingLibrary(lib_name: []const u8) -> bool {
// TODO shouldn't need this if
if (@compileVar("link_libs").len != 0) {
for (@compileVar("link_libs")) |link_lib| {
if (builtin.link_libs.len != 0) {
for (builtin.link_libs) |link_lib| {
if (mem.eql(u8, link_lib, lib_name)) {
return true;
}

3
test/assemble_and_link.zig
View File

@ -1,7 +1,8 @@
const builtin = @import("builtin");
const tests = @import("tests.zig");
pub fn addCases(cases: &tests.CompareOutputContext) {
if (@compileVar("os") == Os.linux and @compileVar("arch") == Arch.x86_64) {
if (builtin.os == builtin.Os.linux and builtin.arch == builtin.Arch.x86_64) {
cases.addAsm("hello world linux x86_64",
\\.text
\\.globl _start

5
test/cases/asm.zig
View File

@ -1,7 +1,8 @@
const config = @import("builtin");
const assert = @import("std").debug.assert;
comptime {
if (@compileVar("arch") == Arch.x86_64) {
if (config.arch == config.Arch.x86_64) {
asm volatile (
\\.globl aoeu;
\\.type aoeu, @function;
@ -11,7 +12,7 @@ comptime {
}
test "module level assembly" {
if (@compileVar("arch") == Arch.x86_64) {
if (config.arch == config.Arch.x86_64) {
assert(aoeu() == 1234);
}
}

1
test/cases/atomics.zig
View File

@ -1,4 +1,5 @@
const assert = @import("std").debug.assert;
const AtomicOrder = @import("builtin").AtomicOrder;
test "cmpxchg" {
var x: i32 = 1234;

3
test/cases/misc.zig
View File

@ -1,6 +1,7 @@
const assert = @import("std").debug.assert;
const mem = @import("std").mem;
const cstr = @import("std").cstr;
const builtin = @import("builtin");
// normal comment
/// this is a documentation comment
@ -12,7 +13,7 @@ test "emptyFunctionWithComments" {
}
export fn disabledExternFn() {
@setGlobalLinkage(disabledExternFn, GlobalLinkage.Internal);
@setGlobalLinkage(disabledExternFn, builtin.GlobalLinkage.Internal);
}
test "callDisabledExternFn" {

5
test/cases/namespace_depends_on_compile_var/index.zig
View File

@ -1,3 +1,4 @@
const builtin = @import("builtin");
const assert = @import("std").debug.assert;
test "namespaceDependsOnCompileVar" {
@ -7,7 +8,7 @@ test "namespaceDependsOnCompileVar" {
assert(!some_namespace.a_bool);
}
}
const some_namespace = switch(@compileVar("os")) {
Os.linux => @import("a.zig"),
const some_namespace = switch(builtin.os) {
builtin.Os.linux => @import("a.zig"),
else => @import("b.zig"),
};

15
test/compile_errors.zig
View File

@ -688,9 +688,9 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
cases.add("bogus compile var",
\\const x = @compileVar("bogus");
\\const x = @import("builtin").bogus;
\\export fn entry() -> usize { @sizeOf(@typeOf(x)) }
, ".tmp_source.zig:1:23: error: unrecognized compile variable: 'bogus'");
, ".tmp_source.zig:1:29: error: no member named 'bogus' in '");
cases.add("non constant expression in array size outside function",
@ -910,18 +910,20 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
, ".tmp_source.zig:2:15: error: unable to infer expression type");
cases.add("atomic orderings of cmpxchg - failure stricter than success",
\\const AtomicOrder = @import("builtin").AtomicOrder;
\\export fn f() {
\\ var x: i32 = 1234;
\\ while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}
\\}
, ".tmp_source.zig:3:72: error: failure atomic ordering must be no stricter than success");
, ".tmp_source.zig:4:72: error: failure atomic ordering must be no stricter than success");
cases.add("atomic orderings of cmpxchg - success Monotonic or stricter",
\\const AtomicOrder = @import("builtin").AtomicOrder;
\\export fn f() {
\\ var x: i32 = 1234;
\\ while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}
\\}
, ".tmp_source.zig:3:49: error: success atomic ordering must be Monotonic or stricter");
, ".tmp_source.zig:4:49: error: success atomic ordering must be Monotonic or stricter");
cases.add("negation overflow in function evaluation",
\\const y = neg(-128);
@ -1487,10 +1489,11 @@ pub fn addCases(cases: &tests.CompileErrorContext) {
, ".tmp_source.zig:6:5: error: unable to evaluate constant expression");
cases.add("invalid member of builtin enum",
\\const builtin = @import("builtin");
\\export fn entry() {
\\ const foo = Arch.x86;
\\ const foo = builtin.Arch.x86;
\\}
, ".tmp_source.zig:2:21: error: container 'Arch' has no member called 'x86'");
, ".tmp_source.zig:3:29: error: container 'Arch' has no member called 'x86'");
cases.add("int to ptr of 0 bits",
\\export fn foo() {