motiejus/zig
1
Fork 0
Code Releases Activity

hit a comptime limitation with computing dense sets

Browse Source
This commit is contained in:
Andrew Kelley
2020-01-21 19:40:44 -05:00
parent 15d5cab569
commit 92559cd02c
21 changed files with 1720 additions and 3107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/std/build.zig
View File

@@ -1983,7 +1983,7 @@ pub const LibExeObjStep = struct {
var feature_str_buffer = try std.Buffer.initSize(builder.allocator, 0);
for (self.target.getArch().allFeaturesList()) |feature, i| {
if (features.isEnabled(@intCast(u8, i))) {
if (features.isEnabled(@intCast(Target.Cpu.Feature.Set.Index, i))) {
try feature_str_buffer.append(feature.name);
try feature_str_buffer.append(",");
}

186
lib/std/target.zig
View File

@@ -172,6 +172,48 @@ pub const Target = union(enum) {
r6,
};
pub fn subArchFeature(arch: Arch) ?u8 {
return switch (arch) {
.arm, .armeb, .thumb, .thumbeb => |arm32| switch (arm32) {
.v8_5a => @enumToInt(arm.Feature.armv8_5_a),
.v8_4a => @enumToInt(arm.Feature.armv8_4_a),
.v8_3a => @enumToInt(arm.Feature.armv8_3_a),
.v8_2a => @enumToInt(arm.Feature.armv8_2_a),
.v8_1a => @enumToInt(arm.Feature.armv8_1_a),
.v8 => @enumToInt(arm.Feature.armv8_a),
.v8r => @enumToInt(arm.Feature.armv8_r),
.v8m_baseline => @enumToInt(arm.Feature.armv8_m_base),
.v8m_mainline => @enumToInt(arm.Feature.armv8_m_main),
.v8_1m_mainline => @enumToInt(arm.Feature.armv8_1_m_main),
.v7 => @enumToInt(arm.Feature.armv7_a),
.v7em => @enumToInt(arm.Feature.armv7e_m),
.v7m => @enumToInt(arm.Feature.armv7_m),
.v7s => @enumToInt(arm.Feature.armv7s),
.v7k => @enumToInt(arm.Feature.armv7k),
.v7ve => @enumToInt(arm.Feature.armv7ve),
.v6 => @enumToInt(arm.Feature.armv6),
.v6m => @enumToInt(arm.Feature.armv6_m),
.v6k => @enumToInt(arm.Feature.armv6k),
.v6t2 => @enumToInt(arm.Feature.armv6t2),
.v5 => @enumToInt(arm.Feature.armv5t),
.v5te => @enumToInt(arm.Feature.armv5te),
.v4t => @enumToInt(arm.Feature.armv4t),
},
.aarch64, .aarch64_be, .aarch64_32 => |arm64| switch (arm64) {
.v8_5a => @enumToInt(aarch64.Feature.v8_5a),
.v8_4a => @enumToInt(aarch64.Feature.v8_4a),
.v8_3a => @enumToInt(aarch64.Feature.v8_3a),
.v8_2a => @enumToInt(aarch64.Feature.v8_2a),
.v8_1a => @enumToInt(aarch64.Feature.v8_1a),
.v8 => @enumToInt(aarch64.Feature.v8_1a),
.v8r => @enumToInt(aarch64.Feature.v8_1a),
.v8m_baseline => @enumToInt(aarch64.Feature.v8_1a),
.v8m_mainline => @enumToInt(aarch64.Feature.v8_1a),
},
else => return null,
};
}
pub fn isARM(arch: Arch) bool {
return switch (arch) {
.arm, .armeb => true,
@@ -219,7 +261,7 @@ pub const Target = union(enum) {
pub fn parseCpuFeatureSet(arch: Arch, features_text: []const u8) !Cpu.Feature.Set {
// Here we compute both and choose the correct result at the end, based
// on whether or not we saw + and - signs.
var whitelist_set = Cpu.Feature.Set.empty();
var whitelist_set = Cpu.Feature.Set.empty;
var baseline_set = arch.baselineFeatures();
var mode: enum {
unknown,
@@ -256,16 +298,18 @@ pub const Target = union(enum) {
op = .add;
feature_name = item_text;
}
for (arch.allFeaturesList()) |feature, index| {
const all_features = arch.allFeaturesList();
for (all_features) |feature, index_usize| {
const index = @intCast(Cpu.Feature.Set.Index, index_usize);
if (mem.eql(u8, feature_name, feature.name)) {
switch (op) {
.add => {
baseline_set.addFeature(@intCast(u8, index));
whitelist_set.addFeature(@intCast(u8, index));
baseline_set.addFeature(index, all_features);
whitelist_set.addFeature(index, all_features);
},
.sub => {
baseline_set.removeFeature(@intCast(u8, index));
whitelist_set.removeFeature(@intCast(u8, index));
baseline_set.removeFeature(index, all_features);
whitelist_set.removeFeature(index, all_features);
},
}
break;
@@ -462,7 +506,7 @@ pub const Target = union(enum) {
.nvptx, .nvptx64 => nvptx.cpu.sm_20.features,
.wasm32, .wasm64 => wasm.cpu.generic.features,
else => Cpu.Feature.Set.empty(),
else => Cpu.Feature.Set.empty,
};
}
@@ -521,48 +565,130 @@ pub const Target = union(enum) {
features: Feature.Set,
pub const Feature = struct {
/// The bit index into `Set`.
index: u8,
name: []const u8,
/// The bit index into `Set`. Has a default value of `undefined` because the canonical
/// structures are populated via comptime logic.
index: Set.Index = undefined,
/// Has a default value of `undefined` because the canonical
/// structures are populated via comptime logic.
name: []const u8 = undefined,
/// If this corresponds to an LLVM-recognized feature, this will be populated;
/// otherwise null.
llvm_name: ?[:0]const u8,
/// Human-friendly UTF-8 text.
description: []const u8,
dependencies: Set,
/// `Set` of all features this depends on, and this feature itself.
/// Can be "or"ed with another set to remove this feature and all
/// its dependencies.
/// Has a default value of `undefined` because the canonical
/// structures are populated via comptime logic.
dependencies: Set = undefined,
/// A bit set of all the features.
pub const Set = struct {
bytes: [bit_count / 8]u8,
ints: [usize_count]usize,
pub const bit_count = 22 * 8;
pub const needed_bit_count = 174;
pub const byte_count = (needed_bit_count + 7) / 8;
pub const usize_count = (byte_count + (@sizeOf(usize) - 1)) / @sizeOf(usize);
pub const Index = std.math.Log2Int(@IntType(false, usize_count * @bitSizeOf(usize)));
pub const ShiftInt = std.math.Log2Int(usize);
pub fn empty() Set {
return .{ .bytes = [1]u8{0} ** 22 };
pub const empty = Set{ .ints = [1]usize{0} ** usize_count };
pub fn isEnabled(set: Set, arch_feature_index: Index) bool {
const usize_index = arch_feature_index / @bitSizeOf(usize);
const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
return (set.ints[usize_index] & (@as(usize, 1) << bit_index)) != 0;
}
pub fn isEnabled(set: Set, arch_feature_index: u8) bool {
const byte_index = arch_feature_index / 8;
const bit_index = @intCast(u3, arch_feature_index % 8);
return (set.bytes[byte_index] & (@as(u8, 1) << bit_index)) != 0;
/// Adds the specified feature and all its dependencies to the set. O(1).
pub fn addFeature(
set: *Set,
arch_feature_index: Index,
all_features_list: []const Cpu.Feature,
) void {
set.ints = @as(@Vector(usize_count, usize), set.ints) |
@as(@Vector(usize_count, usize), all_features_list[arch_feature_index].dependencies.ints);
}
pub fn addFeature(set: *Set, arch_feature_index: u8) void {
const byte_index = arch_feature_index / 8;
const bit_index = @intCast(u3, arch_feature_index % 8);
set.bytes[byte_index] |= @as(u8, 1) << bit_index;
/// Removes the specified feature (TODO and all its dependents) from the set. O(1).
/// TODO improve this function to actually handle dependants rather than just calling
/// `removeSparseFeature`.
pub fn removeFeature(
set: *Set,
arch_feature_index: Index,
all_features_list: []const Cpu.Feature,
) void {
set.removeSparseFeature(arch_feature_index);
}
pub fn removeFeature(set: *Set, arch_feature_index: u8) void {
const byte_index = arch_feature_index / 8;
const bit_index = @intCast(u3, arch_feature_index % 8);
set.bytes[byte_index] &= ~(@as(u8, 1) << bit_index);
/// Adds the specified feature but not its dependencies.
pub fn addSparseFeature(set: *Set, arch_feature_index: Index) void {
const usize_index = arch_feature_index / @bitSizeOf(usize);
const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
set.ints[usize_index] |= @as(usize, 1) << bit_index;
}
/// Removes the specified feature but not its dependents.
pub fn removeSparseFeature(set: *Set, arch_feature_index: Index) void {
const usize_index = arch_feature_index / @bitSizeOf(usize);
const bit_index = @intCast(ShiftInt, arch_feature_index % @bitSizeOf(usize));
set.ints[usize_index] &= ~(@as(usize, 1) << bit_index);
}
pub fn initAsDependencies(
set: *Set,
arch_feature_index: Index,
all_features_list: []const Cpu.Feature,
) void {
// fast-case to help reduce how much comptime code must execute
const no_deps = for (set.ints) |elem| {
if (elem != 0) break false;
} else true;
// add itself to its own dependencies for easy "or"ing later
set.addSparseFeature(arch_feature_index);
if (no_deps) return;
var old = set.ints;
while (true) {
for (all_features_list) |feature, index| {
const casted_index = @intCast(Index, index);
if (set.isEnabled(casted_index)) {
set.addFeature(casted_index, all_features_list);
}
}
const nothing_changed = mem.eql(usize, &old, &set.ints);
if (nothing_changed) return;
old = set.ints;
}
}
pub fn asBytes(set: *const Set) *const [byte_count]u8 {
return @ptrCast(*const [byte_count]u8, &set.ints);
}
};
pub fn feature_set_fns(comptime F: type) type {
return struct {
pub fn featureSet(features: []const F) Set {
var x = Set.empty();
/// Populates a set with the list of features and all their dependencies included.
pub fn featureSet(all_features_list: []const Feature, features: []const F) Set {
var x: Set = Set.empty;
for (features) |feature| {
x.addFeature(@enumToInt(feature));
x.addFeature(@enumToInt(feature), all_features_list);
}
@compileLog(Set.empty);
return x;
}
/// Populates only the feature bits specified.
pub fn sparseFeatureSet(features: []const F) Set {
var x = Set.empty;
for (features) |feature| {
x.addSparseFeature(@enumToInt(feature));
}
return x;
}

645
lib/std/target/aarch64.zig
View File

File diff suppressed because it is too large Load Diff

515
lib/std/target/amdgpu.zig
View File

File diff suppressed because it is too large Load Diff

869
lib/std/target/arm.zig
View File

File diff suppressed because it is too large Load Diff

656
lib/std/target/avr.zig
View File

File diff suppressed because it is too large Load Diff

30
lib/std/target/bpf.zig
View File

@@ -11,29 +11,29 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.alu32)] = .{
.index = @enumToInt(Feature.alu32),
.name = @tagName(Feature.alu32),
.llvm_name = "alu32",
.description = "Enable ALU32 instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dummy)] = .{
.index = @enumToInt(Feature.dummy),
.name = @tagName(Feature.dummy),
.llvm_name = "dummy",
.description = "unused feature",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dwarfris)] = .{
.index = @enumToInt(Feature.dwarfris),
.name = @tagName(Feature.dwarfris),
.llvm_name = "dwarfris",
.description = "Disable MCAsmInfo DwarfUsesRelocationsAcrossSections",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -41,27 +41,27 @@ pub const cpu = struct {
pub const generic = Cpu{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const probe = Cpu{
.name = "probe",
.llvm_name = "probe",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const v1 = Cpu{
.name = "v1",
.llvm_name = "v1",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const v2 = Cpu{
.name = "v2",
.llvm_name = "v2",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const v3 = Cpu{
.name = "v3",
.llvm_name = "v3",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
};

118
lib/std/target/hexagon.zig
View File

@@ -32,76 +32,60 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.duplex)] = .{
.index = @enumToInt(Feature.duplex),
.name = @tagName(Feature.duplex),
.llvm_name = "duplex",
.description = "Enable generation of duplex instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hvx)] = .{
.index = @enumToInt(Feature.hvx),
.name = @tagName(Feature.hvx),
.llvm_name = "hvx",
.description = "Hexagon HVX instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hvx_length128b)] = .{
.index = @enumToInt(Feature.hvx_length128b),
.name = @tagName(Feature.hvx_length128b),
.llvm_name = "hvx-length128b",
.description = "Hexagon HVX 128B instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.hvx,
}),
};
result[@enumToInt(Feature.hvx_length64b)] = .{
.index = @enumToInt(Feature.hvx_length64b),
.name = @tagName(Feature.hvx_length64b),
.llvm_name = "hvx-length64b",
.description = "Hexagon HVX 64B instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.hvx,
}),
};
result[@enumToInt(Feature.hvxv60)] = .{
.index = @enumToInt(Feature.hvxv60),
.name = @tagName(Feature.hvxv60),
.llvm_name = "hvxv60",
.description = "Hexagon HVX instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.hvx,
}),
};
result[@enumToInt(Feature.hvxv62)] = .{
.index = @enumToInt(Feature.hvxv62),
.name = @tagName(Feature.hvxv62),
.llvm_name = "hvxv62",
.description = "Hexagon HVX instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.hvx,
.hvxv60,
}),
};
result[@enumToInt(Feature.hvxv65)] = .{
.index = @enumToInt(Feature.hvxv65),
.name = @tagName(Feature.hvxv65),
.llvm_name = "hvxv65",
.description = "Hexagon HVX instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.hvx,
.hvxv60,
.hvxv62,
}),
};
result[@enumToInt(Feature.hvxv66)] = .{
.index = @enumToInt(Feature.hvxv66),
.name = @tagName(Feature.hvxv66),
.llvm_name = "hvxv66",
.description = "Hexagon HVX instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.hvx,
.hvxv60,
.hvxv62,
@@ -110,121 +94,95 @@ pub const all_features = blk: {
}),
};
result[@enumToInt(Feature.long_calls)] = .{
.index = @enumToInt(Feature.long_calls),
.name = @tagName(Feature.long_calls),
.llvm_name = "long-calls",
.description = "Use constant-extended calls",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mem_noshuf)] = .{
.index = @enumToInt(Feature.mem_noshuf),
.name = @tagName(Feature.mem_noshuf),
.llvm_name = "mem_noshuf",
.description = "Supports mem_noshuf feature",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.memops)] = .{
.index = @enumToInt(Feature.memops),
.name = @tagName(Feature.memops),
.llvm_name = "memops",
.description = "Use memop instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.noreturn_stack_elim)] = .{
.index = @enumToInt(Feature.noreturn_stack_elim),
.name = @tagName(Feature.noreturn_stack_elim),
.llvm_name = "noreturn-stack-elim",
.description = "Eliminate stack allocation in a noreturn function when possible",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.nvj)] = .{
.index = @enumToInt(Feature.nvj),
.name = @tagName(Feature.nvj),
.llvm_name = "nvj",
.description = "Support for new-value jumps",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.packets,
}),
};
result[@enumToInt(Feature.nvs)] = .{
.index = @enumToInt(Feature.nvs),
.name = @tagName(Feature.nvs),
.llvm_name = "nvs",
.description = "Support for new-value stores",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.packets,
}),
};
result[@enumToInt(Feature.packets)] = .{
.index = @enumToInt(Feature.packets),
.name = @tagName(Feature.packets),
.llvm_name = "packets",
.description = "Support for instruction packets",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.reserved_r19)] = .{
.index = @enumToInt(Feature.reserved_r19),
.name = @tagName(Feature.reserved_r19),
.llvm_name = "reserved-r19",
.description = "Reserve register R19",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.small_data)] = .{
.index = @enumToInt(Feature.small_data),
.name = @tagName(Feature.small_data),
.llvm_name = "small-data",
.description = "Allow GP-relative addressing of global variables",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.v5)] = .{
.index = @enumToInt(Feature.v5),
.name = @tagName(Feature.v5),
.llvm_name = "v5",
.description = "Enable Hexagon V5 architecture",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.v55)] = .{
.index = @enumToInt(Feature.v55),
.name = @tagName(Feature.v55),
.llvm_name = "v55",
.description = "Enable Hexagon V55 architecture",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.v60)] = .{
.index = @enumToInt(Feature.v60),
.name = @tagName(Feature.v60),
.llvm_name = "v60",
.description = "Enable Hexagon V60 architecture",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.v62)] = .{
.index = @enumToInt(Feature.v62),
.name = @tagName(Feature.v62),
.llvm_name = "v62",
.description = "Enable Hexagon V62 architecture",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.v65)] = .{
.index = @enumToInt(Feature.v65),
.name = @tagName(Feature.v65),
.llvm_name = "v65",
.description = "Enable Hexagon V65 architecture",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.v66)] = .{
.index = @enumToInt(Feature.v66),
.name = @tagName(Feature.v66),
.llvm_name = "v66",
.description = "Enable Hexagon V66 architecture",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.zreg)] = .{
.index = @enumToInt(Feature.zreg),
.name = @tagName(Feature.zreg),
.llvm_name = "zreg",
.description = "Hexagon ZReg extension instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -232,7 +190,7 @@ pub const cpu = struct {
pub const generic = Cpu{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.duplex,
.memops,
.nvj,
@@ -247,7 +205,7 @@ pub const cpu = struct {
pub const hexagonv5 = Cpu{
.name = "hexagonv5",
.llvm_name = "hexagonv5",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.duplex,
.memops,
.nvj,
@@ -260,7 +218,7 @@ pub const cpu = struct {
pub const hexagonv55 = Cpu{
.name = "hexagonv55",
.llvm_name = "hexagonv55",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.duplex,
.memops,
.nvj,
@@ -274,7 +232,7 @@ pub const cpu = struct {
pub const hexagonv60 = Cpu{
.name = "hexagonv60",
.llvm_name = "hexagonv60",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.duplex,
.memops,
.nvj,
@@ -289,7 +247,7 @@ pub const cpu = struct {
pub const hexagonv62 = Cpu{
.name = "hexagonv62",
.llvm_name = "hexagonv62",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.duplex,
.memops,
.nvj,
@@ -305,7 +263,7 @@ pub const cpu = struct {
pub const hexagonv65 = Cpu{
.name = "hexagonv65",
.llvm_name = "hexagonv65",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.duplex,
.mem_noshuf,
.memops,
@@ -323,7 +281,7 @@ pub const cpu = struct {
pub const hexagonv66 = Cpu{
.name = "hexagonv66",
.llvm_name = "hexagonv66",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.duplex,
.mem_noshuf,
.memops,

238
lib/std/target/mips.zig
View File

@@ -57,135 +57,101 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.abs2008)] = .{
.index = @enumToInt(Feature.abs2008),
.name = @tagName(Feature.abs2008),
.llvm_name = "abs2008",
.description = "Disable IEEE 754-2008 abs.fmt mode",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.cnmips)] = .{
.index = @enumToInt(Feature.cnmips),
.name = @tagName(Feature.cnmips),
.llvm_name = "cnmips",
.description = "Octeon cnMIPS Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips64r2,
}),
};
result[@enumToInt(Feature.crc)] = .{
.index = @enumToInt(Feature.crc),
.name = @tagName(Feature.crc),
.llvm_name = "crc",
.description = "Mips R6 CRC ASE",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dsp)] = .{
.index = @enumToInt(Feature.dsp),
.name = @tagName(Feature.dsp),
.llvm_name = "dsp",
.description = "Mips DSP ASE",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dspr2)] = .{
.index = @enumToInt(Feature.dspr2),
.name = @tagName(Feature.dspr2),
.llvm_name = "dspr2",
.description = "Mips DSP-R2 ASE",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.dsp,
}),
};
result[@enumToInt(Feature.dspr3)] = .{
.index = @enumToInt(Feature.dspr3),
.name = @tagName(Feature.dspr3),
.llvm_name = "dspr3",
.description = "Mips DSP-R3 ASE",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.dsp,
.dspr2,
}),
};
result[@enumToInt(Feature.eva)] = .{
.index = @enumToInt(Feature.eva),
.name = @tagName(Feature.eva),
.llvm_name = "eva",
.description = "Mips EVA ASE",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fp64)] = .{
.index = @enumToInt(Feature.fp64),
.name = @tagName(Feature.fp64),
.llvm_name = "fp64",
.description = "Support 64-bit FP registers",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fpxx)] = .{
.index = @enumToInt(Feature.fpxx),
.name = @tagName(Feature.fpxx),
.llvm_name = "fpxx",
.description = "Support for FPXX",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ginv)] = .{
.index = @enumToInt(Feature.ginv),
.name = @tagName(Feature.ginv),
.llvm_name = "ginv",
.description = "Mips Global Invalidate ASE",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.gp64)] = .{
.index = @enumToInt(Feature.gp64),
.name = @tagName(Feature.gp64),
.llvm_name = "gp64",
.description = "General Purpose Registers are 64-bit wide",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.long_calls)] = .{
.index = @enumToInt(Feature.long_calls),
.name = @tagName(Feature.long_calls),
.llvm_name = "long-calls",
.description = "Disable use of the jal instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.micromips)] = .{
.index = @enumToInt(Feature.micromips),
.name = @tagName(Feature.micromips),
.llvm_name = "micromips",
.description = "microMips mode",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mips1)] = .{
.index = @enumToInt(Feature.mips1),
.name = @tagName(Feature.mips1),
.llvm_name = "mips1",
.description = "Mips I ISA Support [highly experimental]",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mips16)] = .{
.index = @enumToInt(Feature.mips16),
.name = @tagName(Feature.mips16),
.llvm_name = "mips16",
.description = "Mips16 mode",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mips2)] = .{
.index = @enumToInt(Feature.mips2),
.name = @tagName(Feature.mips2),
.llvm_name = "mips2",
.description = "Mips II ISA Support [highly experimental]",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips1,
}),
};
result[@enumToInt(Feature.mips3)] = .{
.index = @enumToInt(Feature.mips3),
.name = @tagName(Feature.mips3),
.llvm_name = "mips3",
.description = "MIPS III ISA Support [highly experimental]",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fp64,
.gp64,
.mips2,
@@ -194,22 +160,18 @@ pub const all_features = blk: {
}),
};
result[@enumToInt(Feature.mips32)] = .{
.index = @enumToInt(Feature.mips32),
.name = @tagName(Feature.mips32),
.llvm_name = "mips32",
.description = "Mips32 ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips2,
.mips3_32,
.mips4_32,
}),
};
result[@enumToInt(Feature.mips32r2)] = .{
.index = @enumToInt(Feature.mips32r2),
.name = @tagName(Feature.mips32r2),
.llvm_name = "mips32r2",
.description = "Mips32r2 ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips32,
.mips3_32r2,
.mips4_32r2,
@@ -217,29 +179,23 @@ pub const all_features = blk: {
}),
};
result[@enumToInt(Feature.mips32r3)] = .{
.index = @enumToInt(Feature.mips32r3),
.name = @tagName(Feature.mips32r3),
.llvm_name = "mips32r3",
.description = "Mips32r3 ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips32r2,
}),
};
result[@enumToInt(Feature.mips32r5)] = .{
.index = @enumToInt(Feature.mips32r5),
.name = @tagName(Feature.mips32r5),
.llvm_name = "mips32r5",
.description = "Mips32r5 ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips32r3,
}),
};
result[@enumToInt(Feature.mips32r6)] = .{
.index = @enumToInt(Feature.mips32r6),
.name = @tagName(Feature.mips32r6),
.llvm_name = "mips32r6",
.description = "Mips32r6 ISA Support [experimental]",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.abs2008,
.fp64,
.mips32r5,
@@ -247,107 +203,83 @@ pub const all_features = blk: {
}),
};
result[@enumToInt(Feature.mips3_32)] = .{
.index = @enumToInt(Feature.mips3_32),
.name = @tagName(Feature.mips3_32),
.llvm_name = "mips3_32",
.description = "Subset of MIPS-III that is also in MIPS32 [highly experimental]",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mips3_32r2)] = .{
.index = @enumToInt(Feature.mips3_32r2),
.name = @tagName(Feature.mips3_32r2),
.llvm_name = "mips3_32r2",
.description = "Subset of MIPS-III that is also in MIPS32r2 [highly experimental]",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mips4)] = .{
.index = @enumToInt(Feature.mips4),
.name = @tagName(Feature.mips4),
.llvm_name = "mips4",
.description = "MIPS IV ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips3,
.mips4_32,
.mips4_32r2,
}),
};
result[@enumToInt(Feature.mips4_32)] = .{
.index = @enumToInt(Feature.mips4_32),
.name = @tagName(Feature.mips4_32),
.llvm_name = "mips4_32",
.description = "Subset of MIPS-IV that is also in MIPS32 [highly experimental]",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mips4_32r2)] = .{
.index = @enumToInt(Feature.mips4_32r2),
.name = @tagName(Feature.mips4_32r2),
.llvm_name = "mips4_32r2",
.description = "Subset of MIPS-IV that is also in MIPS32r2 [highly experimental]",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mips5)] = .{
.index = @enumToInt(Feature.mips5),
.name = @tagName(Feature.mips5),
.llvm_name = "mips5",
.description = "MIPS V ISA Support [highly experimental]",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips4,
.mips5_32r2,
}),
};
result[@enumToInt(Feature.mips5_32r2)] = .{
.index = @enumToInt(Feature.mips5_32r2),
.name = @tagName(Feature.mips5_32r2),
.llvm_name = "mips5_32r2",
.description = "Subset of MIPS-V that is also in MIPS32r2 [highly experimental]",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mips64)] = .{
.index = @enumToInt(Feature.mips64),
.name = @tagName(Feature.mips64),
.llvm_name = "mips64",
.description = "Mips64 ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips32,
.mips5,
}),
};
result[@enumToInt(Feature.mips64r2)] = .{
.index = @enumToInt(Feature.mips64r2),
.name = @tagName(Feature.mips64r2),
.llvm_name = "mips64r2",
.description = "Mips64r2 ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips32r2,
.mips64,
}),
};
result[@enumToInt(Feature.mips64r3)] = .{
.index = @enumToInt(Feature.mips64r3),
.name = @tagName(Feature.mips64r3),
.llvm_name = "mips64r3",
.description = "Mips64r3 ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips32r3,
.mips64r2,
}),
};
result[@enumToInt(Feature.mips64r5)] = .{
.index = @enumToInt(Feature.mips64r5),
.name = @tagName(Feature.mips64r5),
.llvm_name = "mips64r5",
.description = "Mips64r5 ISA Support",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips32r5,
.mips64r3,
}),
};
result[@enumToInt(Feature.mips64r6)] = .{
.index = @enumToInt(Feature.mips64r6),
.name = @tagName(Feature.mips64r6),
.llvm_name = "mips64r6",
.description = "Mips64r6 ISA Support [experimental]",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.abs2008,
.mips32r6,
.mips64r5,
@@ -355,112 +287,88 @@ pub const all_features = blk: {
}),
};
result[@enumToInt(Feature.msa)] = .{
.index = @enumToInt(Feature.msa),
.name = @tagName(Feature.msa),
.llvm_name = "msa",
.description = "Mips MSA ASE",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mt)] = .{
.index = @enumToInt(Feature.mt),
.name = @tagName(Feature.mt),
.llvm_name = "mt",
.description = "Mips MT ASE",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.nan2008)] = .{
.index = @enumToInt(Feature.nan2008),
.name = @tagName(Feature.nan2008),
.llvm_name = "nan2008",
.description = "IEEE 754-2008 NaN encoding",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.noabicalls)] = .{
.index = @enumToInt(Feature.noabicalls),
.name = @tagName(Feature.noabicalls),
.llvm_name = "noabicalls",
.description = "Disable SVR4-style position-independent code",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.nomadd4)] = .{
.index = @enumToInt(Feature.nomadd4),
.name = @tagName(Feature.nomadd4),
.llvm_name = "nomadd4",
.description = "Disable 4-operand madd.fmt and related instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.nooddspreg)] = .{
.index = @enumToInt(Feature.nooddspreg),
.name = @tagName(Feature.nooddspreg),
.llvm_name = "nooddspreg",
.description = "Disable odd numbered single-precision registers",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.p5600)] = .{
.index = @enumToInt(Feature.p5600),
.name = @tagName(Feature.p5600),
.llvm_name = "p5600",
.description = "The P5600 Processor",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.mips32r5,
}),
};
result[@enumToInt(Feature.ptr64)] = .{
.index = @enumToInt(Feature.ptr64),
.name = @tagName(Feature.ptr64),
.llvm_name = "ptr64",
.description = "Pointers are 64-bit wide",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.single_float)] = .{
.index = @enumToInt(Feature.single_float),
.name = @tagName(Feature.single_float),
.llvm_name = "single-float",
.description = "Only supports single precision float",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.soft_float)] = .{
.index = @enumToInt(Feature.soft_float),
.name = @tagName(Feature.soft_float),
.llvm_name = "soft-float",
.description = "Does not support floating point instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sym32)] = .{
.index = @enumToInt(Feature.sym32),
.name = @tagName(Feature.sym32),
.llvm_name = "sym32",
.description = "Symbols are 32 bit on Mips64",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.use_indirect_jump_hazard)] = .{
.index = @enumToInt(Feature.use_indirect_jump_hazard),
.name = @tagName(Feature.use_indirect_jump_hazard),
.llvm_name = "use-indirect-jump-hazard",
.description = "Use indirect jump guards to prevent certain speculation based attacks",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.use_tcc_in_div)] = .{
.index = @enumToInt(Feature.use_tcc_in_div),
.name = @tagName(Feature.use_tcc_in_div),
.llvm_name = "use-tcc-in-div",
.description = "Force the assembler to use trapping",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vfpu)] = .{
.index = @enumToInt(Feature.vfpu),
.name = @tagName(Feature.vfpu),
.llvm_name = "vfpu",
.description = "Enable vector FPU instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.virt)] = .{
.index = @enumToInt(Feature.virt),
.name = @tagName(Feature.virt),
.llvm_name = "virt",
.description = "Mips Virtualization ASE",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -468,112 +376,112 @@ pub const cpu = struct {
pub const mips1 = Cpu{
.name = "mips1",
.llvm_name = "mips1",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips1,
}),
};
pub const mips2 = Cpu{
.name = "mips2",
.llvm_name = "mips2",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips2,
}),
};
pub const mips3 = Cpu{
.name = "mips3",
.llvm_name = "mips3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips3,
}),
};
pub const mips32 = Cpu{
.name = "mips32",
.llvm_name = "mips32",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips32,
}),
};
pub const mips32r2 = Cpu{
.name = "mips32r2",
.llvm_name = "mips32r2",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips32r2,
}),
};
pub const mips32r3 = Cpu{
.name = "mips32r3",
.llvm_name = "mips32r3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips32r3,
}),
};
pub const mips32r5 = Cpu{
.name = "mips32r5",
.llvm_name = "mips32r5",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips32r5,
}),
};
pub const mips32r6 = Cpu{
.name = "mips32r6",
.llvm_name = "mips32r6",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips32r6,
}),
};
pub const mips4 = Cpu{
.name = "mips4",
.llvm_name = "mips4",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips4,
}),
};
pub const mips5 = Cpu{
.name = "mips5",
.llvm_name = "mips5",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips5,
}),
};
pub const mips64 = Cpu{
.name = "mips64",
.llvm_name = "mips64",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips64,
}),
};
pub const mips64r2 = Cpu{
.name = "mips64r2",
.llvm_name = "mips64r2",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips64r2,
}),
};
pub const mips64r3 = Cpu{
.name = "mips64r3",
.llvm_name = "mips64r3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips64r3,
}),
};
pub const mips64r5 = Cpu{
.name = "mips64r5",
.llvm_name = "mips64r5",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips64r5,
}),
};
pub const mips64r6 = Cpu{
.name = "mips64r6",
.llvm_name = "mips64r6",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.mips64r6,
}),
};
pub const octeon = Cpu{
.name = "octeon",
.llvm_name = "octeon",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.cnmips,
.mips64r2,
}),
@@ -581,7 +489,7 @@ pub const cpu = struct {
pub const p5600 = Cpu{
.name = "p5600",
.llvm_name = "p5600",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.p5600,
}),
};

