ResolvedTarget

pub const ResolvedTarget = struct

File

Code

pub const ResolvedTarget = struct {
    /// none indicates host.
    query: TargetQuery.OptionalIndex,
    /// defaults will be resolved.
    result: TargetQuery.Index,

    pub const Index = enum(u32) {
        _,

        pub fn get(this: @This(), c: *const Configuration) ResolvedTarget {
            return extraData(c, ResolvedTarget, @backingInt(this));
        }
    };

    pub const OptionalIndex = enum(u32) {
        none = max_u32,
        _,

        pub fn init(i: Index) OptionalIndex {
            const result: OptionalIndex = @fromBackingInt(@intCast(@backingInt(i)));
            assert(result != .none);
            return result;
        }

        pub fn unwrap(this: @This()) ?Index {
            return switch (this) {
                .none => null,
                _ => @fromBackingInt(@intCast(@backingInt(this))),
            };
        }

        pub fn get(this: @This(), c: *const Configuration) ?ResolvedTarget {
            return (unwrap(this) orelse return null).get(c);
        }
    };

    pub fn unwrapQuery(rt: *const ResolvedTarget, c: *const Configuration) ?std.Target.Query {
        const tq = rt.query.get(c) orelse return null;
        const cpu_arch = tq.flags.cpu_arch.unwrap() orelse rt.result.get(c).flags.cpu_arch.unwrap().?;
        return .{
            .cpu_arch = cpu_arch,
            .cpu_model = switch (tq.flags.cpu_model) {
                .native => .native,
                .baseline => .baseline,
                .determined_by_arch_os => .determined_by_arch_os,
                .explicit => .{ .explicit = cpu_arch.parseCpuModel(tq.cpu_name.value.?.slice(c)).? },
            },
            .cpu_features_add = tq.cpu_features_add.value orelse .empty,
            .cpu_features_sub = tq.cpu_features_sub.value orelse .empty,
            .os_tag = tq.flags.os_tag.unwrap(),
            .os_version_min = tq.os_version_min.u.unwrap(c),
            .os_version_max = tq.os_version_max.u.unwrap(c),
            .glibc_version = if (tq.glibc_version.value) |s|
                std.SemanticVersion.parse(s.slice(c)) catch unreachable
            else
                null,
            .android_api_level = tq.android_api_level.value,
            .abi = tq.flags.abi.unwrap(),
            .dynamic_linker = if (tq.dynamic_linker.value) |s| .init(s.slice(c)) else null,
            .ofmt = tq.flags.object_format.unwrap(),
        };
    }
}