- Temporary backport of aro and translate-c (drop this commit)

Author: kcbanner

lib/compiler/aro/aro/Compilation.zig

@@ -263,6 +263,11 @@ fn generateSystemDefines(comp: *Compilation, w: *std.Io.Writer) !void {
     };
     try w.print("#define __ARO_EMULATE__ {s}\n", .{emulated});
 
+    if (comp.langopts.emulate == .msvc) {
+        try w.writeAll("#define _MSC_VER 1933\n");
+        try w.writeAll("#define _MSC_FULL_VER 193300000\n");
+    }
+
     if (comp.code_gen_options.optimization_level.hasAnyOptimizations()) {
         try define(w, "__OPTIMIZE__");
     }
@@ -1663,13 +1668,11 @@ const FindInclude = struct {
             only_search_after_dir: []const u8,
         },
     ) Allocator.Error!?Result {
-        var wait_for: ?[]u8 = null;
         var find: FindInclude = .{
             .comp = comp,
             .include_path = include_path,
             .wait_for = null,
         };
-        defer if (wait_for) |buf| comp.gpa.free(buf);
 
         if (std.fs.path.isAbsolute(include_path)) {
             switch (search_strat) {
@@ -1690,12 +1693,7 @@ const FindInclude = struct {
                 // because a file might not be directly inside of an include directory. To implement
                 // this correctly, we will need to track which include directory a file has been
                 // included from.
-                wait_for = if (std.fs.path.dirname(other_file)) |path|
-                    try std.fs.path.resolve(comp.gpa, &.{path})
-                else
-                    null;
-
-                find.wait_for = wait_for;
+                find.wait_for = std.fs.path.dirname(other_file);
             },
         }
         switch (include_type) {
@@ -1724,9 +1722,28 @@ const FindInclude = struct {
         }
         return null;
     }
+    fn pathMatches(a: []const u8, b: []const u8) bool {
+        if (@import("builtin").os.tag != .windows) {
+            return std.mem.eql(u8, a, b);
+        }
+
+        const separators = std.fs.path.sep_str_windows ++ std.fs.path.sep_str_posix;
+        var a_iter = std.mem.splitAny(u8, a, separators);
+        var b_iter = std.mem.splitAny(u8, b, separators);
+        var a_component = a_iter.next();
+        var b_component = b_iter.next();
+        while (a_component != null and b_component != null) : ({
+            a_component = a_iter.next();
+            b_component = b_iter.next();
+        }) {
+            if (!std.mem.eql(u8, a_component.?, b_component.?)) return false;
+        }
+
+        return a_component == null and b_component == null;
+    }
     fn checkIncludeDir(find: *FindInclude, include_dir: []const u8, kind: Source.Kind) Allocator.Error!?Result {
         if (find.wait_for) |wait_for| {
-            if (std.mem.eql(u8, include_dir, wait_for)) find.wait_for = null;
+            if (pathMatches(include_dir, wait_for)) find.wait_for = null;
             return null;
         }
         return find.check("{s}{c}{s}", .{
@@ -1739,7 +1756,7 @@ const FindInclude = struct {
         const path = find.comp.getSource(source_id).path;
         const dir = std.fs.path.dirname(path) orelse ".";
         if (find.wait_for) |wait_for| {
-            if (std.mem.eql(u8, dir, wait_for)) find.wait_for = null;
+            if (pathMatches(dir, wait_for)) find.wait_for = null;
             return null;
         }
         return find.check("{s}{c}{s}", .{
@@ -1754,7 +1771,7 @@ const FindInclude = struct {
                 // If this is a match, then `wait_for` looks like '.../Foo.framework/Headers'.
                 const wait_framework = std.fs.path.dirname(wait_for) orelse break :match;
                 const wait_framework_dir = std.fs.path.dirname(wait_framework) orelse break :match;
-                if (!std.mem.eql(u8, framework_dir, wait_framework_dir)) break :match;
+                if (!pathMatches(framework_dir, wait_framework_dir)) break :match;
                 find.wait_for = null;
             }
             return null;

lib/compiler/translate-c/Translator.zig

@@ -1165,17 +1165,8 @@ fn headFieldAlignment(t: *Translator, record_decl: aro.Type.Record) ?c_uint {
     const parent_ptr_alignment_bits = record_decl.layout.?.pointer_alignment_bits;
     const parent_ptr_alignment = parent_ptr_alignment_bits / bits_per_byte;
     var max_field_alignment_bits: u64 = 0;
-    for (record_decl.fields) |field| {
-        if (field.qt.getRecord(t.comp)) |field_record_decl| {
-            const child_record_alignment = field_record_decl.layout.?.field_alignment_bits;
-            if (child_record_alignment > max_field_alignment_bits)
-                max_field_alignment_bits = child_record_alignment;
-        } else {
-            const field_size = field.layout.size_bits;
-            if (field_size > max_field_alignment_bits)
-                max_field_alignment_bits = field_size;
-        }
-    }
+    for (record_decl.fields) |field|
+        max_field_alignment_bits = @max(max_field_alignment_bits, bits_per_byte * field.qt.alignof(t.comp));
     if (max_field_alignment_bits != parent_ptr_alignment_bits) {
         return parent_ptr_alignment;
     } else {
@@ -1227,10 +1218,7 @@ fn alignmentForField(
     // Records have a natural alignment when used as a field, and their size is
     // a multiple of this alignment value. For all other types, the natural alignment
     // is their size.
-    const field_natural_alignment_bits: u64 = if (field.qt.getRecord(t.comp)) |record|
-        record.layout.?.field_alignment_bits
-    else
-        field_size_bits;
+    const field_natural_alignment_bits: u64 = bits_per_byte * field.qt.alignof(t.comp);
     const rem_bits = field_offset_bits % field_natural_alignment_bits;
 
     // If there's a remainder, then the alignment is smaller than the field's