30
lib/std/target/msp430.zig
View File

@@ -12,36 +12,34 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.ext)] = .{
.index = @enumToInt(Feature.ext),
.name = @tagName(Feature.ext),
.llvm_name = "ext",
.description = "Enable MSP430-X extensions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hwmult16)] = .{
.index = @enumToInt(Feature.hwmult16),
.name = @tagName(Feature.hwmult16),
.llvm_name = "hwmult16",
.description = "Enable 16-bit hardware multiplier",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hwmult32)] = .{
.index = @enumToInt(Feature.hwmult32),
.name = @tagName(Feature.hwmult32),
.llvm_name = "hwmult32",
.description = "Enable 32-bit hardware multiplier",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hwmultf5)] = .{
.index = @enumToInt(Feature.hwmultf5),
.name = @tagName(Feature.hwmultf5),
.llvm_name = "hwmultf5",
.description = "Enable F5 series hardware multiplier",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -49,17 +47,17 @@ pub const cpu = struct {
pub const generic = Cpu{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const msp430 = Cpu{
.name = "msp430",
.llvm_name = "msp430",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const msp430x = Cpu{
.name = "msp430x",
.llvm_name = "msp430x",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ext,
}),
};

138
lib/std/target/nvptx.zig
View File

@@ -33,183 +33,139 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.ptx32)] = .{
.index = @enumToInt(Feature.ptx32),
.name = @tagName(Feature.ptx32),
.llvm_name = "ptx32",
.description = "Use PTX version 3.2",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx40)] = .{
.index = @enumToInt(Feature.ptx40),
.name = @tagName(Feature.ptx40),
.llvm_name = "ptx40",
.description = "Use PTX version 4.0",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx41)] = .{
.index = @enumToInt(Feature.ptx41),
.name = @tagName(Feature.ptx41),
.llvm_name = "ptx41",
.description = "Use PTX version 4.1",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx42)] = .{
.index = @enumToInt(Feature.ptx42),
.name = @tagName(Feature.ptx42),
.llvm_name = "ptx42",
.description = "Use PTX version 4.2",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx43)] = .{
.index = @enumToInt(Feature.ptx43),
.name = @tagName(Feature.ptx43),
.llvm_name = "ptx43",
.description = "Use PTX version 4.3",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx50)] = .{
.index = @enumToInt(Feature.ptx50),
.name = @tagName(Feature.ptx50),
.llvm_name = "ptx50",
.description = "Use PTX version 5.0",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx60)] = .{
.index = @enumToInt(Feature.ptx60),
.name = @tagName(Feature.ptx60),
.llvm_name = "ptx60",
.description = "Use PTX version 6.0",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx61)] = .{
.index = @enumToInt(Feature.ptx61),
.name = @tagName(Feature.ptx61),
.llvm_name = "ptx61",
.description = "Use PTX version 6.1",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx63)] = .{
.index = @enumToInt(Feature.ptx63),
.name = @tagName(Feature.ptx63),
.llvm_name = "ptx63",
.description = "Use PTX version 6.3",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ptx64)] = .{
.index = @enumToInt(Feature.ptx64),
.name = @tagName(Feature.ptx64),
.llvm_name = "ptx64",
.description = "Use PTX version 6.4",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_20)] = .{
.index = @enumToInt(Feature.sm_20),
.name = @tagName(Feature.sm_20),
.llvm_name = "sm_20",
.description = "Target SM 2.0",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_21)] = .{
.index = @enumToInt(Feature.sm_21),
.name = @tagName(Feature.sm_21),
.llvm_name = "sm_21",
.description = "Target SM 2.1",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_30)] = .{
.index = @enumToInt(Feature.sm_30),
.name = @tagName(Feature.sm_30),
.llvm_name = "sm_30",
.description = "Target SM 3.0",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_32)] = .{
.index = @enumToInt(Feature.sm_32),
.name = @tagName(Feature.sm_32),
.llvm_name = "sm_32",
.description = "Target SM 3.2",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_35)] = .{
.index = @enumToInt(Feature.sm_35),
.name = @tagName(Feature.sm_35),
.llvm_name = "sm_35",
.description = "Target SM 3.5",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_37)] = .{
.index = @enumToInt(Feature.sm_37),
.name = @tagName(Feature.sm_37),
.llvm_name = "sm_37",
.description = "Target SM 3.7",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_50)] = .{
.index = @enumToInt(Feature.sm_50),
.name = @tagName(Feature.sm_50),
.llvm_name = "sm_50",
.description = "Target SM 5.0",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_52)] = .{
.index = @enumToInt(Feature.sm_52),
.name = @tagName(Feature.sm_52),
.llvm_name = "sm_52",
.description = "Target SM 5.2",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_53)] = .{
.index = @enumToInt(Feature.sm_53),
.name = @tagName(Feature.sm_53),
.llvm_name = "sm_53",
.description = "Target SM 5.3",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_60)] = .{
.index = @enumToInt(Feature.sm_60),
.name = @tagName(Feature.sm_60),
.llvm_name = "sm_60",
.description = "Target SM 6.0",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_61)] = .{
.index = @enumToInt(Feature.sm_61),
.name = @tagName(Feature.sm_61),
.llvm_name = "sm_61",
.description = "Target SM 6.1",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_62)] = .{
.index = @enumToInt(Feature.sm_62),
.name = @tagName(Feature.sm_62),
.llvm_name = "sm_62",
.description = "Target SM 6.2",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_70)] = .{
.index = @enumToInt(Feature.sm_70),
.name = @tagName(Feature.sm_70),
.llvm_name = "sm_70",
.description = "Target SM 7.0",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_72)] = .{
.index = @enumToInt(Feature.sm_72),
.name = @tagName(Feature.sm_72),
.llvm_name = "sm_72",
.description = "Target SM 7.2",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sm_75)] = .{
.index = @enumToInt(Feature.sm_75),
.name = @tagName(Feature.sm_75),
.llvm_name = "sm_75",
.description = "Target SM 7.5",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -217,28 +173,28 @@ pub const cpu = struct {
pub const sm_20 = Cpu{
.name = "sm_20",
.llvm_name = "sm_20",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.sm_20,
}),
};
pub const sm_21 = Cpu{
.name = "sm_21",
.llvm_name = "sm_21",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.sm_21,
}),
};
pub const sm_30 = Cpu{
.name = "sm_30",
.llvm_name = "sm_30",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.sm_30,
}),
};
pub const sm_32 = Cpu{
.name = "sm_32",
.llvm_name = "sm_32",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx40,
.sm_32,
}),
@@ -246,14 +202,14 @@ pub const cpu = struct {
pub const sm_35 = Cpu{
.name = "sm_35",
.llvm_name = "sm_35",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.sm_35,
}),
};
pub const sm_37 = Cpu{
.name = "sm_37",
.llvm_name = "sm_37",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx41,
.sm_37,
}),
@@ -261,7 +217,7 @@ pub const cpu = struct {
pub const sm_50 = Cpu{
.name = "sm_50",
.llvm_name = "sm_50",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx40,
.sm_50,
}),
@@ -269,7 +225,7 @@ pub const cpu = struct {
pub const sm_52 = Cpu{
.name = "sm_52",
.llvm_name = "sm_52",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx41,
.sm_52,
}),
@@ -277,7 +233,7 @@ pub const cpu = struct {
pub const sm_53 = Cpu{
.name = "sm_53",
.llvm_name = "sm_53",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx42,
.sm_53,
}),
@@ -285,7 +241,7 @@ pub const cpu = struct {
pub const sm_60 = Cpu{
.name = "sm_60",
.llvm_name = "sm_60",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx50,
.sm_60,
}),
@@ -293,7 +249,7 @@ pub const cpu = struct {
pub const sm_61 = Cpu{
.name = "sm_61",
.llvm_name = "sm_61",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx50,
.sm_61,
}),
@@ -301,7 +257,7 @@ pub const cpu = struct {
pub const sm_62 = Cpu{
.name = "sm_62",
.llvm_name = "sm_62",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx50,
.sm_62,
}),
@@ -309,7 +265,7 @@ pub const cpu = struct {
pub const sm_70 = Cpu{
.name = "sm_70",
.llvm_name = "sm_70",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx60,
.sm_70,
}),
@@ -317,7 +273,7 @@ pub const cpu = struct {
pub const sm_72 = Cpu{
.name = "sm_72",
.llvm_name = "sm_72",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx61,
.sm_72,
}),
@@ -325,7 +281,7 @@ pub const cpu = struct {
pub const sm_75 = Cpu{
.name = "sm_75",
.llvm_name = "sm_75",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.ptx63,
.sm_75,
}),

