Updates and cleanup in self hosted compiler

build.zig

@@ -54,6 +54,7 @@ pub fn build(b: *Builder) !void {
 
     var test_stage2 = b.addTest("src-self-hosted/test.zig");
     test_stage2.setBuildMode(builtin.Mode.Debug);
+    test_stage2.addPackagePath("stage2_tests", "test/stage2/test.zig");
 
     const fmt_build_zig = b.addFmt([_][]const u8{"build.zig"});
 
@@ -72,9 +73,9 @@ pub fn build(b: *Builder) !void {
     const skip_non_native = b.option(bool, "skip-non-native", "Main test suite skips non-native builds") orelse false;
     const skip_libc = b.option(bool, "skip-libc", "Main test suite skips tests that link libc") orelse false;
     const skip_self_hosted = b.option(bool, "skip-self-hosted", "Main test suite skips building self hosted compiler") orelse false;
-    if (!skip_self_hosted) {
-        // TODO re-enable this after https://github.com/ziglang/zig/issues/2377
-        //test_step.dependOn(&exe.step);
+    if (!skip_self_hosted and builtin.os == .linux) {
+        // TODO evented I/O other OS's
+        test_step.dependOn(&exe.step);
     }
 
     const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
@@ -98,11 +99,7 @@ pub fn build(b: *Builder) !void {
 
     const test_stage2_step = b.step("test-stage2", "Run the stage2 compiler tests");
     test_stage2_step.dependOn(&test_stage2.step);
-
-    // TODO see https://github.com/ziglang/zig/issues/1364
-    if (false) {
-        test_step.dependOn(test_stage2_step);
-    }
+    test_step.dependOn(test_stage2_step);
 
     var chosen_modes: [4]builtin.Mode = undefined;
     var chosen_mode_index: usize = 0;
@@ -235,6 +232,9 @@ fn findLLVM(b: *Builder, llvm_config_exe: []const u8) !LibraryDep {
                 if (fs.path.isAbsolute(lib_arg)) {
                     try result.libs.append(lib_arg);
                 } else {
+                    if (mem.endsWith(u8, lib_arg, ".lib")) {
+                        lib_arg = lib_arg[0 .. lib_arg.len - 4];
+                    }
                     try result.system_libs.append(lib_arg);
                 }
             }

lib/std/child_process.zig

@@ -259,7 +259,9 @@ pub const ChildProcess = struct {
     }
 
     fn handleWaitResult(self: *ChildProcess, status: u32) void {
-        self.term = self.cleanupAfterWait(status);
+        // TODO https://github.com/ziglang/zig/issues/3190 
+        var term = self.cleanupAfterWait(status);
+        self.term = term;
     }
 
     fn cleanupStreams(self: *ChildProcess) void {

lib/std/event/group.zig

@@ -66,11 +66,10 @@ pub fn Group(comptime ReturnType: type) type {
             node.* = AllocStack.Node{
                 .next = undefined,
                 .data = Node{
-                    .handle = frame,
+                    .handle = @asyncCall(frame, {}, func, args),
                     .bytes = std.mem.asBytes(frame),
                 },
             };
-            _ = @asyncCall(frame, {}, func, args);
             self.alloc_stack.push(node);
         }
 

src-self-hosted/arg.zig

@@ -119,9 +119,9 @@ pub const Args = struct {
 
                             // MergeN creation disallows 0 length flag entry (doesn't make sense)
                             switch (flag_args) {
-                                FlagArg.None => unreachable,
-                                FlagArg.Single => |inner| try prev.append(inner),
-                                FlagArg.Many => |inner| try prev.appendSlice(inner.toSliceConst()),
+                                .None => unreachable,
+                                .Single => |inner| try prev.append(inner),
+                                .Many => |inner| try prev.appendSlice(inner.toSliceConst()),
                             }
 
                             _ = try parsed.flags.put(flag_name_trimmed, FlagArg{ .Many = prev });
@@ -158,7 +158,7 @@ pub const Args = struct {
     pub fn single(self: *Args, name: []const u8) ?[]const u8 {
         if (self.flags.get(name)) |entry| {
             switch (entry.value) {
-                FlagArg.Single => |inner| {
+                .Single => |inner| {
                     return inner;
                 },
                 else => @panic("attempted to retrieve flag with wrong type"),
@@ -172,7 +172,7 @@ pub const Args = struct {
     pub fn many(self: *Args, name: []const u8) []const []const u8 {
         if (self.flags.get(name)) |entry| {
             switch (entry.value) {
-                FlagArg.Many => |inner| {
+                .Many => |inner| {
                     return inner.toSliceConst();
                 },
                 else => @panic("attempted to retrieve flag with wrong type"),

src-self-hosted/c_int.zig

@@ -1,3 +1,5 @@
+const Target = @import("std").Target;
+
 pub const CInt = struct {
     id: Id,
     zig_name: []const u8,
@@ -17,52 +19,152 @@ pub const CInt = struct {
 
     pub const list = [_]CInt{
         CInt{
-            .id = Id.Short,
+            .id = .Short,
             .zig_name = "c_short",
             .c_name = "short",
             .is_signed = true,
         },
         CInt{
-            .id = Id.UShort,
+            .id = .UShort,
             .zig_name = "c_ushort",
             .c_name = "unsigned short",
             .is_signed = false,
         },
         CInt{
-            .id = Id.Int,
+            .id = .Int,
             .zig_name = "c_int",
             .c_name = "int",
             .is_signed = true,
         },
         CInt{
-            .id = Id.UInt,
+            .id = .UInt,
             .zig_name = "c_uint",
             .c_name = "unsigned int",
             .is_signed = false,
         },
         CInt{
-            .id = Id.Long,
+            .id = .Long,
             .zig_name = "c_long",
             .c_name = "long",
             .is_signed = true,
         },
         CInt{
-            .id = Id.ULong,
+            .id = .ULong,
             .zig_name = "c_ulong",
             .c_name = "unsigned long",
             .is_signed = false,
         },
         CInt{
-            .id = Id.LongLong,
+            .id = .LongLong,
             .zig_name = "c_longlong",
             .c_name = "long long",
             .is_signed = true,
         },
         CInt{
-            .id = Id.ULongLong,
+            .id = .ULongLong,
             .zig_name = "c_ulonglong",
             .c_name = "unsigned long long",
             .is_signed = false,
         },
     };
+
+    pub fn sizeInBits(cint: CInt, self: Target) u32 {
+        const arch = self.getArch();
+        switch (self.getOs()) {
+            .freestanding => switch (self.getArch()) {
+                .msp430 => switch (cint.id) {
+                    .Short,
+                    .UShort,
+                    .Int,
+                    .UInt,
+                    => return 16,
+                    .Long,
+                    .ULong,
+                    => return 32,
+                    .LongLong,
+                    .ULongLong,
+                    => return 64,
+                },
+                else => switch (cint.id) {
+                    .Short,
+                    .UShort,
+                    => return 16,
+                    .Int,
+                    .UInt,
+                    => return 32,
+                    .Long,
+                    .ULong,
+                    => return self.getArchPtrBitWidth(),
+                    .LongLong,
+                    .ULongLong,
+                    => return 64,
+                },
+            },
+
+            .linux,
+            .macosx,
+            .freebsd,
+            .openbsd,
+            .zen,
+            => switch (cint.id) {
+                .Short,
+                .UShort,
+                => return 16,
+                .Int,
+                .UInt,
+                => return 32,
+                .Long,
+                .ULong,
+                => return self.getArchPtrBitWidth(),
+                .LongLong,
+                .ULongLong,
+                => return 64,
+            },
+
+            .windows, .uefi => switch (cint.id) {
+                .Short,
+                .UShort,
+                => return 16,
+                .Int,
+                .UInt,
+                => return 32,
+                .Long,
+                .ULong,
+                .LongLong,
+                .ULongLong,
+                => return 64,
+            },
+
+            .ananas,
+            .cloudabi,
+            .dragonfly,
+            .fuchsia,
+            .ios,
+            .kfreebsd,
+            .lv2,
+            .netbsd,
+            .solaris,
+            .haiku,
+            .minix,
+            .rtems,
+            .nacl,
+            .cnk,
+            .aix,
+            .cuda,
+            .nvcl,
+            .amdhsa,
+            .ps4,
+            .elfiamcu,
+            .tvos,
+            .watchos,
+            .mesa3d,
+            .contiki,
+            .amdpal,
+            .hermit,
+            .hurd,
+            .wasi,
+            .emscripten,
+            => @panic("TODO specify the C integer type sizes for this OS"),
+        }
+    }
 };

src-self-hosted/codegen.zig

@@ -1,23 +1,23 @@
 const std = @import("std");
-const builtin = @import("builtin");
 const Compilation = @import("compilation.zig").Compilation;
 const llvm = @import("llvm.zig");
 const c = @import("c.zig");
 const ir = @import("ir.zig");
 const Value = @import("value.zig").Value;
 const Type = @import("type.zig").Type;
 const Scope = @import("scope.zig").Scope;
+const util = @import("util.zig");
 const event = std.event;
 const assert = std.debug.assert;
 const DW = std.dwarf;
 const maxInt = std.math.maxInt;
 
-pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code) !void {
+pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code) Compilation.BuildError!void {
     fn_val.base.ref();
     defer fn_val.base.deref(comp);
     defer code.destroy(comp.gpa());
 
-    var output_path = try await (async comp.createRandomOutputPath(comp.target.objFileExt()) catch unreachable);
+    var output_path = try comp.createRandomOutputPath(comp.target.oFileExt());
     errdefer output_path.deinit();
 
     const llvm_handle = try comp.zig_compiler.getAnyLlvmContext();
@@ -31,7 +31,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
     llvm.SetTarget(module, comp.llvm_triple.ptr());
     llvm.SetDataLayout(module, comp.target_layout_str);
 
-    if (comp.target.getObjectFormat() == builtin.ObjectFormat.coff) {
+    if (util.getObjectFormat(comp.target) == .coff) {
         llvm.AddModuleCodeViewFlag(module);
     } else {
         llvm.AddModuleDebugInfoFlag(module);
@@ -59,7 +59,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
         comp.name.ptr(),
         comp.root_package.root_src_dir.ptr(),
     ) orelse return error.OutOfMemory;
-    const is_optimized = comp.build_mode != builtin.Mode.Debug;
+    const is_optimized = comp.build_mode != .Debug;
     const compile_unit = llvm.CreateCompileUnit(
         dibuilder,
         DW.LANG_C99,
@@ -79,7 +79,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
         .builder = builder,
         .dibuilder = dibuilder,
         .context = context,
-        .lock = event.Lock.init(comp.loop),
+        .lock = event.Lock.init(),
         .arena = &code.arena.allocator,
     };
 
@@ -105,8 +105,8 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
 
     assert(comp.emit_file_type == Compilation.Emit.Binary); // TODO support other types
 
-    const is_small = comp.build_mode == builtin.Mode.ReleaseSmall;
-    const is_debug = comp.build_mode == builtin.Mode.Debug;
+    const is_small = comp.build_mode == .ReleaseSmall;
+    const is_debug = comp.build_mode == .Debug;
 
     var err_msg: [*]u8 = undefined;
     // TODO integrate this with evented I/O
@@ -234,8 +234,8 @@ pub fn renderToLlvmModule(ofile: *ObjectFile, fn_val: *Value.Fn, code: *ir.Code)
     // create debug variable declarations for variables and allocate all local variables
     for (var_list) |var_scope, i| {
         const var_type = switch (var_scope.data) {
-            Scope.Var.Data.Const => unreachable,
-            Scope.Var.Data.Param => |param| param.typ,
+            .Const => unreachable,
+            .Param => |param| param.typ,
         };
         //    if (!type_has_bits(var->value->type)) {
         //        continue;
@@ -266,7 +266,7 @@ pub fn renderToLlvmModule(ofile: *ObjectFile, fn_val: *Value.Fn, code: *ir.Code)
             var_scope.data.Param.llvm_value = llvm.GetParam(llvm_fn, @intCast(c_uint, i));
         } else {
             //            gen_type = var->value->type;
-            var_scope.data.Param.llvm_value = try renderAlloca(ofile, var_type, var_scope.name, Type.Pointer.Align.Abi);
+            var_scope.data.Param.llvm_value = try renderAlloca(ofile, var_type, var_scope.name, .Abi);
         }
         //        if (var->decl_node) {
         //            var->di_loc_var = ZigLLVMCreateParameterVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
@@ -300,8 +300,8 @@ pub fn renderToLlvmModule(ofile: *ObjectFile, fn_val: *Value.Fn, code: *ir.Code)
                 ofile,
                 llvm_param,
                 scope_var.data.Param.llvm_value,
-                Type.Pointer.Align.Abi,
-                Type.Pointer.Vol.Non,
+                .Abi,
+                .Non,
             );
         }
 
@@ -383,8 +383,8 @@ fn renderLoadUntyped(
 ) !*llvm.Value {
     const result = llvm.BuildLoad(ofile.builder, ptr, name) orelse return error.OutOfMemory;
     switch (vol) {
-        Type.Pointer.Vol.Non => {},
-        Type.Pointer.Vol.Volatile => llvm.SetVolatile(result, 1),
+        .Non => {},
+        .Volatile => llvm.SetVolatile(result, 1),
     }
     llvm.SetAlignment(result, resolveAlign(ofile, alignment, llvm.GetElementType(llvm.TypeOf(ptr))));
     return result;
@@ -414,8 +414,8 @@ pub fn renderStoreUntyped(
 ) !*llvm.Value {
     const result = llvm.BuildStore(ofile.builder, value, ptr) orelse return error.OutOfMemory;
     switch (vol) {
-        Type.Pointer.Vol.Non => {},
-        Type.Pointer.Vol.Volatile => llvm.SetVolatile(result, 1),
+        .Non => {},
+        .Volatile => llvm.SetVolatile(result, 1),
     }
     llvm.SetAlignment(result, resolveAlign(ofile, alignment, llvm.TypeOf(value)));
     return result;
@@ -445,7 +445,7 @@ pub fn renderAlloca(
 
 pub fn resolveAlign(ofile: *ObjectFile, alignment: Type.Pointer.Align, llvm_type: *llvm.Type) u32 {
     return switch (alignment) {
-        Type.Pointer.Align.Abi => return llvm.ABIAlignmentOfType(ofile.comp.target_data_ref, llvm_type),
-        Type.Pointer.Align.Override => |a| a,
+        .Abi => return llvm.ABIAlignmentOfType(ofile.comp.target_data_ref, llvm_type),
+        .Override => |a| a,
     };
 }