Add runtime page_size

Author: RossComputerGuy

lib/std/c.zig

@@ -79,6 +79,7 @@ pub usingnamespace switch (builtin.os.tag) {
         pub extern "c" fn getrusage(who: c_int, usage: *c.rusage) c_int;
 
         pub extern "c" fn sched_yield() c_int;
+        pub extern "c" fn sysconf(sc: c_int) c_long;
 
         pub extern "c" fn sigaction(sig: c_int, noalias act: ?*const c.Sigaction, noalias oact: ?*c.Sigaction) c_int;
         pub extern "c" fn sigprocmask(how: c_int, noalias set: ?*const c.sigset_t, noalias oset: ?*c.sigset_t) c_int;

lib/std/mem.zig

@@ -10,9 +10,19 @@ const testing = std.testing;
 const Endian = std.builtin.Endian;
 const native_endian = builtin.cpu.arch.endian();
 
+/// Runtime known minimum page size.
+/// If the page size cannot be determined at runtime,
+/// it will use the comptime known one.
+pub fn getPageSize() usize {
+    return switch (builtin.os.tag) {
+        .linux => if (builtin.link_libc) @intCast(std.c.sysconf(30)) else std.os.linux.getauxval(std.elf.AT_PAGESZ),
+        else => page_size,
+    };
+}
+
 /// Compile time known minimum page size.
 /// https://github.com/ziglang/zig/issues/4082
-pub const page_size = switch (builtin.cpu.arch) {
+pub const page_size = builtin.target.page_size orelse switch (builtin.cpu.arch) {
     .wasm32, .wasm64 => 64 * 1024,
     .aarch64 => switch (builtin.os.tag) {
         .macos, .ios, .watchos, .tvos => 16 * 1024,

lib/std/target.zig

@@ -8,6 +8,7 @@ pub const Target = struct {
     os: Os,
     abi: Abi,
     ofmt: ObjectFormat,
+    page_size: ?usize = null,
 
     pub const Os = struct {
         tag: Tag,
@@ -449,6 +450,10 @@ pub const Target = struct {
                 => false,
             };
         }
+
+        pub fn compare(self: Os, other: Os) bool {
+            return self.tag == other.tag and self.isAtLeast(other.tag, other.getVersionRange());
+        }
     };
 
     pub const aarch64 = @import("target/aarch64.zig");
@@ -1360,8 +1365,16 @@ pub const Target = struct {
         pub fn baseline(arch: Arch) Cpu {
             return Model.baseline(arch).toCpu(arch);
         }
+
+        pub fn compare(self: Cpu, other: Cpu) bool {
+            return self.arch == other.arch and std.mem.eql(u8, self.model.name, other.model.name) and self.features.eql(other.features);
+        }
     };
 
+    pub fn useHostPageSize(self: Target, other: Target) bool {
+        return self.cpu.compare(other.cpu) and self.os.compare(other.os);
+    }
+
     pub fn zigTriple(self: Target, allocator: mem.Allocator) ![]u8 {
         return std.zig.CrossTarget.fromTarget(self).zigTriple(allocator);
     }

lib/std/zig/CrossTarget.zig

@@ -45,6 +45,9 @@ dynamic_linker: DynamicLinker = DynamicLinker{},
 /// `null` means default for the cpu/arch/os combo.
 ofmt: ?Target.ObjectFormat = null,
 
+/// `null` means to dynamically get the page size or use the platform default.
+page_size: ?usize = null,
+
 pub const CpuModel = union(enum) {
     /// Always native
     native,
@@ -81,6 +84,7 @@ pub fn fromTarget(target: Target) CrossTarget {
             target.os.version_range.linux.glibc
         else
             null,
+        .page_size = target.page_size,
     };
     result.updateOsVersionRange(target.os);
 
@@ -176,6 +180,7 @@ pub fn toTarget(self: CrossTarget) Target {
         .os = self.getOs(),
         .abi = self.getAbi(),
         .ofmt = self.getObjectFormat(),
+        .page_size = self.page_size,
     };
 }
 

lib/std/zig/system/NativeTargetInfo.zig

@@ -644,6 +644,7 @@ pub fn abiAndDynamicLinkerFromFile(
             .os = os,
             .abi = cross_target.abi orelse Target.Abi.default(cpu.arch, os),
             .ofmt = cross_target.ofmt orelse Target.ObjectFormat.default(os.tag, cpu.arch),
+            .page_size = cross_target.page_size,
         },
         .dynamic_linker = cross_target.dynamic_linker,
     };
@@ -921,6 +922,7 @@ fn defaultAbiAndDynamicLinker(cpu: Target.Cpu, os: Target.Os, cross_target: Cros
         .os = os,
         .abi = cross_target.abi orelse Target.Abi.default(cpu.arch, os),
         .ofmt = cross_target.ofmt orelse Target.ObjectFormat.default(os.tag, cpu.arch),
+        .page_size = cross_target.page_size,
     };
     return NativeTargetInfo{
         .target = target,

src/Compilation.zig

@@ -6267,6 +6267,7 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
         \\    .os = os,
         \\    .abi = abi,
         \\    .ofmt = object_format,
+        \\    .page_size = {?},
         \\}};
         \\pub const object_format = std.Target.ObjectFormat.{};
         \\pub const mode = std.builtin.OptimizeMode.{};
@@ -6282,6 +6283,7 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: Allocator) Alloca
         \\pub const omit_frame_pointer = {};
         \\
     , .{
+        target.page_size orelse (if (comp.bin_file.options.is_native_os and comp.bin_file.options.is_native_abi) std.mem.getPageSize() else null),
         std.zig.fmtId(@tagName(target.ofmt)),
         std.zig.fmtId(@tagName(comp.bin_file.options.optimize_mode)),
         link_libc,