286
lib/std/target/powerpc.zig
View File

@@ -59,417 +59,321 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.@"64bit")] = .{
.index = @enumToInt(Feature.@"64bit"),
.name = @tagName(Feature.@"64bit"),
.llvm_name = "64bit",
.description = "Enable 64-bit instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.@"64bitregs")] = .{
.index = @enumToInt(Feature.@"64bitregs"),
.name = @tagName(Feature.@"64bitregs"),
.llvm_name = "64bitregs",
.description = "Enable 64-bit registers usage for ppc32 [beta]",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.altivec)] = .{
.index = @enumToInt(Feature.altivec),
.name = @tagName(Feature.altivec),
.llvm_name = "altivec",
.description = "Enable Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.booke)] = .{
.index = @enumToInt(Feature.booke),
.name = @tagName(Feature.booke),
.llvm_name = "booke",
.description = "Enable Book E instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.icbt,
}),
};
result[@enumToInt(Feature.bpermd)] = .{
.index = @enumToInt(Feature.bpermd),
.name = @tagName(Feature.bpermd),
.llvm_name = "bpermd",
.description = "Enable the bpermd instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.cmpb)] = .{
.index = @enumToInt(Feature.cmpb),
.name = @tagName(Feature.cmpb),
.llvm_name = "cmpb",
.description = "Enable the cmpb instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.crbits)] = .{
.index = @enumToInt(Feature.crbits),
.name = @tagName(Feature.crbits),
.llvm_name = "crbits",
.description = "Use condition-register bits individually",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.crypto)] = .{
.index = @enumToInt(Feature.crypto),
.name = @tagName(Feature.crypto),
.llvm_name = "crypto",
.description = "Enable POWER8 Crypto instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.power8_altivec,
}),
};
result[@enumToInt(Feature.direct_move)] = .{
.index = @enumToInt(Feature.direct_move),
.name = @tagName(Feature.direct_move),
.llvm_name = "direct-move",
.description = "Enable Power8 direct move instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.vsx,
}),
};
result[@enumToInt(Feature.e500)] = .{
.index = @enumToInt(Feature.e500),
.name = @tagName(Feature.e500),
.llvm_name = "e500",
.description = "Enable E500/E500mc instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.extdiv)] = .{
.index = @enumToInt(Feature.extdiv),
.name = @tagName(Feature.extdiv),
.llvm_name = "extdiv",
.description = "Enable extended divide instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fcpsgn)] = .{
.index = @enumToInt(Feature.fcpsgn),
.name = @tagName(Feature.fcpsgn),
.llvm_name = "fcpsgn",
.description = "Enable the fcpsgn instruction",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.float128)] = .{
.index = @enumToInt(Feature.float128),
.name = @tagName(Feature.float128),
.llvm_name = "float128",
.description = "Enable the __float128 data type for IEEE-754R Binary128.",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.vsx,
}),
};
result[@enumToInt(Feature.fpcvt)] = .{
.index = @enumToInt(Feature.fpcvt),
.name = @tagName(Feature.fpcvt),
.llvm_name = "fpcvt",
.description = "Enable fc[ft]* (unsigned and single-precision) and lfiwzx instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.fprnd)] = .{
.index = @enumToInt(Feature.fprnd),
.name = @tagName(Feature.fprnd),
.llvm_name = "fprnd",
.description = "Enable the fri[mnpz] instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.fpu)] = .{
.index = @enumToInt(Feature.fpu),
.name = @tagName(Feature.fpu),
.llvm_name = "fpu",
.description = "Enable classic FPU instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.hard_float,
}),
};
result[@enumToInt(Feature.fre)] = .{
.index = @enumToInt(Feature.fre),
.name = @tagName(Feature.fre),
.llvm_name = "fre",
.description = "Enable the fre instruction",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.fres)] = .{
.index = @enumToInt(Feature.fres),
.name = @tagName(Feature.fres),
.llvm_name = "fres",
.description = "Enable the fres instruction",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.frsqrte)] = .{
.index = @enumToInt(Feature.frsqrte),
.name = @tagName(Feature.frsqrte),
.llvm_name = "frsqrte",
.description = "Enable the frsqrte instruction",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.frsqrtes)] = .{
.index = @enumToInt(Feature.frsqrtes),
.name = @tagName(Feature.frsqrtes),
.llvm_name = "frsqrtes",
.description = "Enable the frsqrtes instruction",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.fsqrt)] = .{
.index = @enumToInt(Feature.fsqrt),
.name = @tagName(Feature.fsqrt),
.llvm_name = "fsqrt",
.description = "Enable the fsqrt instruction",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.hard_float)] = .{
.index = @enumToInt(Feature.hard_float),
.name = @tagName(Feature.hard_float),
.llvm_name = "hard-float",
.description = "Enable floating-point instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.htm)] = .{
.index = @enumToInt(Feature.htm),
.name = @tagName(Feature.htm),
.llvm_name = "htm",
.description = "Enable Hardware Transactional Memory instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.icbt)] = .{
.index = @enumToInt(Feature.icbt),
.name = @tagName(Feature.icbt),
.llvm_name = "icbt",
.description = "Enable icbt instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.invariant_function_descriptors)] = .{
.index = @enumToInt(Feature.invariant_function_descriptors),
.name = @tagName(Feature.invariant_function_descriptors),
.llvm_name = "invariant-function-descriptors",
.description = "Assume function descriptors are invariant",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.isa_v30_instructions)] = .{
.index = @enumToInt(Feature.isa_v30_instructions),
.name = @tagName(Feature.isa_v30_instructions),
.llvm_name = "isa-v30-instructions",
.description = "Enable instructions added in ISA 3.0.",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.isel)] = .{
.index = @enumToInt(Feature.isel),
.name = @tagName(Feature.isel),
.llvm_name = "isel",
.description = "Enable the isel instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ldbrx)] = .{
.index = @enumToInt(Feature.ldbrx),
.name = @tagName(Feature.ldbrx),
.llvm_name = "ldbrx",
.description = "Enable the ldbrx instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.lfiwax)] = .{
.index = @enumToInt(Feature.lfiwax),
.name = @tagName(Feature.lfiwax),
.llvm_name = "lfiwax",
.description = "Enable the lfiwax instruction",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.longcall)] = .{
.index = @enumToInt(Feature.longcall),
.name = @tagName(Feature.longcall),
.llvm_name = "longcall",
.description = "Always use indirect calls",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mfocrf)] = .{
.index = @enumToInt(Feature.mfocrf),
.name = @tagName(Feature.mfocrf),
.llvm_name = "mfocrf",
.description = "Enable the MFOCRF instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.msync)] = .{
.index = @enumToInt(Feature.msync),
.name = @tagName(Feature.msync),
.llvm_name = "msync",
.description = "Has only the msync instruction instead of sync",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.booke,
}),
};
result[@enumToInt(Feature.partword_atomics)] = .{
.index = @enumToInt(Feature.partword_atomics),
.name = @tagName(Feature.partword_atomics),
.llvm_name = "partword-atomics",
.description = "Enable l[bh]arx and st[bh]cx.",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.popcntd)] = .{
.index = @enumToInt(Feature.popcntd),
.name = @tagName(Feature.popcntd),
.llvm_name = "popcntd",
.description = "Enable the popcnt[dw] instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.power8_altivec)] = .{
.index = @enumToInt(Feature.power8_altivec),
.name = @tagName(Feature.power8_altivec),
.llvm_name = "power8-altivec",
.description = "Enable POWER8 Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.altivec,
}),
};
result[@enumToInt(Feature.power8_vector)] = .{
.index = @enumToInt(Feature.power8_vector),
.name = @tagName(Feature.power8_vector),
.llvm_name = "power8-vector",
.description = "Enable POWER8 vector instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.power8_altivec,
.vsx,
}),
};
result[@enumToInt(Feature.power9_altivec)] = .{
.index = @enumToInt(Feature.power9_altivec),
.name = @tagName(Feature.power9_altivec),
.llvm_name = "power9-altivec",
.description = "Enable POWER9 Altivec instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.isa_v30_instructions,
.power8_altivec,
}),
};
result[@enumToInt(Feature.power9_vector)] = .{
.index = @enumToInt(Feature.power9_vector),
.name = @tagName(Feature.power9_vector),
.llvm_name = "power9-vector",
.description = "Enable POWER9 vector instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.isa_v30_instructions,
.power8_vector,
.power9_altivec,
}),
};
result[@enumToInt(Feature.ppc_postra_sched)] = .{
.index = @enumToInt(Feature.ppc_postra_sched),
.name = @tagName(Feature.ppc_postra_sched),
.llvm_name = "ppc-postra-sched",
.description = "Use PowerPC post-RA scheduling strategy",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ppc_prera_sched)] = .{
.index = @enumToInt(Feature.ppc_prera_sched),
.name = @tagName(Feature.ppc_prera_sched),
.llvm_name = "ppc-prera-sched",
.description = "Use PowerPC pre-RA scheduling strategy",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ppc4xx)] = .{
.index = @enumToInt(Feature.ppc4xx),
.name = @tagName(Feature.ppc4xx),
.llvm_name = "ppc4xx",
.description = "Enable PPC 4xx instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.ppc6xx)] = .{
.index = @enumToInt(Feature.ppc6xx),
.name = @tagName(Feature.ppc6xx),
.llvm_name = "ppc6xx",
.description = "Enable PPC 6xx instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.qpx)] = .{
.index = @enumToInt(Feature.qpx),
.name = @tagName(Feature.qpx),
.llvm_name = "qpx",
.description = "Enable QPX instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.recipprec)] = .{
.index = @enumToInt(Feature.recipprec),
.name = @tagName(Feature.recipprec),
.llvm_name = "recipprec",
.description = "Assume higher precision reciprocal estimates",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.secure_plt)] = .{
.index = @enumToInt(Feature.secure_plt),
.name = @tagName(Feature.secure_plt),
.llvm_name = "secure-plt",
.description = "Enable secure plt mode",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.slow_popcntd)] = .{
.index = @enumToInt(Feature.slow_popcntd),
.name = @tagName(Feature.slow_popcntd),
.llvm_name = "slow-popcntd",
.description = "Has slow popcnt[dw] instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.spe)] = .{
.index = @enumToInt(Feature.spe),
.name = @tagName(Feature.spe),
.llvm_name = "spe",
.description = "Enable SPE instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.hard_float,
}),
};
result[@enumToInt(Feature.stfiwx)] = .{
.index = @enumToInt(Feature.stfiwx),
.name = @tagName(Feature.stfiwx),
.llvm_name = "stfiwx",
.description = "Enable the stfiwx instruction",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.fpu,
}),
};
result[@enumToInt(Feature.two_const_nr)] = .{
.index = @enumToInt(Feature.two_const_nr),
.name = @tagName(Feature.two_const_nr),
.llvm_name = "two-const-nr",
.description = "Requires two constant Newton-Raphson computation",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vectors_use_two_units)] = .{
.index = @enumToInt(Feature.vectors_use_two_units),
.name = @tagName(Feature.vectors_use_two_units),
.llvm_name = "vectors-use-two-units",
.description = "Vectors use two units",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vsx)] = .{
.index = @enumToInt(Feature.vsx),
.name = @tagName(Feature.vsx),
.llvm_name = "vsx",
.description = "Enable VSX instructions",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.altivec,
}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -477,7 +381,7 @@ pub const cpu = struct {
pub const @"440" = Cpu{
.name = "440",
.llvm_name = "440",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.booke,
.fres,
.frsqrte,
@@ -489,7 +393,7 @@ pub const cpu = struct {
pub const @"450" = Cpu{
.name = "450",
.llvm_name = "450",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.booke,
.fres,
.frsqrte,
@@ -501,21 +405,21 @@ pub const cpu = struct {
pub const @"601" = Cpu{
.name = "601",
.llvm_name = "601",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fpu,
}),
};
pub const @"602" = Cpu{
.name = "602",
.llvm_name = "602",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fpu,
}),
};
pub const @"603" = Cpu{
.name = "603",
.llvm_name = "603",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fres,
.frsqrte,
}),
@@ -523,7 +427,7 @@ pub const cpu = struct {
pub const @"603e" = Cpu{
.name = "603e",
.llvm_name = "603e",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fres,
.frsqrte,
}),
@@ -531,7 +435,7 @@ pub const cpu = struct {
pub const @"603ev" = Cpu{
.name = "603ev",
.llvm_name = "603ev",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fres,
.frsqrte,
}),
@@ -539,7 +443,7 @@ pub const cpu = struct {
pub const @"604" = Cpu{
.name = "604",
.llvm_name = "604",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fres,
.frsqrte,
}),
@@ -547,7 +451,7 @@ pub const cpu = struct {
pub const @"604e" = Cpu{
.name = "604e",
.llvm_name = "604e",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fres,
.frsqrte,
}),
@@ -555,7 +459,7 @@ pub const cpu = struct {
pub const @"620" = Cpu{
.name = "620",
.llvm_name = "620",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fres,
.frsqrte,
}),
@@ -563,7 +467,7 @@ pub const cpu = struct {
pub const @"7400" = Cpu{
.name = "7400",
.llvm_name = "7400",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.altivec,
.fres,
.frsqrte,
@@ -572,7 +476,7 @@ pub const cpu = struct {
pub const @"7450" = Cpu{
.name = "7450",
.llvm_name = "7450",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.altivec,
.fres,
.frsqrte,
@@ -581,7 +485,7 @@ pub const cpu = struct {
pub const @"750" = Cpu{
.name = "750",
.llvm_name = "750",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fres,
.frsqrte,
}),
@@ -589,7 +493,7 @@ pub const cpu = struct {
pub const @"970" = Cpu{
.name = "970",
.llvm_name = "970",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.fres,
@@ -602,7 +506,7 @@ pub const cpu = struct {
pub const a2 = Cpu{
.name = "a2",
.llvm_name = "a2",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.booke,
.cmpb,
@@ -627,7 +531,7 @@ pub const cpu = struct {
pub const a2q = Cpu{
.name = "a2q",
.llvm_name = "a2q",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.booke,
.cmpb,
@@ -653,7 +557,7 @@ pub const cpu = struct {
pub const e500 = Cpu{
.name = "e500",
.llvm_name = "e500",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.booke,
.icbt,
.isel,
@@ -662,7 +566,7 @@ pub const cpu = struct {
pub const e500mc = Cpu{
.name = "e500mc",
.llvm_name = "e500mc",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.booke,
.icbt,
.isel,
@@ -672,7 +576,7 @@ pub const cpu = struct {
pub const e5500 = Cpu{
.name = "e5500",
.llvm_name = "e5500",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.booke,
.icbt,
@@ -684,7 +588,7 @@ pub const cpu = struct {
pub const g3 = Cpu{
.name = "g3",
.llvm_name = "g3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fres,
.frsqrte,
}),
@@ -692,7 +596,7 @@ pub const cpu = struct {
pub const g4 = Cpu{
.name = "g4",
.llvm_name = "g4",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.altivec,
.fres,
.frsqrte,
@@ -701,7 +605,7 @@ pub const cpu = struct {
pub const @"g4+" = Cpu{
.name = "g4+",
.llvm_name = "g4+",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.altivec,
.fres,
.frsqrte,
@@ -710,7 +614,7 @@ pub const cpu = struct {
pub const g5 = Cpu{
.name = "g5",
.llvm_name = "g5",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.fres,
@@ -723,28 +627,28 @@ pub const cpu = struct {
pub const generic = Cpu{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hard_float,
}),
};
pub const ppc = Cpu{
.name = "ppc",
.llvm_name = "ppc",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hard_float,
}),
};
pub const ppc32 = Cpu{
.name = "ppc32",
.llvm_name = "ppc32",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hard_float,
}),
};
pub const ppc64 = Cpu{
.name = "ppc64",
.llvm_name = "ppc64",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.fres,
@@ -757,7 +661,7 @@ pub const cpu = struct {
pub const ppc64le = Cpu{
.name = "ppc64le",
.llvm_name = "ppc64le",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.bpermd,
@@ -792,7 +696,7 @@ pub const cpu = struct {
pub const pwr3 = Cpu{
.name = "pwr3",
.llvm_name = "pwr3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.fres,
@@ -804,7 +708,7 @@ pub const cpu = struct {
pub const pwr4 = Cpu{
.name = "pwr4",
.llvm_name = "pwr4",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.fres,
@@ -817,7 +721,7 @@ pub const cpu = struct {
pub const pwr5 = Cpu{
.name = "pwr5",
.llvm_name = "pwr5",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.fre,
@@ -832,7 +736,7 @@ pub const cpu = struct {
pub const pwr5x = Cpu{
.name = "pwr5x",
.llvm_name = "pwr5x",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.fprnd,
@@ -848,7 +752,7 @@ pub const cpu = struct {
pub const pwr6 = Cpu{
.name = "pwr6",
.llvm_name = "pwr6",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.cmpb,
@@ -868,7 +772,7 @@ pub const cpu = struct {
pub const pwr6x = Cpu{
.name = "pwr6x",
.llvm_name = "pwr6x",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.cmpb,
@@ -888,7 +792,7 @@ pub const cpu = struct {
pub const pwr7 = Cpu{
.name = "pwr7",
.llvm_name = "pwr7",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.bpermd,
@@ -916,7 +820,7 @@ pub const cpu = struct {
pub const pwr8 = Cpu{
.name = "pwr8",
.llvm_name = "pwr8",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.bpermd,
@@ -951,7 +855,7 @@ pub const cpu = struct {
pub const pwr9 = Cpu{
.name = "pwr9",
.llvm_name = "pwr9",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.altivec,
.bpermd,

48
lib/std/target/riscv.zig
View File

@@ -16,66 +16,56 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.@"64bit")] = .{
.index = @enumToInt(Feature.@"64bit"),
.name = @tagName(Feature.@"64bit"),
.llvm_name = "64bit",
.description = "Implements RV64",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.a)] = .{
.index = @enumToInt(Feature.a),
.name = @tagName(Feature.a),
.llvm_name = "a",
.description = "'A' (Atomic Instructions)",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.c)] = .{
.index = @enumToInt(Feature.c),
.name = @tagName(Feature.c),
.llvm_name = "c",
.description = "'C' (Compressed Instructions)",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.d)] = .{
.index = @enumToInt(Feature.d),
.name = @tagName(Feature.d),
.llvm_name = "d",
.description = "'D' (Double-Precision Floating-Point)",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.f,
}),
};
result[@enumToInt(Feature.e)] = .{
.index = @enumToInt(Feature.e),
.name = @tagName(Feature.e),
.llvm_name = "e",
.description = "Implements RV32E (provides 16 rather than 32 GPRs)",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.f)] = .{
.index = @enumToInt(Feature.f),
.name = @tagName(Feature.f),
.llvm_name = "f",
.description = "'F' (Single-Precision Floating-Point)",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.m)] = .{
.index = @enumToInt(Feature.m),
.name = @tagName(Feature.m),
.llvm_name = "m",
.description = "'M' (Integer Multiplication and Division)",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.relax)] = .{
.index = @enumToInt(Feature.relax),
.name = @tagName(Feature.relax),
.llvm_name = "relax",
.description = "Enable Linker relaxation.",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -83,12 +73,12 @@ pub const cpu = struct {
pub const generic_rv32 = Cpu{
.name = "generic_rv32",
.llvm_name = "generic-rv32",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const generic_rv64 = Cpu{
.name = "generic_rv64",
.llvm_name = "generic-rv64",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.@"64bit",
}),
};
@@ -102,7 +92,7 @@ pub const all_cpus = &[_]*const Cpu{
&cpu.generic_rv64,
};
pub const baseline_32_features = featureSet(&[_]Feature{
pub const baseline_32_features = featureSet(&all_features, &[_]Feature{
.a,
.c,
.d,
@@ -111,7 +101,7 @@ pub const baseline_32_features = featureSet(&[_]Feature{
.relax,
});
pub const baseline_64_features = featureSet(&[_]Feature{
pub const baseline_64_features = featureSet(&all_features, &[_]Feature{
.@"64bit",
.a,
.c,

164
lib/std/target/sparc.zig
View File

@@ -27,141 +27,109 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.deprecated_v8)] = .{
.index = @enumToInt(Feature.deprecated_v8),
.name = @tagName(Feature.deprecated_v8),
.llvm_name = "deprecated-v8",
.description = "Enable deprecated V8 instructions in V9 mode",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.detectroundchange)] = .{
.index = @enumToInt(Feature.detectroundchange),
.name = @tagName(Feature.detectroundchange),
.llvm_name = "detectroundchange",
.description = "LEON3 erratum detection: Detects any rounding mode change request: use only the round-to-nearest rounding mode",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fixallfdivsqrt)] = .{
.index = @enumToInt(Feature.fixallfdivsqrt),
.name = @tagName(Feature.fixallfdivsqrt),
.llvm_name = "fixallfdivsqrt",
.description = "LEON erratum fix: Fix FDIVS/FDIVD/FSQRTS/FSQRTD instructions with NOPs and floating-point store",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hard_quad_float)] = .{
.index = @enumToInt(Feature.hard_quad_float),
.name = @tagName(Feature.hard_quad_float),
.llvm_name = "hard-quad-float",
.description = "Enable quad-word floating point instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hasleoncasa)] = .{
.index = @enumToInt(Feature.hasleoncasa),
.name = @tagName(Feature.hasleoncasa),
.llvm_name = "hasleoncasa",
.description = "Enable CASA instruction for LEON3 and LEON4 processors",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.hasumacsmac)] = .{
.index = @enumToInt(Feature.hasumacsmac),
.name = @tagName(Feature.hasumacsmac),
.llvm_name = "hasumacsmac",
.description = "Enable UMAC and SMAC for LEON3 and LEON4 processors",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.insertnopload)] = .{
.index = @enumToInt(Feature.insertnopload),
.name = @tagName(Feature.insertnopload),
.llvm_name = "insertnopload",
.description = "LEON3 erratum fix: Insert a NOP instruction after every single-cycle load instruction when the next instruction is another load/store instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.leon)] = .{
.index = @enumToInt(Feature.leon),
.name = @tagName(Feature.leon),
.llvm_name = "leon",
.description = "Enable LEON extensions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.leoncyclecounter)] = .{
.index = @enumToInt(Feature.leoncyclecounter),
.name = @tagName(Feature.leoncyclecounter),
.llvm_name = "leoncyclecounter",
.description = "Use the Leon cycle counter register",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.leonpwrpsr)] = .{
.index = @enumToInt(Feature.leonpwrpsr),
.name = @tagName(Feature.leonpwrpsr),
.llvm_name = "leonpwrpsr",
.description = "Enable the PWRPSR instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.no_fmuls)] = .{
.index = @enumToInt(Feature.no_fmuls),
.name = @tagName(Feature.no_fmuls),
.llvm_name = "no-fmuls",
.description = "Disable the fmuls instruction.",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.no_fsmuld)] = .{
.index = @enumToInt(Feature.no_fsmuld),
.name = @tagName(Feature.no_fsmuld),
.llvm_name = "no-fsmuld",
.description = "Disable the fsmuld instruction.",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.popc)] = .{
.index = @enumToInt(Feature.popc),
.name = @tagName(Feature.popc),
.llvm_name = "popc",
.description = "Use the popc (population count) instruction",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.soft_float)] = .{
.index = @enumToInt(Feature.soft_float),
.name = @tagName(Feature.soft_float),
.llvm_name = "soft-float",
.description = "Use software emulation for floating point",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.soft_mul_div)] = .{
.index = @enumToInt(Feature.soft_mul_div),
.name = @tagName(Feature.soft_mul_div),
.llvm_name = "soft-mul-div",
.description = "Use software emulation for integer multiply and divide",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.v9)] = .{
.index = @enumToInt(Feature.v9),
.name = @tagName(Feature.v9),
.llvm_name = "v9",
.description = "Enable SPARC-V9 instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vis)] = .{
.index = @enumToInt(Feature.vis),
.name = @tagName(Feature.vis),
.llvm_name = "vis",
.description = "Enable UltraSPARC Visual Instruction Set extensions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vis2)] = .{
.index = @enumToInt(Feature.vis2),
.name = @tagName(Feature.vis2),
.llvm_name = "vis2",
.description = "Enable Visual Instruction Set extensions II",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vis3)] = .{
.index = @enumToInt(Feature.vis3),
.name = @tagName(Feature.vis3),
.llvm_name = "vis3",
.description = "Enable Visual Instruction Set extensions III",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -169,7 +137,7 @@ pub const cpu = struct {
pub const at697e = Cpu{
.name = "at697e",
.llvm_name = "at697e",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.insertnopload,
.leon,
}),
@@ -177,7 +145,7 @@ pub const cpu = struct {
pub const at697f = Cpu{
.name = "at697f",
.llvm_name = "at697f",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.insertnopload,
.leon,
}),
@@ -185,17 +153,17 @@ pub const cpu = struct {
pub const f934 = Cpu{
.name = "f934",
.llvm_name = "f934",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const generic = Cpu{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const gr712rc = Cpu{
.name = "gr712rc",
.llvm_name = "gr712rc",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -203,7 +171,7 @@ pub const cpu = struct {
pub const gr740 = Cpu{
.name = "gr740",
.llvm_name = "gr740",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.hasumacsmac,
.leon,
@@ -214,19 +182,19 @@ pub const cpu = struct {
pub const hypersparc = Cpu{
.name = "hypersparc",
.llvm_name = "hypersparc",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const leon2 = Cpu{
.name = "leon2",
.llvm_name = "leon2",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.leon,
}),
};
pub const leon3 = Cpu{
.name = "leon3",
.llvm_name = "leon3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasumacsmac,
.leon,
}),
@@ -234,7 +202,7 @@ pub const cpu = struct {
pub const leon4 = Cpu{
.name = "leon4",
.llvm_name = "leon4",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.hasumacsmac,
.leon,
@@ -243,7 +211,7 @@ pub const cpu = struct {
pub const ma2080 = Cpu{
.name = "ma2080",
.llvm_name = "ma2080",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -251,7 +219,7 @@ pub const cpu = struct {
pub const ma2085 = Cpu{
.name = "ma2085",
.llvm_name = "ma2085",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -259,7 +227,7 @@ pub const cpu = struct {
pub const ma2100 = Cpu{
.name = "ma2100",
.llvm_name = "ma2100",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -267,7 +235,7 @@ pub const cpu = struct {
pub const ma2150 = Cpu{
.name = "ma2150",
.llvm_name = "ma2150",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -275,7 +243,7 @@ pub const cpu = struct {
pub const ma2155 = Cpu{
.name = "ma2155",
.llvm_name = "ma2155",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -283,7 +251,7 @@ pub const cpu = struct {
pub const ma2450 = Cpu{
.name = "ma2450",
.llvm_name = "ma2450",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -291,7 +259,7 @@ pub const cpu = struct {
pub const ma2455 = Cpu{
.name = "ma2455",
.llvm_name = "ma2455",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -299,7 +267,7 @@ pub const cpu = struct {
pub const ma2480 = Cpu{
.name = "ma2480",
.llvm_name = "ma2480",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -307,7 +275,7 @@ pub const cpu = struct {
pub const ma2485 = Cpu{
.name = "ma2485",
.llvm_name = "ma2485",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -315,7 +283,7 @@ pub const cpu = struct {
pub const ma2x5x = Cpu{
.name = "ma2x5x",
.llvm_name = "ma2x5x",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -323,7 +291,7 @@ pub const cpu = struct {
pub const ma2x8x = Cpu{
.name = "ma2x8x",
.llvm_name = "ma2x8x",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -331,7 +299,7 @@ pub const cpu = struct {
pub const myriad2 = Cpu{
.name = "myriad2",
.llvm_name = "myriad2",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -339,7 +307,7 @@ pub const cpu = struct {
pub const myriad2_1 = Cpu{
.name = "myriad2_1",
.llvm_name = "myriad2.1",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -347,7 +315,7 @@ pub const cpu = struct {
pub const myriad2_2 = Cpu{
.name = "myriad2_2",
.llvm_name = "myriad2.2",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -355,7 +323,7 @@ pub const cpu = struct {
pub const myriad2_3 = Cpu{
.name = "myriad2_3",
.llvm_name = "myriad2.3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.hasleoncasa,
.leon,
}),
@@ -363,7 +331,7 @@ pub const cpu = struct {
pub const niagara = Cpu{
.name = "niagara",
.llvm_name = "niagara",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.deprecated_v8,
.v9,
.vis,
@@ -373,7 +341,7 @@ pub const cpu = struct {
pub const niagara2 = Cpu{
.name = "niagara2",
.llvm_name = "niagara2",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.deprecated_v8,
.popc,
.v9,
@@ -384,7 +352,7 @@ pub const cpu = struct {
pub const niagara3 = Cpu{
.name = "niagara3",
.llvm_name = "niagara3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.deprecated_v8,
.popc,
.v9,
@@ -395,7 +363,7 @@ pub const cpu = struct {
pub const niagara4 = Cpu{
.name = "niagara4",
.llvm_name = "niagara4",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.deprecated_v8,
.popc,
.v9,
@@ -407,32 +375,32 @@ pub const cpu = struct {
pub const sparclet = Cpu{
.name = "sparclet",
.llvm_name = "sparclet",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const sparclite = Cpu{
.name = "sparclite",
.llvm_name = "sparclite",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const sparclite86x = Cpu{
.name = "sparclite86x",
.llvm_name = "sparclite86x",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const supersparc = Cpu{
.name = "supersparc",
.llvm_name = "supersparc",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const tsc701 = Cpu{
.name = "tsc701",
.llvm_name = "tsc701",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const ultrasparc = Cpu{
.name = "ultrasparc",
.llvm_name = "ultrasparc",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.deprecated_v8,
.v9,
.vis,
@@ -441,7 +409,7 @@ pub const cpu = struct {
pub const ultrasparc3 = Cpu{
.name = "ultrasparc3",
.llvm_name = "ultrasparc3",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.deprecated_v8,
.v9,
.vis,
@@ -451,7 +419,7 @@ pub const cpu = struct {
pub const ut699 = Cpu{
.name = "ut699",
.llvm_name = "ut699",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.fixallfdivsqrt,
.insertnopload,
.leon,
@@ -462,7 +430,7 @@ pub const cpu = struct {
pub const v7 = Cpu{
.name = "v7",
.llvm_name = "v7",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.no_fsmuld,
.soft_mul_div,
}),
@@ -470,12 +438,12 @@ pub const cpu = struct {
pub const v8 = Cpu{
.name = "v8",
.llvm_name = "v8",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const v9 = Cpu{
.name = "v9",
.llvm_name = "v9",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.v9,
}),
};

172
lib/std/target/systemz.zig
View File

@@ -43,253 +43,189 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.deflate_conversion)] = .{
.index = @enumToInt(Feature.deflate_conversion),
.name = @tagName(Feature.deflate_conversion),
.llvm_name = "deflate-conversion",
.description = "Assume that the deflate-conversion facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dfp_packed_conversion)] = .{
.index = @enumToInt(Feature.dfp_packed_conversion),
.name = @tagName(Feature.dfp_packed_conversion),
.llvm_name = "dfp-packed-conversion",
.description = "Assume that the DFP packed-conversion facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.dfp_zoned_conversion)] = .{
.index = @enumToInt(Feature.dfp_zoned_conversion),
.name = @tagName(Feature.dfp_zoned_conversion),
.llvm_name = "dfp-zoned-conversion",
.description = "Assume that the DFP zoned-conversion facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.distinct_ops)] = .{
.index = @enumToInt(Feature.distinct_ops),
.name = @tagName(Feature.distinct_ops),
.llvm_name = "distinct-ops",
.description = "Assume that the distinct-operands facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.enhanced_dat_2)] = .{
.index = @enumToInt(Feature.enhanced_dat_2),
.name = @tagName(Feature.enhanced_dat_2),
.llvm_name = "enhanced-dat-2",
.description = "Assume that the enhanced-DAT facility 2 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.enhanced_sort)] = .{
.index = @enumToInt(Feature.enhanced_sort),
.name = @tagName(Feature.enhanced_sort),
.llvm_name = "enhanced-sort",
.description = "Assume that the enhanced-sort facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.execution_hint)] = .{
.index = @enumToInt(Feature.execution_hint),
.name = @tagName(Feature.execution_hint),
.llvm_name = "execution-hint",
.description = "Assume that the execution-hint facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fast_serialization)] = .{
.index = @enumToInt(Feature.fast_serialization),
.name = @tagName(Feature.fast_serialization),
.llvm_name = "fast-serialization",
.description = "Assume that the fast-serialization facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.fp_extension)] = .{
.index = @enumToInt(Feature.fp_extension),
.name = @tagName(Feature.fp_extension),
.llvm_name = "fp-extension",
.description = "Assume that the floating-point extension facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.guarded_storage)] = .{
.index = @enumToInt(Feature.guarded_storage),
.name = @tagName(Feature.guarded_storage),
.llvm_name = "guarded-storage",
.description = "Assume that the guarded-storage facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.high_word)] = .{
.index = @enumToInt(Feature.high_word),
.name = @tagName(Feature.high_word),
.llvm_name = "high-word",
.description = "Assume that the high-word facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.insert_reference_bits_multiple)] = .{
.index = @enumToInt(Feature.insert_reference_bits_multiple),
.name = @tagName(Feature.insert_reference_bits_multiple),
.llvm_name = "insert-reference-bits-multiple",
.description = "Assume that the insert-reference-bits-multiple facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.interlocked_access1)] = .{
.index = @enumToInt(Feature.interlocked_access1),
.name = @tagName(Feature.interlocked_access1),
.llvm_name = "interlocked-access1",
.description = "Assume that interlocked-access facility 1 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.load_and_trap)] = .{
.index = @enumToInt(Feature.load_and_trap),
.name = @tagName(Feature.load_and_trap),
.llvm_name = "load-and-trap",
.description = "Assume that the load-and-trap facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.load_and_zero_rightmost_byte)] = .{
.index = @enumToInt(Feature.load_and_zero_rightmost_byte),
.name = @tagName(Feature.load_and_zero_rightmost_byte),
.llvm_name = "load-and-zero-rightmost-byte",
.description = "Assume that the load-and-zero-rightmost-byte facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.load_store_on_cond)] = .{
.index = @enumToInt(Feature.load_store_on_cond),
.name = @tagName(Feature.load_store_on_cond),
.llvm_name = "load-store-on-cond",
.description = "Assume that the load/store-on-condition facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.load_store_on_cond_2)] = .{
.index = @enumToInt(Feature.load_store_on_cond_2),
.name = @tagName(Feature.load_store_on_cond_2),
.llvm_name = "load-store-on-cond-2",
.description = "Assume that the load/store-on-condition facility 2 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.message_security_assist_extension3)] = .{
.index = @enumToInt(Feature.message_security_assist_extension3),
.name = @tagName(Feature.message_security_assist_extension3),
.llvm_name = "message-security-assist-extension3",
.description = "Assume that the message-security-assist extension facility 3 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.message_security_assist_extension4)] = .{
.index = @enumToInt(Feature.message_security_assist_extension4),
.name = @tagName(Feature.message_security_assist_extension4),
.llvm_name = "message-security-assist-extension4",
.description = "Assume that the message-security-assist extension facility 4 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.message_security_assist_extension5)] = .{
.index = @enumToInt(Feature.message_security_assist_extension5),
.name = @tagName(Feature.message_security_assist_extension5),
.llvm_name = "message-security-assist-extension5",
.description = "Assume that the message-security-assist extension facility 5 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.message_security_assist_extension7)] = .{
.index = @enumToInt(Feature.message_security_assist_extension7),
.name = @tagName(Feature.message_security_assist_extension7),
.llvm_name = "message-security-assist-extension7",
.description = "Assume that the message-security-assist extension facility 7 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.message_security_assist_extension8)] = .{
.index = @enumToInt(Feature.message_security_assist_extension8),
.name = @tagName(Feature.message_security_assist_extension8),
.llvm_name = "message-security-assist-extension8",
.description = "Assume that the message-security-assist extension facility 8 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.message_security_assist_extension9)] = .{
.index = @enumToInt(Feature.message_security_assist_extension9),
.name = @tagName(Feature.message_security_assist_extension9),
.llvm_name = "message-security-assist-extension9",
.description = "Assume that the message-security-assist extension facility 9 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.miscellaneous_extensions)] = .{
.index = @enumToInt(Feature.miscellaneous_extensions),
.name = @tagName(Feature.miscellaneous_extensions),
.llvm_name = "miscellaneous-extensions",
.description = "Assume that the miscellaneous-extensions facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.miscellaneous_extensions_2)] = .{
.index = @enumToInt(Feature.miscellaneous_extensions_2),
.name = @tagName(Feature.miscellaneous_extensions_2),
.llvm_name = "miscellaneous-extensions-2",
.description = "Assume that the miscellaneous-extensions facility 2 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.miscellaneous_extensions_3)] = .{
.index = @enumToInt(Feature.miscellaneous_extensions_3),
.name = @tagName(Feature.miscellaneous_extensions_3),
.llvm_name = "miscellaneous-extensions-3",
.description = "Assume that the miscellaneous-extensions facility 3 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.population_count)] = .{
.index = @enumToInt(Feature.population_count),
.name = @tagName(Feature.population_count),
.llvm_name = "population-count",
.description = "Assume that the population-count facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.processor_assist)] = .{
.index = @enumToInt(Feature.processor_assist),
.name = @tagName(Feature.processor_assist),
.llvm_name = "processor-assist",
.description = "Assume that the processor-assist facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.reset_reference_bits_multiple)] = .{
.index = @enumToInt(Feature.reset_reference_bits_multiple),
.name = @tagName(Feature.reset_reference_bits_multiple),
.llvm_name = "reset-reference-bits-multiple",
.description = "Assume that the reset-reference-bits-multiple facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.transactional_execution)] = .{
.index = @enumToInt(Feature.transactional_execution),
.name = @tagName(Feature.transactional_execution),
.llvm_name = "transactional-execution",
.description = "Assume that the transactional-execution facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vector)] = .{
.index = @enumToInt(Feature.vector),
.name = @tagName(Feature.vector),
.llvm_name = "vector",
.description = "Assume that the vectory facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vector_enhancements_1)] = .{
.index = @enumToInt(Feature.vector_enhancements_1),
.name = @tagName(Feature.vector_enhancements_1),
.llvm_name = "vector-enhancements-1",
.description = "Assume that the vector enhancements facility 1 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vector_enhancements_2)] = .{
.index = @enumToInt(Feature.vector_enhancements_2),
.name = @tagName(Feature.vector_enhancements_2),
.llvm_name = "vector-enhancements-2",
.description = "Assume that the vector enhancements facility 2 is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vector_packed_decimal)] = .{
.index = @enumToInt(Feature.vector_packed_decimal),
.name = @tagName(Feature.vector_packed_decimal),
.llvm_name = "vector-packed-decimal",
.description = "Assume that the vector packed decimal facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.vector_packed_decimal_enhancement)] = .{
.index = @enumToInt(Feature.vector_packed_decimal_enhancement),
.name = @tagName(Feature.vector_packed_decimal_enhancement),
.llvm_name = "vector-packed-decimal-enhancement",
.description = "Assume that the vector packed decimal enhancement facility is installed",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -297,7 +233,7 @@ pub const cpu = struct {
pub const arch10 = Cpu{
.name = "arch10",
.llvm_name = "arch10",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.dfp_zoned_conversion,
.distinct_ops,
.enhanced_dat_2,
@@ -320,7 +256,7 @@ pub const cpu = struct {
pub const arch11 = Cpu{
.name = "arch11",
.llvm_name = "arch11",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.dfp_packed_conversion,
.dfp_zoned_conversion,
.distinct_ops,
@@ -348,7 +284,7 @@ pub const cpu = struct {
pub const arch12 = Cpu{
.name = "arch12",
.llvm_name = "arch12",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.dfp_packed_conversion,
.dfp_zoned_conversion,
.distinct_ops,
@@ -383,7 +319,7 @@ pub const cpu = struct {
pub const arch13 = Cpu{
.name = "arch13",
.llvm_name = "arch13",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.deflate_conversion,
.dfp_packed_conversion,
.dfp_zoned_conversion,
@@ -424,12 +360,12 @@ pub const cpu = struct {
pub const arch8 = Cpu{
.name = "arch8",
.llvm_name = "arch8",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const arch9 = Cpu{
.name = "arch9",
.llvm_name = "arch9",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.distinct_ops,
.fast_serialization,
.fp_extension,
@@ -445,17 +381,17 @@ pub const cpu = struct {
pub const generic = Cpu{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const z10 = Cpu{
.name = "z10",
.llvm_name = "z10",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const z13 = Cpu{
.name = "z13",
.llvm_name = "z13",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.dfp_packed_conversion,
.dfp_zoned_conversion,
.distinct_ops,
@@ -483,7 +419,7 @@ pub const cpu = struct {
pub const z14 = Cpu{
.name = "z14",
.llvm_name = "z14",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.dfp_packed_conversion,
.dfp_zoned_conversion,
.distinct_ops,
@@ -518,7 +454,7 @@ pub const cpu = struct {
pub const z196 = Cpu{
.name = "z196",
.llvm_name = "z196",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.distinct_ops,
.fast_serialization,
.fp_extension,
@@ -534,7 +470,7 @@ pub const cpu = struct {
pub const zEC12 = Cpu{
.name = "zEC12",
.llvm_name = "zEC12",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.dfp_zoned_conversion,
.distinct_ops,
.enhanced_dat_2,

54
lib/std/target/wasm.zig
View File

@@ -18,80 +18,66 @@ pub usingnamespace Cpu.Feature.feature_set_fns(Feature);
pub const all_features = blk: {
const len = @typeInfo(Feature).Enum.fields.len;
std.debug.assert(len <= Cpu.Feature.Set.bit_count);
std.debug.assert(len <= Cpu.Feature.Set.needed_bit_count);
var result: [len]Cpu.Feature = undefined;
result[@enumToInt(Feature.atomics)] = .{
.index = @enumToInt(Feature.atomics),
.name = @tagName(Feature.atomics),
.llvm_name = "atomics",
.description = "Enable Atomics",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.bulk_memory)] = .{
.index = @enumToInt(Feature.bulk_memory),
.name = @tagName(Feature.bulk_memory),
.llvm_name = "bulk-memory",
.description = "Enable bulk memory operations",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.exception_handling)] = .{
.index = @enumToInt(Feature.exception_handling),
.name = @tagName(Feature.exception_handling),
.llvm_name = "exception-handling",
.description = "Enable Wasm exception handling",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.multivalue)] = .{
.index = @enumToInt(Feature.multivalue),
.name = @tagName(Feature.multivalue),
.llvm_name = "multivalue",
.description = "Enable multivalue blocks, instructions, and functions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.mutable_globals)] = .{
.index = @enumToInt(Feature.mutable_globals),
.name = @tagName(Feature.mutable_globals),
.llvm_name = "mutable-globals",
.description = "Enable mutable globals",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.nontrapping_fptoint)] = .{
.index = @enumToInt(Feature.nontrapping_fptoint),
.name = @tagName(Feature.nontrapping_fptoint),
.llvm_name = "nontrapping-fptoint",
.description = "Enable non-trapping float-to-int conversion operators",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.sign_ext)] = .{
.index = @enumToInt(Feature.sign_ext),
.name = @tagName(Feature.sign_ext),
.llvm_name = "sign-ext",
.description = "Enable sign extension operators",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.simd128)] = .{
.index = @enumToInt(Feature.simd128),
.name = @tagName(Feature.simd128),
.llvm_name = "simd128",
.description = "Enable 128-bit SIMD",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.tail_call)] = .{
.index = @enumToInt(Feature.tail_call),
.name = @tagName(Feature.tail_call),
.llvm_name = "tail-call",
.description = "Enable tail call instructions",
.dependencies = featureSet(&[_]Feature{}),
.dependencies = sparseFeatureSet(&[_]Feature{}),
};
result[@enumToInt(Feature.unimplemented_simd128)] = .{
.index = @enumToInt(Feature.unimplemented_simd128),
.name = @tagName(Feature.unimplemented_simd128),
.llvm_name = "unimplemented-simd128",
.description = "Enable 128-bit SIMD not yet implemented in engines",
.dependencies = featureSet(&[_]Feature{
.dependencies = sparseFeatureSet(&[_]Feature{
.simd128,
}),
};
const ti = @typeInfo(Feature);
for (result) |*elem, i| {
elem.index = i;
elem.name = ti.Enum.fields[i].name;
elem.dependencies.initAsDependencies(i, &result);
}
break :blk result;
};
@@ -99,7 +85,7 @@ pub const cpu = struct {
pub const bleeding_edge = Cpu{
.name = "bleeding_edge",
.llvm_name = "bleeding-edge",
.features = featureSet(&[_]Feature{
.features = featureSet(&all_features, &[_]Feature{
.atomics,
.mutable_globals,
.nontrapping_fptoint,
@@ -110,12 +96,12 @@ pub const cpu = struct {
pub const generic = Cpu{
.name = "generic",
.llvm_name = "generic",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
pub const mvp = Cpu{
.name = "mvp",
.llvm_name = "mvp",
.features = featureSet(&[_]Feature{}),
.features = featureSet(&all_features, &[_]Feature{}),
};
};

649
lib/std/target/x86.zig
View File

File diff suppressed because it is too large Load Diff

15
src-self-hosted/stage1.zig
View File

@@ -581,8 +581,8 @@ fn cpuFeaturesFromLLVM(
const this_llvm_name = feature.llvm_name orelse continue;
if (mem.eql(u8, llvm_feat, this_llvm_name)) {
switch (op) {
.add => set.addFeature(@intCast(u8, index)),
.sub => set.removeFeature(@intCast(u8, index)),
.add => set.addSparseFeature(@intCast(u8, index)),
.sub => set.removeSparseFeature(@intCast(u8, index)),
}
break;
}
@@ -676,7 +676,7 @@ const Stage2CpuFeatures = struct {
});
errdefer allocator.free(builtin_str);
const cache_hash = try std.fmt.allocPrint0(allocator, "{}\n{x}", .{ cpu.name, cpu.features.bytes });
const cache_hash = try std.fmt.allocPrint0(allocator, "{}\n{}", .{ cpu.name, cpu.features.asBytes() });
errdefer allocator.free(cache_hash);
self.* = Self{
@@ -699,10 +699,13 @@ const Stage2CpuFeatures = struct {
defer llvm_features_buffer.deinit();
const all_features = arch.allFeaturesList();
var populated_feature_set = feature_set;
if (arch.subArchFeature()) |sub_arch_index| {
populated_feature_set.addFeature(sub_arch_index, all_features);
}
for (all_features) |feature, index| {
const llvm_name = feature.llvm_name orelse continue;
const plus_or_minus = "-+"[@boolToInt(feature_set.isEnabled(@intCast(u8, index)))];
const plus_or_minus = "-+"[@boolToInt(populated_feature_set.isEnabled(@intCast(u8, index)))];
try llvm_features_buffer.appendByte(plus_or_minus);
try llvm_features_buffer.append(llvm_name);
try llvm_features_buffer.append(",");
@@ -721,7 +724,7 @@ const Stage2CpuFeatures = struct {
const self = try allocator.create(Self);
errdefer allocator.destroy(self);
const cache_hash = try std.fmt.allocPrint0(allocator, "\n{}", .{feature_set.bytes});
const cache_hash = try std.fmt.allocPrint0(allocator, "\n{}", .{feature_set.asBytes()});
errdefer allocator.free(cache_hash);
const generic_arch_name = arch.genericName();

1
src/all_types.hpp
View File

@@ -2144,6 +2144,7 @@ struct CodeGen {
bool verbose_llvm_ir;
bool verbose_cimport;
bool verbose_cc;
bool verbose_llvm_cpu_features;
bool error_during_imports;
bool generate_error_name_table;
bool enable_cache; // mutually exclusive with output_dir

6
src/codegen.cpp
View File

@@ -8802,8 +8802,10 @@ static void init(CodeGen *g) {
target_specific_cpu_args = stage2_cpu_features_get_llvm_cpu(g->zig_target->cpu_features);
target_specific_features = stage2_cpu_features_get_llvm_features(g->zig_target->cpu_features);
}
//fprintf(stderr, "name=%s target_specific_cpu_args=%s\n", buf_ptr(g->root_out_name), target_specific_cpu_args);
//fprintf(stderr, "name=%s target_specific_features=%s\n", buf_ptr(g->root_out_name), target_specific_features);
if (g->verbose_llvm_cpu_features) {
fprintf(stderr, "name=%s target_specific_cpu_args=%s\n", buf_ptr(g->root_out_name), target_specific_cpu_args);
fprintf(stderr, "name=%s target_specific_features=%s\n", buf_ptr(g->root_out_name), target_specific_features);
}
g->target_machine = ZigLLVMCreateTargetMachine(target_ref, buf_ptr(&g->llvm_triple_str),
target_specific_cpu_args, target_specific_features, opt_level, reloc_mode,

5
src/main.cpp
View File

@@ -93,6 +93,7 @@ static int print_full_usage(const char *arg0, FILE *file, int return_code) {
" --verbose-llvm-ir enable compiler debug output for LLVM IR\n"
" --verbose-cimport enable compiler debug output for C imports\n"
" --verbose-cc enable compiler debug output for C compilation\n"
" --verbose-llvm-cpu-features enable compiler debug output for LLVM CPU features\n"
" -dirafter [dir] add directory to AFTER include search path\n"
" -isystem [dir] add directory to SYSTEM include search path\n"
" -I[dir] add directory to include search path\n"
@@ -398,6 +399,7 @@ int main(int argc, char **argv) {
bool verbose_llvm_ir = false;
bool verbose_cimport = false;
bool verbose_cc = false;
bool verbose_llvm_cpu_features = false;
bool link_eh_frame_hdr = false;
ErrColor color = ErrColorAuto;
CacheOpt enable_cache = CacheOptAuto;
@@ -614,6 +616,8 @@ int main(int argc, char **argv) {
verbose_cimport = true;
} else if (strcmp(arg, "--verbose-cc") == 0) {
verbose_cc = true;
} else if (strcmp(arg, "--verbose-llvm-cpu-features") == 0) {
verbose_llvm_cpu_features = true;
} else if (strcmp(arg, "-rdynamic") == 0) {
rdynamic = true;
} else if (strcmp(arg, "--each-lib-rpath") == 0) {
@@ -1184,6 +1188,7 @@ int main(int argc, char **argv) {
g->verbose_llvm_ir = verbose_llvm_ir;
g->verbose_cimport = verbose_cimport;
g->verbose_cc = verbose_cc;
g->verbose_llvm_cpu_features = verbose_llvm_cpu_features;
g->output_dir = output_dir;
g->disable_gen_h = disable_gen_h;
g->bundle_compiler_rt = bundle_compiler_rt;