From 85b669d497641de383070353d50a6e4fd30abd49 Mon Sep 17 00:00:00 2001 From: Luuk de Gram Date: Wed, 19 Oct 2022 21:48:21 +0200 Subject: wasm-linker: validate feature compatibility Verifies disallowed and used/required features. After verifying, all errors will be emit to notify the user about incompatible features. When the user did not define any featureset, we infer the features from the linked objects instead. --- src/link/Wasm.zig | 107 ++++++++++++++++++++++++++++++++++++++++++++++++ src/link/Wasm/types.zig | 24 +++++------ 2 files changed, 117 insertions(+), 14 deletions(-) (limited to 'src') diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index 4c3de84e01..ed07756345 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -651,6 +651,112 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void { } } +fn validateFeatures(wasm: *const Wasm, arena: Allocator) !void { + const cpu_features = wasm.base.options.target.cpu.features; + const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects. + var allowed = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena); + var used = std.AutoArrayHashMap(std.Target.wasm.Feature, []const u8).init(arena); + var disallowed = std.AutoHashMap(std.Target.wasm.Feature, []const u8).init(arena); + var required = std.AutoHashMap(std.Target.wasm.Feature, []const u8).init(arena); + + // when false, we fail linking. We only verify this after a loop to catch all invalid features. + var valid_feature_set = true; + + // When the user has given an explicit list of features to enable, + // we extract them and insert each into the 'allowed' list. + if (!infer) { + try allowed.ensureUnusedCapacity(std.Target.wasm.all_features.len); + // std.builtin.Type.EnumField + inline for (@typeInfo(std.Target.wasm.Feature).Enum.fields) |feature_field| { + if (cpu_features.isEnabled(feature_field.value)) { + allowed.putAssumeCapacityNoClobber(@intToEnum(std.Target.wasm.Feature, feature_field.value), {}); + } + } + } + + // extract all the used, disallowed and required features from each + // linked object file so we can test them. + for (wasm.objects.items) |object| { + for (object.features) |feature| { + switch (feature.prefix) { + .used => { + const gop = try used.getOrPut(feature.tag); + if (!gop.found_existing) { + gop.value_ptr.* = object.name; + } + }, + .disallowed => { + const gop = try disallowed.getOrPut(feature.tag); + if (!gop.found_existing) { + gop.value_ptr.* = object.name; + } + }, + .required => { + const gop = try required.getOrPut(feature.tag); + if (!gop.found_existing) { + gop.value_ptr.* = object.name; + } + const used_gop = try used.getOrPut(feature.tag); + if (!used_gop.found_existing) { + used_gop.value_ptr.* = object.name; + } + }, + } + } + } + + // when we infer the features, we allow each feature found in the 'used' set + // and insert it into the 'allowed' set. When features are not inferred, + // we validate that a used feature is allowed. + if (infer) try allowed.ensureUnusedCapacity(@intCast(u32, used.count())); + for (used.keys()) |used_feature, used_index| { + if (infer) { + allowed.putAssumeCapacityNoClobber(used_feature, {}); + } else if (!allowed.contains(used_feature)) { + log.err("feature '{s}' not allowed, but used by linked object", .{@tagName(used_feature)}); + log.err(" defined in '{s}'", .{used.values()[used_index]}); + valid_feature_set = false; + } + } + + if (!valid_feature_set) { + return error.InvalidFeatureSet; + } + + // For each linked object, validate the required and disallowed features + for (wasm.objects.items) |object| { + var object_used_features = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena); + try object_used_features.ensureTotalCapacity(@intCast(u32, object.features.len)); + for (object.features) |feature| { + if (feature.prefix == .disallowed) continue; // already defined in 'disallowed' set. + // from here a feature is always used + if (disallowed.get(feature.tag)) |disallowed_object_name| { + log.err("feature '{s}' is disallowed, but used by linked object", .{@tagName(feature.tag)}); + log.err(" disallowed by '{s}'", .{disallowed_object_name}); + log.err(" used in '{s}'", .{object.name}); + valid_feature_set = false; + } + + object_used_features.putAssumeCapacity(feature.tag, {}); + } + + // validate the linked object file has each required feature + var required_it = required.iterator(); + while (required_it.next()) |required_feature| { + if (!object_used_features.contains(required_feature.key_ptr.*)) { + log.err("feature '{s}' is required but not used in linked object", .{@tagName(required_feature.key_ptr.*)}); + log.err(" required by '{s}'", .{required_feature.value_ptr.*}); + log.err(" missing in '{s}'", .{object.name}); + valid_feature_set = false; + } + } + } + + if (!valid_feature_set) { + return error.InvalidFeatureSet; + } +} + fn checkUndefinedSymbols(wasm: *const Wasm) !void { if (wasm.base.options.output_mode == .Obj) return; @@ -2158,6 +2264,7 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod try wasm.resolveSymbolsInObject(@intCast(u16, object_index)); } + try wasm.validateFeatures(arena); try wasm.resolveSymbolsInArchives(); try wasm.checkUndefinedSymbols(); diff --git a/src/link/Wasm/types.zig b/src/link/Wasm/types.zig index 2006fe1812..5e071c2f20 100644 --- a/src/link/Wasm/types.zig +++ b/src/link/Wasm/types.zig @@ -183,18 +183,7 @@ pub const Feature = struct { /// Type of the feature, must be unique in the sequence of features. tag: Tag, - pub const Tag = enum { - atomics, - bulk_memory, - exception_handling, - multivalue, - mutable_globals, - nontrapping_fptoint, - sign_ext, - simd128, - tail_call, - shared_mem, - }; + pub const Tag = std.Target.wasm.Feature; pub const Prefix = enum(u8) { used = '+', @@ -204,13 +193,18 @@ pub const Feature = struct { pub fn toString(feature: Feature) []const u8 { return switch (feature.tag) { + .atomics => "atomics", .bulk_memory => "bulk-memory", .exception_handling => "exception-handling", + .extended_const => "extended-const", + .multivalue => "multivalue", .mutable_globals => "mutable-globals", .nontrapping_fptoint => "nontrapping-fptoint", + .reference_types => "reference-types", + .relaxed_simd => "relaxed-simd", .sign_ext => "sign-ext", + .simd128 => "simd128", .tail_call => "tail-call", - else => @tagName(feature), }; } @@ -225,11 +219,13 @@ pub const known_features = std.ComptimeStringMap(Feature.Tag, .{ .{ "atomics", .atomics }, .{ "bulk-memory", .bulk_memory }, .{ "exception-handling", .exception_handling }, + .{ "extended-const", .extended_const }, .{ "multivalue", .multivalue }, .{ "mutable-globals", .mutable_globals }, .{ "nontrapping-fptoint", .nontrapping_fptoint }, + .{ "reference-types", .reference_types }, + .{ "relaxed-simd", .relaxed_simd }, .{ "sign-ext", .sign_ext }, .{ "simd128", .simd128 }, .{ "tail-call", .tail_call }, - .{ "shared-mem", .shared_mem }, }); -- cgit v1.2.3 From 777bcbf96871a0250664b9cabdea5dbf51e0e64d Mon Sep 17 00:00:00 2001 From: Luuk de Gram Date: Thu, 20 Oct 2022 16:58:00 +0200 Subject: wasm-linker: emit `target_features` section When the result is not being stripped, we emit the `target_features` section based on all the used features. This includes features inferred from linked object files. Considering we know all possible features upfront, we can use an array and therefore do not have to dynamically allocate memory. Using this trick we can also easily order all features based the same ordering as found in `std.Target.wasm` which is the same ordering used by LLVM and the like. --- src/link/Wasm.zig | 47 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 45 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index ed07756345..da9a878720 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -651,7 +651,12 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void { } } -fn validateFeatures(wasm: *const Wasm, arena: Allocator) !void { +fn validateFeatures( + wasm: *const Wasm, + arena: Allocator, + to_emit: *[@typeInfo(std.Target.wasm.Feature).Enum.fields.len]bool, + emit_features_count: *u32, +) !void { const cpu_features = wasm.base.options.target.cpu.features; const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects. var allowed = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena); @@ -755,6 +760,13 @@ fn validateFeatures(wasm: *const Wasm, arena: Allocator) !void { if (!valid_feature_set) { return error.InvalidFeatureSet; } + + if (allowed.count() > 0) { + emit_features_count.* = allowed.count(); + for (to_emit) |*feature_enabled, feature_index| { + feature_enabled.* = allowed.contains(@intToEnum(std.Target.wasm.Feature, feature_index)); + } + } } fn checkUndefinedSymbols(wasm: *const Wasm) !void { @@ -2264,7 +2276,9 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod try wasm.resolveSymbolsInObject(@intCast(u16, object_index)); } - try wasm.validateFeatures(arena); + var emit_features_count: u32 = 0; + var enabled_features: [@typeInfo(std.Target.wasm.Feature).Enum.fields.len]bool = undefined; + try wasm.validateFeatures(arena, &enabled_features, &emit_features_count); try wasm.resolveSymbolsInArchives(); try wasm.checkUndefinedSymbols(); @@ -2710,6 +2724,9 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod } try emitProducerSection(&binary_bytes); + if (emit_features_count > 0) { + try emitFeaturesSection(&binary_bytes, &enabled_features, emit_features_count); + } } // Only when writing all sections executed properly we write the magic @@ -2802,6 +2819,32 @@ fn emitProducerSection(binary_bytes: *std.ArrayList(u8)) !void { ); } +fn emitFeaturesSection(binary_bytes: *std.ArrayList(u8), enabled_features: []const bool, features_count: u32) !void { + const header_offset = try reserveCustomSectionHeader(binary_bytes); + + const writer = binary_bytes.writer(); + const target_features = "target_features"; + try leb.writeULEB128(writer, @intCast(u32, target_features.len)); + try writer.writeAll(target_features); + + try leb.writeULEB128(writer, features_count); + for (enabled_features) |enabled, feature_index| { + if (enabled) { + const feature: types.Feature = .{ .prefix = .used, .tag = @intToEnum(types.Feature.Tag, feature_index) }; + try leb.writeULEB128(writer, @enumToInt(feature.prefix)); + const string = feature.toString(); + try leb.writeULEB128(writer, @intCast(u32, string.len)); + try writer.writeAll(string); + } + } + + try writeCustomSectionHeader( + binary_bytes.items, + header_offset, + @intCast(u32, binary_bytes.items.len - header_offset - 6), + ); +} + fn emitNameSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), arena: std.mem.Allocator) !void { const Name = struct { index: u32, -- cgit v1.2.3 From 3d1d19f3877190db42544acf9e0ed26784ba82ba Mon Sep 17 00:00:00 2001 From: Luuk de Gram Date: Sun, 23 Oct 2022 20:02:25 +0200 Subject: wasm-linker: seperate linker -and cpu features The list of features a Wasm object/binary file can emit can differ from the list of cpu features. The reason for this is because the "target_features" section also contains linker features. An example of this is the "shared-mem" feature, which is a feature for the linker and not that of the cpu target as defined by LLVM. --- src/link/Wasm.zig | 18 +++++++++--------- src/link/Wasm/types.zig | 24 +++++++++++++++++++++++- 2 files changed, 32 insertions(+), 10 deletions(-) (limited to 'src') diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index da9a878720..4b6895c4e5 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -654,15 +654,15 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void { fn validateFeatures( wasm: *const Wasm, arena: Allocator, - to_emit: *[@typeInfo(std.Target.wasm.Feature).Enum.fields.len]bool, + to_emit: *[@typeInfo(types.Feature.Tag).Enum.fields.len]bool, emit_features_count: *u32, ) !void { const cpu_features = wasm.base.options.target.cpu.features; const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects. - var allowed = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena); - var used = std.AutoArrayHashMap(std.Target.wasm.Feature, []const u8).init(arena); - var disallowed = std.AutoHashMap(std.Target.wasm.Feature, []const u8).init(arena); - var required = std.AutoHashMap(std.Target.wasm.Feature, []const u8).init(arena); + var allowed = std.AutoHashMap(types.Feature.Tag, void).init(arena); + var used = std.AutoArrayHashMap(types.Feature.Tag, []const u8).init(arena); + var disallowed = std.AutoHashMap(types.Feature.Tag, []const u8).init(arena); + var required = std.AutoHashMap(types.Feature.Tag, []const u8).init(arena); // when false, we fail linking. We only verify this after a loop to catch all invalid features. var valid_feature_set = true; @@ -674,7 +674,7 @@ fn validateFeatures( // std.builtin.Type.EnumField inline for (@typeInfo(std.Target.wasm.Feature).Enum.fields) |feature_field| { if (cpu_features.isEnabled(feature_field.value)) { - allowed.putAssumeCapacityNoClobber(@intToEnum(std.Target.wasm.Feature, feature_field.value), {}); + allowed.putAssumeCapacityNoClobber(@intToEnum(types.Feature.Tag, feature_field.value), {}); } } } @@ -730,7 +730,7 @@ fn validateFeatures( // For each linked object, validate the required and disallowed features for (wasm.objects.items) |object| { - var object_used_features = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena); + var object_used_features = std.AutoHashMap(types.Feature.Tag, void).init(arena); try object_used_features.ensureTotalCapacity(@intCast(u32, object.features.len)); for (object.features) |feature| { if (feature.prefix == .disallowed) continue; // already defined in 'disallowed' set. @@ -764,7 +764,7 @@ fn validateFeatures( if (allowed.count() > 0) { emit_features_count.* = allowed.count(); for (to_emit) |*feature_enabled, feature_index| { - feature_enabled.* = allowed.contains(@intToEnum(std.Target.wasm.Feature, feature_index)); + feature_enabled.* = allowed.contains(@intToEnum(types.Feature.Tag, feature_index)); } } } @@ -2277,7 +2277,7 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod } var emit_features_count: u32 = 0; - var enabled_features: [@typeInfo(std.Target.wasm.Feature).Enum.fields.len]bool = undefined; + var enabled_features: [@typeInfo(types.Feature.Tag).Enum.fields.len]bool = undefined; try wasm.validateFeatures(arena, &enabled_features, &emit_features_count); try wasm.resolveSymbolsInArchives(); try wasm.checkUndefinedSymbols(); diff --git a/src/link/Wasm/types.zig b/src/link/Wasm/types.zig index 5e071c2f20..1b6df86d37 100644 --- a/src/link/Wasm/types.zig +++ b/src/link/Wasm/types.zig @@ -183,7 +183,27 @@ pub const Feature = struct { /// Type of the feature, must be unique in the sequence of features. tag: Tag, - pub const Tag = std.Target.wasm.Feature; + /// Unlike `std.Target.wasm.Feature` this also contains linker-features such as shared-mem + pub const Tag = enum { + atomics, + bulk_memory, + exception_handling, + extended_const, + multivalue, + mutable_globals, + nontrapping_fptoint, + reference_types, + relaxed_simd, + sign_ext, + simd128, + tail_call, + shared_mem, + + /// From a given cpu feature, returns its linker feature + pub fn fromCpuFeature(feature: std.Target.wasm.Feature) Tag { + return @intToEnum(Tag, @enumToInt(feature)); + } + }; pub const Prefix = enum(u8) { used = '+', @@ -205,6 +225,7 @@ pub const Feature = struct { .sign_ext => "sign-ext", .simd128 => "simd128", .tail_call => "tail-call", + .shared_mem => "shared-mem", }; } @@ -228,4 +249,5 @@ pub const known_features = std.ComptimeStringMap(Feature.Tag, .{ .{ "sign-ext", .sign_ext }, .{ "simd128", .simd128 }, .{ "tail-call", .tail_call }, + .{ "shared-mem", .shared_mem }, }); -- cgit v1.2.3 From c0710b0c42716bb7173b9fcc2785f9bf5175ae0f Mon Sep 17 00:00:00 2001 From: Luuk de Gram Date: Tue, 25 Oct 2022 21:16:51 +0200 Subject: use fixed-size arrays for feature lists Considering all possible features are known by the linker during compile-time, we can create arrays on the stack instead of dynamically allocating hash maps. We use a simple bitset to determine whether a feature is enabled or not, and from which object file it originates. This allows us to make feature validation slightly faster and use less runtime memory. In the future this could be enhanced further by having a single array instead with a more sophisticated bitset. --- src/link.zig | 1 + src/link/Wasm.zig | 85 ++++++++++++++++++++----------------------------- src/link/Wasm/types.zig | 38 +++++++++++----------- 3 files changed, 55 insertions(+), 69 deletions(-) (limited to 'src') diff --git a/src/link.zig b/src/link.zig index 9d4ac0d55b..39f51e90ec 100644 --- a/src/link.zig +++ b/src/link.zig @@ -696,6 +696,7 @@ pub const File = struct { GlobalTypeMismatch, InvalidCharacter, InvalidEntryKind, + InvalidFeatureSet, InvalidFormat, InvalidIndex, InvalidMagicByte, diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index 4b6895c4e5..b9f2d74bd8 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -653,16 +653,17 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void { fn validateFeatures( wasm: *const Wasm, - arena: Allocator, to_emit: *[@typeInfo(types.Feature.Tag).Enum.fields.len]bool, emit_features_count: *u32, ) !void { const cpu_features = wasm.base.options.target.cpu.features; const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects. - var allowed = std.AutoHashMap(types.Feature.Tag, void).init(arena); - var used = std.AutoArrayHashMap(types.Feature.Tag, []const u8).init(arena); - var disallowed = std.AutoHashMap(types.Feature.Tag, []const u8).init(arena); - var required = std.AutoHashMap(types.Feature.Tag, []const u8).init(arena); + const known_features_count = @typeInfo(types.Feature.Tag).Enum.fields.len; + + var allowed = [_]bool{false} ** known_features_count; + var used = [_]u17{0} ** known_features_count; + var disallowed = [_]u17{0} ** known_features_count; + var required = [_]u17{0} ** known_features_count; // when false, we fail linking. We only verify this after a loop to catch all invalid features. var valid_feature_set = true; @@ -670,41 +671,29 @@ fn validateFeatures( // When the user has given an explicit list of features to enable, // we extract them and insert each into the 'allowed' list. if (!infer) { - try allowed.ensureUnusedCapacity(std.Target.wasm.all_features.len); - // std.builtin.Type.EnumField inline for (@typeInfo(std.Target.wasm.Feature).Enum.fields) |feature_field| { if (cpu_features.isEnabled(feature_field.value)) { - allowed.putAssumeCapacityNoClobber(@intToEnum(types.Feature.Tag, feature_field.value), {}); + allowed[feature_field.value] = true; + emit_features_count.* += 1; } } } // extract all the used, disallowed and required features from each // linked object file so we can test them. - for (wasm.objects.items) |object| { + for (wasm.objects.items) |object, object_index| { for (object.features) |feature| { + const value = @intCast(u16, object_index) << 1 | @as(u1, 1); switch (feature.prefix) { .used => { - const gop = try used.getOrPut(feature.tag); - if (!gop.found_existing) { - gop.value_ptr.* = object.name; - } + used[@enumToInt(feature.tag)] = value; }, .disallowed => { - const gop = try disallowed.getOrPut(feature.tag); - if (!gop.found_existing) { - gop.value_ptr.* = object.name; - } + disallowed[@enumToInt(feature.tag)] = value; }, .required => { - const gop = try required.getOrPut(feature.tag); - if (!gop.found_existing) { - gop.value_ptr.* = object.name; - } - const used_gop = try used.getOrPut(feature.tag); - if (!used_gop.found_existing) { - used_gop.value_ptr.* = object.name; - } + required[@enumToInt(feature.tag)] = value; + used[@enumToInt(feature.tag)] = value; }, } } @@ -713,13 +702,14 @@ fn validateFeatures( // when we infer the features, we allow each feature found in the 'used' set // and insert it into the 'allowed' set. When features are not inferred, // we validate that a used feature is allowed. - if (infer) try allowed.ensureUnusedCapacity(@intCast(u32, used.count())); - for (used.keys()) |used_feature, used_index| { + for (used) |used_set, used_index| { + const is_enabled = @truncate(u1, used_set) != 0; if (infer) { - allowed.putAssumeCapacityNoClobber(used_feature, {}); - } else if (!allowed.contains(used_feature)) { - log.err("feature '{s}' not allowed, but used by linked object", .{@tagName(used_feature)}); - log.err(" defined in '{s}'", .{used.values()[used_index]}); + allowed[used_index] = is_enabled; + emit_features_count.* += @boolToInt(is_enabled); + } else if (is_enabled and !allowed[used_index]) { + log.err("feature '{s}' not allowed, but used by linked object", .{(@intToEnum(types.Feature.Tag, used_index)).toString()}); + log.err(" defined in '{s}'", .{wasm.objects.items[used_set >> 1].name}); valid_feature_set = false; } } @@ -730,27 +720,27 @@ fn validateFeatures( // For each linked object, validate the required and disallowed features for (wasm.objects.items) |object| { - var object_used_features = std.AutoHashMap(types.Feature.Tag, void).init(arena); - try object_used_features.ensureTotalCapacity(@intCast(u32, object.features.len)); + var object_used_features = [_]bool{false} ** known_features_count; for (object.features) |feature| { if (feature.prefix == .disallowed) continue; // already defined in 'disallowed' set. // from here a feature is always used - if (disallowed.get(feature.tag)) |disallowed_object_name| { - log.err("feature '{s}' is disallowed, but used by linked object", .{@tagName(feature.tag)}); - log.err(" disallowed by '{s}'", .{disallowed_object_name}); + const disallowed_feature = disallowed[@enumToInt(feature.tag)]; + if (@truncate(u1, disallowed_feature) != 0) { + log.err("feature '{s}' is disallowed, but used by linked object", .{feature.tag.toString()}); + log.err(" disallowed by '{s}'", .{wasm.objects.items[disallowed_feature >> 1].name}); log.err(" used in '{s}'", .{object.name}); valid_feature_set = false; } - object_used_features.putAssumeCapacity(feature.tag, {}); + object_used_features[@enumToInt(feature.tag)] = true; } // validate the linked object file has each required feature - var required_it = required.iterator(); - while (required_it.next()) |required_feature| { - if (!object_used_features.contains(required_feature.key_ptr.*)) { - log.err("feature '{s}' is required but not used in linked object", .{@tagName(required_feature.key_ptr.*)}); - log.err(" required by '{s}'", .{required_feature.value_ptr.*}); + for (required) |required_feature, feature_index| { + const is_required = @truncate(u1, required_feature) != 0; + if (is_required and !object_used_features[feature_index]) { + log.err("feature '{s}' is required but not used in linked object", .{(@intToEnum(types.Feature.Tag, feature_index)).toString()}); + log.err(" required by '{s}'", .{wasm.objects.items[required_feature >> 1].name}); log.err(" missing in '{s}'", .{object.name}); valid_feature_set = false; } @@ -761,12 +751,7 @@ fn validateFeatures( return error.InvalidFeatureSet; } - if (allowed.count() > 0) { - emit_features_count.* = allowed.count(); - for (to_emit) |*feature_enabled, feature_index| { - feature_enabled.* = allowed.contains(@intToEnum(types.Feature.Tag, feature_index)); - } - } + to_emit.* = allowed; } fn checkUndefinedSymbols(wasm: *const Wasm) !void { @@ -2278,7 +2263,7 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod var emit_features_count: u32 = 0; var enabled_features: [@typeInfo(types.Feature.Tag).Enum.fields.len]bool = undefined; - try wasm.validateFeatures(arena, &enabled_features, &emit_features_count); + try wasm.validateFeatures(&enabled_features, &emit_features_count); try wasm.resolveSymbolsInArchives(); try wasm.checkUndefinedSymbols(); @@ -2832,7 +2817,7 @@ fn emitFeaturesSection(binary_bytes: *std.ArrayList(u8), enabled_features: []con if (enabled) { const feature: types.Feature = .{ .prefix = .used, .tag = @intToEnum(types.Feature.Tag, feature_index) }; try leb.writeULEB128(writer, @enumToInt(feature.prefix)); - const string = feature.toString(); + const string = feature.tag.toString(); try leb.writeULEB128(writer, @intCast(u32, string.len)); try writer.writeAll(string); } diff --git a/src/link/Wasm/types.zig b/src/link/Wasm/types.zig index 1b6df86d37..a46fad4e53 100644 --- a/src/link/Wasm/types.zig +++ b/src/link/Wasm/types.zig @@ -203,6 +203,24 @@ pub const Feature = struct { pub fn fromCpuFeature(feature: std.Target.wasm.Feature) Tag { return @intToEnum(Tag, @enumToInt(feature)); } + + pub fn toString(tag: Tag) []const u8 { + return switch (tag) { + .atomics => "atomics", + .bulk_memory => "bulk-memory", + .exception_handling => "exception-handling", + .extended_const => "extended-const", + .multivalue => "multivalue", + .mutable_globals => "mutable-globals", + .nontrapping_fptoint => "nontrapping-fptoint", + .reference_types => "reference-types", + .relaxed_simd => "relaxed-simd", + .sign_ext => "sign-ext", + .simd128 => "simd128", + .tail_call => "tail-call", + .shared_mem => "shared-mem", + }; + } }; pub const Prefix = enum(u8) { @@ -211,28 +229,10 @@ pub const Feature = struct { required = '=', }; - pub fn toString(feature: Feature) []const u8 { - return switch (feature.tag) { - .atomics => "atomics", - .bulk_memory => "bulk-memory", - .exception_handling => "exception-handling", - .extended_const => "extended-const", - .multivalue => "multivalue", - .mutable_globals => "mutable-globals", - .nontrapping_fptoint => "nontrapping-fptoint", - .reference_types => "reference-types", - .relaxed_simd => "relaxed-simd", - .sign_ext => "sign-ext", - .simd128 => "simd128", - .tail_call => "tail-call", - .shared_mem => "shared-mem", - }; - } - pub fn format(feature: Feature, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void { _ = opt; _ = fmt; - try writer.print("{c} {s}", .{ feature.prefix, feature.toString() }); + try writer.print("{c} {s}", .{ feature.prefix, feature.tag.toString() }); } }; -- cgit v1.2.3