Merge remote-tracking branch 'origin/main' into linux64

crates/compiler/builtins/bitcode/bc/build.rs

@@ -62,12 +62,12 @@ fn generate_bc_file(bitcode_path: &Path, zig_object: &str, file_name: &str) {
     ll_path.set_extension("ll");
     let dest_ir_host = ll_path.to_str().expect("Invalid dest ir path");
 
-    println!("Compiling host ir to: {}", dest_ir_host);
+    println!("Compiling host ir to: {dest_ir_host}");
 
     let mut bc_path = bitcode_path.join(file_name);
     bc_path.set_extension("bc");
     let dest_bc_64bit = bc_path.to_str().expect("Invalid dest bc path");
-    println!("Compiling 64-bit bitcode to: {}", dest_bc_64bit);
+    println!("Compiling 64-bit bitcode to: {dest_bc_64bit}");
 
     // workaround for github.com/ziglang/zig/issues/9711
     #[cfg(target_os = "macos")]
@@ -105,7 +105,7 @@ fn run_command(mut command: Command, flaky_fail_counter: usize) {
             false => {
                 let error_str = match str::from_utf8(&output.stderr) {
                     Ok(stderr) => stderr.to_string(),
-                    Err(_) => format!("Failed to run \"{}\"", command_str),
+                    Err(_) => format!("Failed to run \"{command_str}\""),
                 };
 
                 // Flaky test errors that only occur sometimes on MacOS ci server.

crates/compiler/builtins/bitcode/build.rs

@@ -66,7 +66,7 @@ fn generate_object_file(bitcode_path: &Path, zig_object: &str, object_file_name:
     let src_obj_path = bitcode_path.join(object_file_name);
     let src_obj = src_obj_path.to_str().expect("Invalid src object path");
 
-    println!("Compiling zig object `{}` to: {}", zig_object, src_obj);
+    println!("Compiling zig object `{zig_object}` to: {src_obj}");
 
     if !DEBUG {
         let mut zig_cmd = zig();
@@ -77,7 +77,7 @@ fn generate_object_file(bitcode_path: &Path, zig_object: &str, object_file_name:
 
         run_command(zig_cmd, 0);
 
-        println!("Moving zig object `{}` to: {}", zig_object, dest_obj);
+        println!("Moving zig object `{zig_object}` to: {dest_obj}");
 
         // we store this .o file in rust's `target` folder (for wasm we need to leave a copy here too)
         fs::copy(src_obj, dest_obj).unwrap_or_else(|err| {
@@ -167,7 +167,7 @@ fn run_command(mut command: Command, flaky_fail_counter: usize) {
             false => {
                 let error_str = match str::from_utf8(&output.stderr) {
                     Ok(stderr) => stderr.to_string(),
-                    Err(_) => format!("Failed to run \"{}\"", command_str),
+                    Err(_) => format!("Failed to run \"{command_str}\""),
                 };
 
                 // Flaky test errors that only occur sometimes on MacOS ci server.

crates/compiler/builtins/bitcode/src/compiler_rt.zig

@@ -18,6 +18,7 @@ const v2u64 = @Vector(2, u64);
 // Export it as weak incase it is already linked in by something else.
 comptime {
     @export(__muloti4, .{ .name = "__muloti4", .linkage = .Weak });
+    @export(__lshrti3, .{ .name = "__lshrti3", .linkage = .Weak });
     if (want_windows_v2u64_abi) {
         @export(__divti3_windows_x86_64, .{ .name = "__divti3", .linkage = .Weak });
         @export(__modti3_windows_x86_64, .{ .name = "__modti3", .linkage = .Weak });
@@ -440,3 +441,47 @@ pub inline fn floatFractionalBits(comptime T: type) comptime_int {
         else => @compileError("unknown floating point type " ++ @typeName(T)),
     };
 }
+
+pub fn __lshrti3(a: i128, b: i32) callconv(.C) i128 {
+    return lshrXi3(i128, a, b);
+}
+
+// Logical shift right: shift in 0 from left to right
+// Precondition: 0 <= b < T.bit_count
+inline fn lshrXi3(comptime T: type, a: T, b: i32) T {
+    const word_t = HalveInt(T, false);
+    const S = std.math.Log2Int(word_t.HalfT);
+
+    const input = word_t{ .all = a };
+    var output: word_t = undefined;
+
+    if (b >= word_t.bits) {
+        output.s.high = 0;
+        output.s.low = input.s.high >> @intCast(S, b - word_t.bits);
+    } else if (b == 0) {
+        return a;
+    } else {
+        output.s.high = input.s.high >> @intCast(S, b);
+        output.s.low = input.s.high << @intCast(S, word_t.bits - b);
+        output.s.low |= input.s.low >> @intCast(S, b);
+    }
+
+    return output.all;
+}
+
+/// Allows to access underlying bits as two equally sized lower and higher
+/// signed or unsigned integers.
+fn HalveInt(comptime T: type, comptime signed_half: bool) type {
+    return extern union {
+        pub const bits = @divExact(@typeInfo(T).Int.bits, 2);
+        pub const HalfTU = std.meta.Int(.unsigned, bits);
+        pub const HalfTS = std.meta.Int(.signed, bits);
+        pub const HalfT = if (signed_half) HalfTS else HalfTU;
+
+        all: T,
+        s: if (native_endian == .Little)
+            extern struct { low: HalfT, high: HalfT }
+        else
+            extern struct { high: HalfT, low: HalfT },
+    };
+}

crates/compiler/builtins/bitcode/src/main.zig

@@ -195,8 +195,10 @@ comptime {
     exportUtilsFn(utils.test_panic, "test_panic");
     exportUtilsFn(utils.increfRcPtrC, "incref_rc_ptr");
     exportUtilsFn(utils.decrefRcPtrC, "decref_rc_ptr");
+    exportUtilsFn(utils.freeRcPtrC, "free_rc_ptr");
     exportUtilsFn(utils.increfDataPtrC, "incref_data_ptr");
     exportUtilsFn(utils.decrefDataPtrC, "decref_data_ptr");
+    exportUtilsFn(utils.freeDataPtrC, "free_data_ptr");
     exportUtilsFn(utils.isUnique, "is_unique");
     exportUtilsFn(utils.decrefCheckNullC, "decref_check_null");
     exportUtilsFn(utils.allocateWithRefcountC, "allocate_with_refcount");

crates/compiler/builtins/bitcode/src/utils.zig

@@ -220,6 +220,29 @@ pub fn increfDataPtrC(
     return increfRcPtrC(isizes, inc_amount);
 }
 
+pub fn freeDataPtrC(
+    bytes_or_null: ?[*]isize,
+    alignment: u32,
+) callconv(.C) void {
+    var bytes = bytes_or_null orelse return;
+
+    const ptr = @ptrToInt(bytes);
+    const tag_mask: usize = if (@sizeOf(usize) == 8) 0b111 else 0b11;
+    const masked_ptr = ptr & ~tag_mask;
+
+    const isizes: [*]isize = @intToPtr([*]isize, masked_ptr);
+
+    return freeRcPtrC(isizes - 1, alignment);
+}
+
+pub fn freeRcPtrC(
+    bytes_or_null: ?[*]isize,
+    alignment: u32,
+) callconv(.C) void {
+    var bytes = bytes_or_null orelse return;
+    return free_ptr_to_refcount(bytes, alignment);
+}
+
 pub fn decref(
     bytes_or_null: ?[*]u8,
     data_bytes: usize,
@@ -236,13 +259,23 @@ pub fn decref(
     decref_ptr_to_refcount(isizes - 1, alignment);
 }
 
-inline fn decref_ptr_to_refcount(
+inline fn free_ptr_to_refcount(
     refcount_ptr: [*]isize,
     alignment: u32,
 ) void {
     if (RC_TYPE == Refcount.none) return;
     const extra_bytes = std.math.max(alignment, @sizeOf(usize));
 
+    // NOTE: we don't even check whether the refcount is "infinity" here!
+    dealloc(@ptrCast([*]u8, refcount_ptr) - (extra_bytes - @sizeOf(usize)), alignment);
+}
+
+inline fn decref_ptr_to_refcount(
+    refcount_ptr: [*]isize,
+    alignment: u32,
+) void {
+    if (RC_TYPE == Refcount.none) return;
+
     if (DEBUG_INCDEC and builtin.target.cpu.arch != .wasm32) {
         std.debug.print("| decrement {*}: ", .{refcount_ptr});
     }
@@ -264,13 +297,13 @@ inline fn decref_ptr_to_refcount(
                 }
 
                 if (refcount == REFCOUNT_ONE_ISIZE) {
-                    dealloc(@ptrCast([*]u8, refcount_ptr) - (extra_bytes - @sizeOf(usize)), alignment);
+                    free_ptr_to_refcount(refcount_ptr, alignment);
                 }
             },
             Refcount.atomic => {
                 var last = @atomicRmw(isize, &refcount_ptr[0], std.builtin.AtomicRmwOp.Sub, 1, Monotonic);
                 if (last == REFCOUNT_ONE_ISIZE) {
-                    dealloc(@ptrCast([*]u8, refcount_ptr) - (extra_bytes - @sizeOf(usize)), alignment);
+                    free_ptr_to_refcount(refcount_ptr, alignment);
                 }
             },
             Refcount.none => unreachable,