authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-03-03 01:18:23-05:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-03-05 02:59:01-05:00
log93d696e84ef17a32d5c2f1520a295ebcda968e91
tree7494db8b659f454b31025c4a3660e98c06860d34
parenta8f4ac2b94e7945a5a1623547f258f5f32f12674

CBE: implement some big integer and vector unary operations

5 files changed, 460 insertions(+), 23 deletions(-)

lib/zig.h+414-8
......@@ -1919,7 +1919,7 @@ static inline zig_i128 zig_bit_reverse_i128(zig_i128 val, uint8_t bits) {
19191919
19201920/* ========================== Big Integer Support =========================== */
19211921
1922static inline uint16_t zig_big_bytes(uint16_t bits) {
1922static inline uint16_t zig_int_bytes(uint16_t bits) {
19231923 uint16_t bytes = (bits + CHAR_BIT - 1) / CHAR_BIT;
19241924 uint16_t alignment = 16;
19251925 while (alignment / 2 >= bytes) alignment /= 2;
......@@ -1931,7 +1931,7 @@ static inline int32_t zig_cmp_big(const void *lhs, const void *rhs, bool is_sign
19311931 const uint8_t *rhs_bytes = rhs;
19321932 uint16_t byte_offset = 0;
19331933 bool do_signed = is_signed;
1934 uint16_t remaining_bytes = zig_big_bytes(bits);
1934 uint16_t remaining_bytes = zig_int_bytes(bits);
19351935
19361936#if zig_little_endian
19371937 byte_offset = remaining_bytes;
......@@ -1965,7 +1965,7 @@ static inline int32_t zig_cmp_big(const void *lhs, const void *rhs, bool is_sign
19651965 remaining_bytes -= 128 / CHAR_BIT;
19661966
19671967#if zig_big_endian
1968 byte_offset -= 128 / CHAR_BIT;
1968 byte_offset += 128 / CHAR_BIT;
19691969#endif
19701970 }
19711971
......@@ -1994,7 +1994,7 @@ static inline int32_t zig_cmp_big(const void *lhs, const void *rhs, bool is_sign
19941994 remaining_bytes -= 64 / CHAR_BIT;
19951995
19961996#if zig_big_endian
1997 byte_offset -= 64 / CHAR_BIT;
1997 byte_offset += 64 / CHAR_BIT;
19981998#endif
19991999 }
20002000
......@@ -2023,7 +2023,7 @@ static inline int32_t zig_cmp_big(const void *lhs, const void *rhs, bool is_sign
20232023 remaining_bytes -= 32 / CHAR_BIT;
20242024
20252025#if zig_big_endian
2026 byte_offset -= 32 / CHAR_BIT;
2026 byte_offset += 32 / CHAR_BIT;
20272027#endif
20282028 }
20292029
......@@ -2052,7 +2052,7 @@ static inline int32_t zig_cmp_big(const void *lhs, const void *rhs, bool is_sign
20522052 remaining_bytes -= 16 / CHAR_BIT;
20532053
20542054#if zig_big_endian
2055 byte_offset -= 16 / CHAR_BIT;
2055 byte_offset += 16 / CHAR_BIT;
20562056#endif
20572057 }
20582058
......@@ -2081,13 +2081,368 @@ static inline int32_t zig_cmp_big(const void *lhs, const void *rhs, bool is_sign
20812081 remaining_bytes -= 8 / CHAR_BIT;
20822082
20832083#if zig_big_endian
2084 byte_offset -= 8 / CHAR_BIT;
2084 byte_offset += 8 / CHAR_BIT;
20852085#endif
20862086 }
20872087
20882088 return 0;
20892089}
20902090
2091static inline uint16_t zig_clz_big(const void *val, bool is_signed, uint16_t bits) {
2092 const uint8_t *val_bytes = val;
2093 uint16_t byte_offset = 0;
2094 uint16_t remaining_bytes = zig_int_bytes(bits);
2095 uint16_t skip_bits = remaining_bytes * 8 - bits;
2096 uint16_t total_lz = 0;
2097 uint16_t limb_lz;
2098 (void)is_signed;
2099
2100#if zig_little_endian
2101 byte_offset = remaining_bytes;
2102#endif
2103
2104 while (remaining_bytes >= 128 / CHAR_BIT) {
2105#if zig_little_endian
2106 byte_offset -= 128 / CHAR_BIT;
2107#endif
2108
2109 {
2110 zig_u128 val_limb;
2111
2112 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2113 limb_lz = zig_clz_u128(val_limb, 128 - skip_bits);
2114 }
2115
2116 total_lz += limb_lz;
2117 if (limb_lz < 128 - skip_bits) return total_lz;
2118 skip_bits = 0;
2119 remaining_bytes -= 128 / CHAR_BIT;
2120
2121#if zig_big_endian
2122 byte_offset += 128 / CHAR_BIT;
2123#endif
2124 }
2125
2126 while (remaining_bytes >= 64 / CHAR_BIT) {
2127#if zig_little_endian
2128 byte_offset -= 64 / CHAR_BIT;
2129#endif
2130
2131 {
2132 uint64_t val_limb;
2133
2134 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2135 limb_lz = zig_clz_u64(val_limb, 64 - skip_bits);
2136 }
2137
2138 total_lz += limb_lz;
2139 if (limb_lz < 64 - skip_bits) return total_lz;
2140 skip_bits = 0;
2141 remaining_bytes -= 64 / CHAR_BIT;
2142
2143#if zig_big_endian
2144 byte_offset += 64 / CHAR_BIT;
2145#endif
2146 }
2147
2148 while (remaining_bytes >= 32 / CHAR_BIT) {
2149#if zig_little_endian
2150 byte_offset -= 32 / CHAR_BIT;
2151#endif
2152
2153 {
2154 uint32_t val_limb;
2155
2156 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2157 limb_lz = zig_clz_u32(val_limb, 32 - skip_bits);
2158 }
2159
2160 total_lz += limb_lz;
2161 if (limb_lz < 32 - skip_bits) return total_lz;
2162 skip_bits = 0;
2163 remaining_bytes -= 32 / CHAR_BIT;
2164
2165#if zig_big_endian
2166 byte_offset += 32 / CHAR_BIT;
2167#endif
2168 }
2169
2170 while (remaining_bytes >= 16 / CHAR_BIT) {
2171#if zig_little_endian
2172 byte_offset -= 16 / CHAR_BIT;
2173#endif
2174
2175 {
2176 uint16_t val_limb;
2177
2178 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2179 limb_lz = zig_clz_u16(val_limb, 16 - skip_bits);
2180 }
2181
2182 total_lz += limb_lz;
2183 if (limb_lz < 16 - skip_bits) return total_lz;
2184 skip_bits = 0;
2185 remaining_bytes -= 16 / CHAR_BIT;
2186
2187#if zig_big_endian
2188 byte_offset += 16 / CHAR_BIT;
2189#endif
2190 }
2191
2192 while (remaining_bytes >= 8 / CHAR_BIT) {
2193#if zig_little_endian
2194 byte_offset -= 8 / CHAR_BIT;
2195#endif
2196
2197 {
2198 uint8_t val_limb;
2199
2200 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2201 limb_lz = zig_clz_u8(val_limb, 8 - skip_bits);
2202 }
2203
2204 total_lz += limb_lz;
2205 if (limb_lz < 8 - skip_bits) return total_lz;
2206 skip_bits = 0;
2207 remaining_bytes -= 8 / CHAR_BIT;
2208
2209#if zig_big_endian
2210 byte_offset += 8 / CHAR_BIT;
2211#endif
2212 }
2213
2214 return total_lz;
2215}
2216
2217static inline uint16_t zig_ctz_big(const void *val, bool is_signed, uint16_t bits) {
2218 const uint8_t *val_bytes = val;
2219 uint16_t byte_offset = 0;
2220 uint16_t remaining_bytes = zig_int_bytes(bits);
2221 uint16_t total_tz = 0;
2222 uint16_t limb_tz;
2223 (void)is_signed;
2224
2225#if zig_big_endian
2226 byte_offset = remaining_bytes;
2227#endif
2228
2229 while (remaining_bytes >= 128 / CHAR_BIT) {
2230#if zig_big_endian
2231 byte_offset -= 128 / CHAR_BIT;
2232#endif
2233
2234 {
2235 zig_u128 val_limb;
2236
2237 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2238 limb_tz = zig_ctz_u128(val_limb, 128);
2239 }
2240
2241 total_tz += limb_tz;
2242 if (limb_tz < 128) return total_tz;
2243 remaining_bytes -= 128 / CHAR_BIT;
2244
2245#if zig_little_endian
2246 byte_offset += 128 / CHAR_BIT;
2247#endif
2248 }
2249
2250 while (remaining_bytes >= 64 / CHAR_BIT) {
2251#if zig_big_endian
2252 byte_offset -= 64 / CHAR_BIT;
2253#endif
2254
2255 {
2256 uint64_t val_limb;
2257
2258 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2259 limb_tz = zig_ctz_u64(val_limb, 64);
2260 }
2261
2262 total_tz += limb_tz;
2263 if (limb_tz < 64) return total_tz;
2264 remaining_bytes -= 64 / CHAR_BIT;
2265
2266#if zig_little_endian
2267 byte_offset += 64 / CHAR_BIT;
2268#endif
2269 }
2270
2271 while (remaining_bytes >= 32 / CHAR_BIT) {
2272#if zig_big_endian
2273 byte_offset -= 32 / CHAR_BIT;
2274#endif
2275
2276 {
2277 uint32_t val_limb;
2278
2279 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2280 limb_tz = zig_ctz_u32(val_limb, 32);
2281 }
2282
2283 total_tz += limb_tz;
2284 if (limb_tz < 32) return total_tz;
2285 remaining_bytes -= 32 / CHAR_BIT;
2286
2287#if zig_little_endian
2288 byte_offset += 32 / CHAR_BIT;
2289#endif
2290 }
2291
2292 while (remaining_bytes >= 16 / CHAR_BIT) {
2293#if zig_big_endian
2294 byte_offset -= 16 / CHAR_BIT;
2295#endif
2296
2297 {
2298 uint16_t val_limb;
2299
2300 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2301 limb_tz = zig_ctz_u16(val_limb, 16);
2302 }
2303
2304 total_tz += limb_tz;
2305 if (limb_tz < 16) return total_tz;
2306 remaining_bytes -= 16 / CHAR_BIT;
2307
2308#if zig_little_endian
2309 byte_offset += 16 / CHAR_BIT;
2310#endif
2311 }
2312
2313 while (remaining_bytes >= 8 / CHAR_BIT) {
2314#if zig_big_endian
2315 byte_offset -= 8 / CHAR_BIT;
2316#endif
2317
2318 {
2319 uint8_t val_limb;
2320
2321 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2322 limb_tz = zig_ctz_u8(val_limb, 8);
2323 }
2324
2325 total_tz += limb_tz;
2326 if (limb_tz < 8) return total_tz;
2327 remaining_bytes -= 8 / CHAR_BIT;
2328
2329#if zig_little_endian
2330 byte_offset += 8 / CHAR_BIT;
2331#endif
2332 }
2333
2334 return total_tz;
2335}
2336
2337static inline uint16_t zig_popcount_big(const void *val, bool is_signed, uint16_t bits) {
2338 const uint8_t *val_bytes = val;
2339 uint16_t byte_offset = 0;
2340 uint16_t remaining_bytes = zig_int_bytes(bits);
2341 uint16_t total_pc = 0;
2342 (void)is_signed;
2343
2344#if zig_big_endian
2345 byte_offset = remaining_bytes;
2346#endif
2347
2348 while (remaining_bytes >= 128 / CHAR_BIT) {
2349#if zig_big_endian
2350 byte_offset -= 128 / CHAR_BIT;
2351#endif
2352
2353 {
2354 zig_u128 val_limb;
2355
2356 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2357 total_pc += zig_popcount_u128(val_limb, 128);
2358 }
2359
2360 remaining_bytes -= 128 / CHAR_BIT;
2361
2362#if zig_little_endian
2363 byte_offset += 128 / CHAR_BIT;
2364#endif
2365 }
2366
2367 while (remaining_bytes >= 64 / CHAR_BIT) {
2368#if zig_big_endian
2369 byte_offset -= 64 / CHAR_BIT;
2370#endif
2371
2372 {
2373 uint64_t val_limb;
2374
2375 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2376 total_pc += zig_popcount_u64(val_limb, 64);
2377 }
2378
2379 remaining_bytes -= 64 / CHAR_BIT;
2380
2381#if zig_little_endian
2382 byte_offset += 64 / CHAR_BIT;
2383#endif
2384 }
2385
2386 while (remaining_bytes >= 32 / CHAR_BIT) {
2387#if zig_big_endian
2388 byte_offset -= 32 / CHAR_BIT;
2389#endif
2390
2391 {
2392 uint32_t val_limb;
2393
2394 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2395 total_pc += zig_popcount_u32(val_limb, 32);
2396 }
2397
2398 remaining_bytes -= 32 / CHAR_BIT;
2399
2400#if zig_little_endian
2401 byte_offset += 32 / CHAR_BIT;
2402#endif
2403 }
2404
2405 while (remaining_bytes >= 16 / CHAR_BIT) {
2406#if zig_big_endian
2407 byte_offset -= 16 / CHAR_BIT;
2408#endif
2409
2410 {
2411 uint16_t val_limb;
2412
2413 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2414 total_pc = zig_popcount_u16(val_limb, 16);
2415 }
2416
2417 remaining_bytes -= 16 / CHAR_BIT;
2418
2419#if zig_little_endian
2420 byte_offset += 16 / CHAR_BIT;
2421#endif
2422 }
2423
2424 while (remaining_bytes >= 8 / CHAR_BIT) {
2425#if zig_big_endian
2426 byte_offset -= 8 / CHAR_BIT;
2427#endif
2428
2429 {
2430 uint8_t val_limb;
2431
2432 memcpy(&val_limb, &val_bytes[byte_offset], sizeof(val_limb));
2433 total_pc = zig_popcount_u8(val_limb, 8);
2434 }
2435
2436 remaining_bytes -= 8 / CHAR_BIT;
2437
2438#if zig_little_endian
2439 byte_offset += 8 / CHAR_BIT;
2440#endif
2441 }
2442
2443 return total_pc;
2444}
2445
20912446/* ========================= Floating Point Support ========================= */
20922447
20932448#if _MSC_VER
......@@ -2742,7 +3097,7 @@ zig_msvc_atomics_128op(u128, max)
27423097 uint32_t index = 0; \
27433098 const uint8_t *lhs_ptr = lhs; \
27443099 const uint8_t *rhs_ptr = rhs; \
2745 uint16_t elem_bytes = zig_big_bytes(elem_bits); \
3100 uint16_t elem_bytes = zig_int_bytes(elem_bits); \
27463101 \
27473102 while (index < len) { \
27483103 result[index] = zig_cmp_big(lhs_ptr, rhs_ptr, is_signed, elem_bits) operator 0; \
......@@ -2758,6 +3113,57 @@ zig_cmp_vec(le, <=)
27583113zig_cmp_vec(gt, > )
27593114zig_cmp_vec(ge, >=)
27603115
3116static inline void zig_clz_vec(void *result, const void *val, uint32_t len, bool is_signed, uint16_t elem_bits) {
3117 uint32_t index = 0;
3118 const uint8_t *val_ptr = val;
3119 uint16_t elem_bytes = zig_int_bytes(elem_bits);
3120
3121 while (index < len) {
3122 uint16_t lz = zig_clz_big(val_ptr, is_signed, elem_bits);
3123 if (elem_bits <= 128) {
3124 ((uint8_t *)result)[index] = (uint8_t)lz;
3125 } else {
3126 ((uint16_t *)result)[index] = lz;
3127 }
3128 val_ptr += elem_bytes;
3129 index += 1;
3130 }
3131}
3132
3133static inline void zig_ctz_vec(void *result, const void *val, uint32_t len, bool is_signed, uint16_t elem_bits) {
3134 uint32_t index = 0;
3135 const uint8_t *val_ptr = val;
3136 uint16_t elem_bytes = zig_int_bytes(elem_bits);
3137
3138 while (index < len) {
3139 uint16_t tz = zig_ctz_big(val_ptr, is_signed, elem_bits);
3140 if (elem_bits <= 128) {
3141 ((uint8_t *)result)[index] = (uint8_t)tz;
3142 } else {
3143 ((uint16_t *)result)[index] = tz;
3144 }
3145 val_ptr += elem_bytes;
3146 index += 1;
3147 }
3148}
3149
3150static inline void zig_popcount_vec(void *result, const void *val, uint32_t len, bool is_signed, uint16_t elem_bits) {
3151 uint32_t index = 0;
3152 const uint8_t *val_ptr = val;
3153 uint16_t elem_bytes = zig_int_bytes(elem_bits);
3154
3155 while (index < len) {
3156 uint16_t pc = zig_popcount_big(val_ptr, is_signed, elem_bits);
3157 if (elem_bits <= 128) {
3158 ((uint8_t *)result)[index] = (uint8_t)pc;
3159 } else {
3160 ((uint16_t *)result)[index] = pc;
3161 }
3162 val_ptr += elem_bytes;
3163 index += 1;
3164 }
3165}
3166
27613167/* ======================== Special Case Intrinsics ========================= */
27623168
27633169#if (_MSC_VER && _M_X64) || defined(__x86_64__)
src/codegen/c.zig+40-11
......@@ -2844,7 +2844,7 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail,
28442844 .cmp_vector => blk: {
28452845 const ty_pl = f.air.instructions.items(.data)[inst].ty_pl;
28462846 const extra = f.air.extraData(Air.VectorCmp, ty_pl.payload).data;
2847 break :blk try cmpBuiltinCall(f, inst, extra, extra.compareOperator(), .operator, .bits);
2847 break :blk try airCmpBuiltinCall(f, inst, extra, extra.compareOperator(), .operator, .bits,);
28482848 },
28492849 .cmp_lt_errors_len => try airCmpLtErrorsLen(f, inst),
28502850
......@@ -3837,9 +3837,16 @@ fn airCmpOp(f: *Function, inst: Air.Inst.Index, operator: std.math.CompareOperat
38373837 const target = f.object.dg.module.getTarget();
38383838 const operand_bits = operand_ty.bitSize(target);
38393839 if (operand_ty.isInt() and operand_bits > 64)
3840 return cmpBuiltinCall(f, inst, bin_op, operator, .cmp, if (operand_bits > 128) .bits else .none);
3840 return airCmpBuiltinCall(
3841 f,
3842 inst,
3843 bin_op,
3844 operator,
3845 .cmp,
3846 if (operand_bits > 128) .bits else .none,
3847 );
38413848 if (operand_ty.isRuntimeFloat())
3842 return cmpBuiltinCall(f, inst, bin_op, operator, .operator, .none);
3849 return airCmpBuiltinCall(f, inst, bin_op, operator, .operator, .none);
38433850
38443851 const inst_ty = f.air.typeOfIndex(inst);
38453852 const lhs = try f.resolveInst(bin_op.lhs);
......@@ -3876,9 +3883,16 @@ fn airEquality(
38763883 const target = f.object.dg.module.getTarget();
38773884 const operand_bits = operand_ty.bitSize(target);
38783885 if (operand_ty.isInt() and operand_bits > 64)
3879 return cmpBuiltinCall(f, inst, bin_op, operator, .cmp, if (operand_bits > 128) .bits else .none);
3886 return airCmpBuiltinCall(
3887 f,
3888 inst,
3889 bin_op,
3890 operator,
3891 .cmp,
3892 if (operand_bits > 128) .bits else .none,
3893 );
38803894 if (operand_ty.isRuntimeFloat())
3881 return cmpBuiltinCall(f, inst, bin_op, operator, .operator, .none);
3895 return airCmpBuiltinCall(f, inst, bin_op, operator, .operator, .none);
38823896
38833897 const lhs = try f.resolveInst(bin_op.lhs);
38843898 const rhs = try f.resolveInst(bin_op.rhs);
......@@ -5969,14 +5983,25 @@ fn airUnBuiltinCall(
59695983 const inst_ty = f.air.typeOfIndex(inst);
59705984 const operand_ty = f.air.typeOf(ty_op.operand);
59715985
5986 const inst_cty = try f.typeToCType(inst_ty, .complete);
5987 const ref_ret = switch (inst_cty.tag()) {
5988 else => false,
5989 .array, .vector => true,
5990 };
5991
59725992 const writer = f.object.writer();
59735993 const local = try f.allocLocal(inst, inst_ty);
5974 try f.writeCValue(writer, local, .Other);
5975 try writer.writeAll(" = zig_");
5976 try writer.writeAll(operation);
5977 try writer.writeByte('_');
5994 if (!ref_ret) {
5995 try f.writeCValue(writer, local, .Other);
5996 try writer.writeAll(" = ");
5997 }
5998 try writer.print("zig_{s}_", .{operation});
59785999 try f.object.dg.renderTypeForBuiltinFnName(writer, operand_ty);
59796000 try writer.writeByte('(');
6001 if (ref_ret) {
6002 try f.writeCValue(writer, local, .FunctionArgument);
6003 try writer.writeAll(", ");
6004 }
59806005 try f.writeCValue(writer, operand, .FunctionArgument);
59816006 try f.object.dg.renderBuiltinInfo(writer, operand_ty, info);
59826007 try writer.writeAll(");\n");
......@@ -6019,7 +6044,7 @@ fn airBinBuiltinCall(
60196044 return local;
60206045}
60216046
6022fn cmpBuiltinCall(
6047fn airCmpBuiltinCall(
60236048 f: *Function,
60246049 inst: Air.Inst.Index,
60256050 data: anytype,
......@@ -6034,7 +6059,11 @@ fn cmpBuiltinCall(
60346059 const rhs = try f.resolveInst(data.rhs);
60356060 try reap(f, inst, &.{ data.lhs, data.rhs });
60366061
6037 const ref_ret = inst_ty.tag() != .bool;
6062 const inst_cty = try f.typeToCType(inst_ty, .complete);
6063 const ref_ret = switch (inst_cty.tag()) {
6064 else => false,
6065 .array, .vector => true,
6066 };
60386067
60396068 const writer = f.object.writer();
60406069 const local = try f.allocLocal(inst, inst_ty);
test/behavior/bugs/10147.zig-1
......@@ -6,7 +6,6 @@ test "test calling @clz on both vector and scalar inputs" {
66 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
77 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
88 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1110
1211 var x: u32 = 0x1;
test/behavior/math.zig+6-2
......@@ -100,7 +100,6 @@ test "@clz vectors" {
100100 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
101101 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
102102 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
103 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
104103 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
105104
106105 try testClzVectors();
......@@ -163,7 +162,6 @@ test "@ctz vectors" {
163162 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
164163 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
165164 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
166 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
167165 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
168166
169167 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) {
......@@ -1562,6 +1560,12 @@ test "signed zeros are represented properly" {
15621560 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
15631561 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15641562
1563 if (builtin.os.tag == .windows and builtin.cpu.arch == .aarch64 and
1564 builtin.zig_backend == .stage2_c)
1565 {
1566 return error.SkipZigTest;
1567 }
1568
15651569 const S = struct {
15661570 fn doTheTest() !void {
15671571 try testOne(f16);
test/behavior/popcount.zig-1
......@@ -67,7 +67,6 @@ fn testPopCountIntegers() !void {
6767}
6868
6969test "@popCount vectors" {
70 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
7170 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
7271 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
7372 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO