authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-01-18 10:47:02-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-01-18 10:47:02-07:00
logf423b5949b8722d4b290f57c3d06d015e39217b0
tree8c9d05573e1d595c311e99643ffd68cce75aa92f
parent4938fb8f5ca9551b69036fdb644103ffc9ef49cf

Revert "stage2: implement `@prefetch`"

This reverts commit d48e4245b68bf25c7f41804a5012ac157a5ee546. I have no idea why this is failing Drone CI, but in a branch, reverting this commit solved the problem.

14 files changed, 45 insertions(+), 280 deletions(-)

lib/std/builtin.zig+2-2
......@@ -643,12 +643,12 @@ pub const PrefetchOptions = struct {
643643 /// The cache that the prefetch should be preformed on.
644644 cache: Cache = .data,
645645
646 pub const Rw = enum(u1) {
646 pub const Rw = enum {
647647 read,
648648 write,
649649 };
650650
651 pub const Cache = enum(u1) {
651 pub const Cache = enum {
652652 instruction,
653653 data,
654654 };
src/Air.zig-12
......@@ -515,11 +515,6 @@ pub const Inst = struct {
515515 /// is a `Ref`. Length of the array is given by the vector type.
516516 vector_init,
517517
518 /// Communicates an intent to load memory.
519 /// Result is always unused.
520 /// Uses the `prefetch` field.
521 prefetch,
522
523518 pub fn fromCmpOp(op: std.math.CompareOperator) Tag {
524519 return switch (op) {
525520 .lt => .cmp_lt,
......@@ -591,12 +586,6 @@ pub const Inst = struct {
591586 ptr: Ref,
592587 order: std.builtin.AtomicOrder,
593588 },
594 prefetch: struct {
595 ptr: Ref,
596 rw: std.builtin.PrefetchOptions.Rw,
597 locality: u2,
598 cache: std.builtin.PrefetchOptions.Cache,
599 },
600589
601590 // Make sure we don't accidentally add a field to make this union
602591 // bigger than expected. Note that in Debug builds, Zig is allowed
......@@ -834,7 +823,6 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
834823 .memset,
835824 .memcpy,
836825 .set_union_tag,
837 .prefetch,
838826 => return Type.initTag(.void),
839827
840828 .ptrtoint,
src/Liveness.zig-5
......@@ -342,11 +342,6 @@ fn analyzeInst(
342342 return trackOperands(a, new_set, inst, main_tomb, .{ operand, .none, .none });
343343 },
344344
345 .prefetch => {
346 const prefetch = inst_datas[inst].prefetch;
347 return trackOperands(a, new_set, inst, main_tomb, .{ prefetch.ptr, .none, .none });
348 },
349
350345 .call => {
351346 const inst_data = inst_datas[inst].pl_op;
352347 const callee = inst_data.operand;
src/Sema.zig+38-82
......@@ -10316,50 +10316,46 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
1031610316 const inst_data = sema.code.instructions.items(.data)[inst].un_node;
1031710317 const src = inst_data.src();
1031810318 const obj_ty = try sema.resolveType(block, src, inst_data.operand);
10319
10320 switch (obj_ty.zigTypeTag()) {
10321 .Struct => return structInitEmpty(sema, block, obj_ty, src, src),
10322 .Array => return arrayInitEmpty(sema, obj_ty),
10323 .Void => return sema.addConstant(obj_ty, Value.void),
10324 else => unreachable,
10325 }
10326}
10327
10328fn structInitEmpty(sema: *Sema, block: *Block, obj_ty: Type, dest_src: LazySrcLoc, init_src: LazySrcLoc) CompileError!Air.Inst.Ref {
1032910319 const gpa = sema.gpa;
10330 // This logic must be synchronized with that in `zirStructInit`.
10331 const struct_ty = try sema.resolveTypeFields(block, dest_src, obj_ty);
10332 const struct_obj = struct_ty.castTag(.@"struct").?.data;
10333
10334 // The init values to use for the struct instance.
10335 const field_inits = try gpa.alloc(Air.Inst.Ref, struct_obj.fields.count());
10336 defer gpa.free(field_inits);
10337
10338 var root_msg: ?*Module.ErrorMsg = null;
1033910320
10340 for (struct_obj.fields.values()) |field, i| {
10341 if (field.default_val.tag() == .unreachable_value) {
10342 const field_name = struct_obj.fields.keys()[i];
10343 const template = "missing struct field: {s}";
10344 const args = .{field_name};
10345 if (root_msg) |msg| {
10346 try sema.errNote(block, init_src, msg, template, args);
10321 switch (obj_ty.zigTypeTag()) {
10322 .Struct => {
10323 // This logic must be synchronized with that in `zirStructInit`.
10324 const struct_ty = try sema.resolveTypeFields(block, src, obj_ty);
10325 const struct_obj = struct_ty.castTag(.@"struct").?.data;
10326
10327 // The init values to use for the struct instance.
10328 const field_inits = try gpa.alloc(Air.Inst.Ref, struct_obj.fields.count());
10329 defer gpa.free(field_inits);
10330
10331 var root_msg: ?*Module.ErrorMsg = null;
10332
10333 for (struct_obj.fields.values()) |field, i| {
10334 if (field.default_val.tag() == .unreachable_value) {
10335 const field_name = struct_obj.fields.keys()[i];
10336 const template = "missing struct field: {s}";
10337 const args = .{field_name};
10338 if (root_msg) |msg| {
10339 try sema.errNote(block, src, msg, template, args);
10340 } else {
10341 root_msg = try sema.errMsg(block, src, template, args);
10342 }
10343 } else {
10344 field_inits[i] = try sema.addConstant(field.ty, field.default_val);
10345 }
10346 }
10347 return sema.finishStructInit(block, src, field_inits, root_msg, struct_obj, struct_ty, false);
10348 },
10349 .Array => {
10350 if (obj_ty.sentinel()) |sentinel| {
10351 const val = try Value.Tag.empty_array_sentinel.create(sema.arena, sentinel);
10352 return sema.addConstant(obj_ty, val);
1034710353 } else {
10348 root_msg = try sema.errMsg(block, init_src, template, args);
10354 return sema.addConstant(obj_ty, Value.initTag(.empty_array));
1034910355 }
10350 } else {
10351 field_inits[i] = try sema.addConstant(field.ty, field.default_val);
10352 }
10353 }
10354 return sema.finishStructInit(block, dest_src, field_inits, root_msg, struct_obj, struct_ty, false);
10355}
10356
10357fn arrayInitEmpty(sema: *Sema, obj_ty: Type) CompileError!Air.Inst.Ref {
10358 if (obj_ty.sentinel()) |sentinel| {
10359 const val = try Value.Tag.empty_array_sentinel.create(sema.arena, sentinel);
10360 return sema.addConstant(obj_ty, val);
10361 } else {
10362 return sema.addConstant(obj_ty, Value.initTag(.empty_array));
10356 },
10357 .Void => return sema.addConstant(obj_ty, Value.void),
10358 else => unreachable,
1036310359 }
1036410360}
1036510361
......@@ -12330,38 +12326,8 @@ fn zirPrefetch(
1233012326 extended: Zir.Inst.Extended.InstData,
1233112327) CompileError!Air.Inst.Ref {
1233212328 const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
12333 const ptr_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
12334 const opts_src: LazySrcLoc = .{ .node_offset_builtin_call_arg1 = extra.node };
12335 const options_ty = try sema.getBuiltinType(block, opts_src, "PrefetchOptions");
12336 const ptr = sema.resolveInst(extra.lhs);
12337 try sema.checkPtrType(block, ptr_src, sema.typeOf(ptr));
12338 const options = try sema.coerce(block, options_ty, sema.resolveInst(extra.rhs), opts_src);
12339
12340 const rw = try sema.fieldVal(block, opts_src, options, "rw", opts_src);
12341 const rw_val = try sema.resolveConstValue(block, opts_src, rw);
12342 const rw_tag = rw_val.toEnum(std.builtin.PrefetchOptions.Rw);
12343
12344 const locality = try sema.fieldVal(block, opts_src, options, "locality", opts_src);
12345 const locality_val = try sema.resolveConstValue(block, opts_src, locality);
12346 const locality_int = @intCast(u2, locality_val.toUnsignedInt());
12347
12348 const cache = try sema.fieldVal(block, opts_src, options, "cache", opts_src);
12349 const cache_val = try sema.resolveConstValue(block, opts_src, cache);
12350 const cache_tag = cache_val.toEnum(std.builtin.PrefetchOptions.Cache);
12351
12352 if (!block.is_comptime) {
12353 _ = try block.addInst(.{
12354 .tag = .prefetch,
12355 .data = .{ .prefetch = .{
12356 .ptr = ptr,
12357 .rw = rw_tag,
12358 .locality = locality_int,
12359 .cache = cache_tag,
12360 } },
12361 });
12362 }
12363
12364 return Air.Inst.Ref.void_value;
12329 const src: LazySrcLoc = .{ .node_offset = extra.node };
12330 return sema.fail(block, src, "TODO: implement Sema.zirPrefetch", .{});
1236512331}
1236612332
1236712333fn zirBuiltinExtern(
......@@ -13821,11 +13787,6 @@ fn coerce(
1382113787 },
1382213788 .Array => switch (inst_ty.zigTypeTag()) {
1382313789 .Vector => return sema.coerceVectorInMemory(block, dest_ty, dest_ty_src, inst, inst_src),
13824 .Struct => {
13825 if (inst == .empty_struct) {
13826 return arrayInitEmpty(sema, dest_ty);
13827 }
13828 },
1382913790 else => {},
1383013791 },
1383113792 .Vector => switch (inst_ty.zigTypeTag()) {
......@@ -13833,11 +13794,6 @@ fn coerce(
1383313794 .Vector => return sema.coerceVectors(block, dest_ty, dest_ty_src, inst, inst_src),
1383413795 else => {},
1383513796 },
13836 .Struct => {
13837 if (inst == .empty_struct) {
13838 return structInitEmpty(sema, block, dest_ty, dest_ty_src, inst_src);
13839 }
13840 },
1384113797 else => {},
1384213798 }
1384313799
src/arch/aarch64/CodeGen.zig-6
......@@ -595,7 +595,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
595595 .error_name => try self.airErrorName(inst),
596596 .splat => try self.airSplat(inst),
597597 .vector_init => try self.airVectorInit(inst),
598 .prefetch => try self.airPrefetch(inst),
599598
600599 .atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),
601600 .atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),
......@@ -2598,11 +2597,6 @@ fn airVectorInit(self: *Self, inst: Air.Inst.Index) !void {
25982597 return bt.finishAir(result);
25992598}
26002599
2601fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
2602 const prefetch = self.air.instructions.items(.data)[inst].prefetch;
2603 return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
2604}
2605
26062600fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
26072601 // First section of indexes correspond to a set number of constant values.
26082602 const ref_int = @enumToInt(inst);
src/arch/arm/CodeGen.zig-6
......@@ -586,7 +586,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
586586 .error_name => try self.airErrorName(inst),
587587 .splat => try self.airSplat(inst),
588588 .vector_init => try self.airVectorInit(inst),
589 .prefetch => try self.airPrefetch(inst),
590589
591590 .atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),
592591 .atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),
......@@ -3694,11 +3693,6 @@ fn airVectorInit(self: *Self, inst: Air.Inst.Index) !void {
36943693 return bt.finishAir(result);
36953694}
36963695
3697fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
3698 const prefetch = self.air.instructions.items(.data)[inst].prefetch;
3699 return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
3700}
3701
37023696fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
37033697 // First section of indexes correspond to a set number of constant values.
37043698 const ref_int = @enumToInt(inst);
src/arch/riscv64/CodeGen.zig-6
......@@ -574,7 +574,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
574574 .error_name => try self.airErrorName(inst),
575575 .splat => try self.airSplat(inst),
576576 .vector_init => try self.airVectorInit(inst),
577 .prefetch => try self.airPrefetch(inst),
578577
579578 .atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),
580579 .atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),
......@@ -2097,11 +2096,6 @@ fn airVectorInit(self: *Self, inst: Air.Inst.Index) !void {
20972096 return bt.finishAir(result);
20982097}
20992098
2100fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
2101 const prefetch = self.air.instructions.items(.data)[inst].prefetch;
2102 return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
2103}
2104
21052099fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
21062100 // First section of indexes correspond to a set number of constant values.
21072101 const ref_int = @enumToInt(inst);
src/arch/wasm/CodeGen.zig+4-63
......@@ -1297,9 +1297,6 @@ fn copyLocal(self: *Self, value: WValue, ty: Type) InnerError!WValue {
12971297fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
12981298 const air_tags = self.air.instructions.items(.tag);
12991299 return switch (air_tags[inst]) {
1300 .constant => unreachable,
1301 .const_ty => unreachable,
1302
13031300 .add => self.airBinOp(inst, .add),
13041301 .addwrap => self.airWrapBinOp(inst, .add),
13051302 .sub => self.airBinOp(inst, .sub),
......@@ -1333,6 +1330,7 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
13331330 .bool_to_int => self.airBoolToInt(inst),
13341331 .call => self.airCall(inst),
13351332 .cond_br => self.airCondBr(inst),
1333 .constant => unreachable,
13361334 .dbg_stmt => WValue.none,
13371335 .intcast => self.airIntcast(inst),
13381336 .float_to_int => self.airFloatToInt(inst),
......@@ -1360,9 +1358,6 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
13601358 .ret => self.airRet(inst),
13611359 .ret_ptr => self.airRetPtr(inst),
13621360 .ret_load => self.airRetLoad(inst),
1363 .splat => self.airSplat(inst),
1364 .vector_init => self.airVectorInit(inst),
1365 .prefetch => self.airPrefetch(inst),
13661361
13671362 .slice => self.airSlice(inst),
13681363 .slice_len => self.airSliceLen(inst),
......@@ -1387,55 +1382,7 @@ fn genInst(self: *Self, inst: Air.Inst.Index) !WValue {
13871382 .unwrap_errunion_err => self.airUnwrapErrUnionError(inst),
13881383 .wrap_errunion_payload => self.airWrapErrUnionPayload(inst),
13891384 .wrap_errunion_err => self.airWrapErrUnionErr(inst),
1390
1391 .add_sat,
1392 .sub_sat,
1393 .mul_sat,
1394 .div_float,
1395 .div_floor,
1396 .div_exact,
1397 .rem,
1398 .mod,
1399 .max,
1400 .min,
1401 .assembly,
1402 .shl_exact,
1403 .shl_sat,
1404 .ret_addr,
1405 .clz,
1406 .ctz,
1407 .popcount,
1408 .is_err_ptr,
1409 .is_non_err_ptr,
1410 .fptrunc,
1411 .fpext,
1412 .unwrap_errunion_payload_ptr,
1413 .unwrap_errunion_err_ptr,
1414 .set_union_tag,
1415 .get_union_tag,
1416 .ptr_slice_len_ptr,
1417 .ptr_slice_ptr_ptr,
1418 .int_to_float,
1419 .memcpy,
1420 .cmpxchg_weak,
1421 .cmpxchg_strong,
1422 .fence,
1423 .atomic_load,
1424 .atomic_store_unordered,
1425 .atomic_store_monotonic,
1426 .atomic_store_release,
1427 .atomic_store_seq_cst,
1428 .atomic_rmw,
1429 .tag_name,
1430 .error_name,
1431
1432 // For these 4, probably best to wait until https://github.com/ziglang/zig/issues/10248
1433 // is implemented in the frontend before implementing them here in the wasm backend.
1434 .add_with_overflow,
1435 .sub_with_overflow,
1436 .mul_with_overflow,
1437 .shl_with_overflow,
1438 => |tag| self.fail("TODO: Implement wasm inst: {s}", .{@tagName(tag)}),
1385 else => |tag| self.fail("TODO: Implement wasm inst: {s}", .{@tagName(tag)}),
14391386 };
14401387}
14411388
......@@ -3264,7 +3211,7 @@ fn airFloatToInt(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
32643211 return result;
32653212}
32663213
3267fn airSplat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
3214fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
32683215 if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
32693216
32703217 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
......@@ -3275,7 +3222,7 @@ fn airSplat(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
32753222 return self.fail("TODO: Implement wasm airSplat", .{});
32763223}
32773224
3278fn airVectorInit(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
3225fn airVectorInit(self: *Self, inst: Air.Inst.Index) !void {
32793226 if (self.liveness.isUnused(inst)) return WValue{ .none = {} };
32803227
32813228 const vector_ty = self.air.typeOfIndex(inst);
......@@ -3287,12 +3234,6 @@ fn airVectorInit(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
32873234 return self.fail("TODO: Wasm backend: implement airVectorInit", .{});
32883235}
32893236
3290fn airPrefetch(self: *Self, inst: Air.Inst.Index) InnerError!WValue {
3291 const prefetch = self.air.instructions.items(.data)[inst].prefetch;
3292 _ = prefetch;
3293 return WValue{ .none = {} };
3294}
3295
32963237fn cmpOptionals(self: *Self, lhs: WValue, rhs: WValue, operand_ty: Type, op: std.math.CompareOperator) InnerError!WValue {
32973238 assert(operand_ty.hasCodeGenBits());
32983239 assert(op == .eq or op == .neq);
src/arch/x86_64/CodeGen.zig-6
......@@ -638,7 +638,6 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
638638 .error_name => try self.airErrorName(inst),
639639 .splat => try self.airSplat(inst),
640640 .vector_init => try self.airVectorInit(inst),
641 .prefetch => try self.airPrefetch(inst),
642641
643642 .atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),
644643 .atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),
......@@ -3747,11 +3746,6 @@ fn airVectorInit(self: *Self, inst: Air.Inst.Index) !void {
37473746 return bt.finishAir(result);
37483747}
37493748
3750fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void {
3751 const prefetch = self.air.instructions.items(.data)[inst].prefetch;
3752 return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none });
3753}
3754
37553749fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
37563750 // First section of indexes correspond to a set number of constant values.
37573751 const ref_int = @enumToInt(inst);
src/codegen/c.zig-13
......@@ -1278,7 +1278,6 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
12781278 .error_name => try airErrorName(f, inst),
12791279 .splat => try airSplat(f, inst),
12801280 .vector_init => try airVectorInit(f, inst),
1281 .prefetch => try airPrefetch(f, inst),
12821281
12831282 .int_to_float,
12841283 .float_to_int,
......@@ -3090,18 +3089,6 @@ fn airVectorInit(f: *Function, inst: Air.Inst.Index) !CValue {
30903089 return f.fail("TODO: C backend: implement airVectorInit", .{});
30913090}
30923091
3093fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue {
3094 const prefetch = f.air.instructions.items(.data)[inst].prefetch;
3095 const ptr = try f.resolveInst(prefetch.ptr);
3096 const writer = f.object.writer();
3097 try writer.writeAll("zig_prefetch(");
3098 try f.writeCValue(writer, ptr);
3099 try writer.print(", {d}, {d});\n", .{
3100 @enumToInt(prefetch.rw), prefetch.locality,
3101 });
3102 return CValue.none;
3103}
3104
31053092fn toMemoryOrder(order: std.builtin.AtomicOrder) [:0]const u8 {
31063093 return switch (order) {
31073094 .Unordered => "memory_order_relaxed",
src/codegen/llvm.zig-62
......@@ -2073,7 +2073,6 @@ pub const FuncGen = struct {
20732073 .error_name => try self.airErrorName(inst),
20742074 .splat => try self.airSplat(inst),
20752075 .vector_init => try self.airVectorInit(inst),
2076 .prefetch => try self.airPrefetch(inst),
20772076
20782077 .atomic_store_unordered => try self.airAtomicStore(inst, .Unordered),
20792078 .atomic_store_monotonic => try self.airAtomicStore(inst, .Monotonic),
......@@ -4385,67 +4384,6 @@ pub const FuncGen = struct {
43854384 return vector;
43864385 }
43874386
4388 fn airPrefetch(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
4389 const prefetch = self.air.instructions.items(.data)[inst].prefetch;
4390
4391 comptime assert(@enumToInt(std.builtin.PrefetchOptions.Rw.read) == 0);
4392 comptime assert(@enumToInt(std.builtin.PrefetchOptions.Rw.write) == 1);
4393
4394 // TODO these two asserts should be able to be comptime because the type is a u2
4395 assert(prefetch.locality >= 0);
4396 assert(prefetch.locality <= 3);
4397
4398 comptime assert(@enumToInt(std.builtin.PrefetchOptions.Cache.instruction) == 0);
4399 comptime assert(@enumToInt(std.builtin.PrefetchOptions.Cache.data) == 1);
4400
4401 // LLVM fails during codegen of instruction cache prefetchs for these architectures.
4402 // This is an LLVM bug as the prefetch intrinsic should be a noop if not supported
4403 // by the target.
4404 // To work around this, don't emit llvm.prefetch in this case.
4405 // See https://bugs.llvm.org/show_bug.cgi?id=21037
4406 const target = self.dg.module.getTarget();
4407 switch (prefetch.cache) {
4408 .instruction => switch (target.cpu.arch) {
4409 .x86_64, .i386 => return null,
4410 .arm, .armeb, .thumb, .thumbeb => {
4411 switch (prefetch.rw) {
4412 .write => return null,
4413 else => {},
4414 }
4415 },
4416 else => {},
4417 },
4418 .data => {},
4419 }
4420
4421 const llvm_u8 = self.context.intType(8);
4422 const llvm_ptr_u8 = llvm_u8.pointerType(0);
4423 const llvm_u32 = self.context.intType(32);
4424
4425 const llvm_fn_name = "llvm.prefetch.p0i8";
4426 const fn_val = self.dg.object.llvm_module.getNamedFunction(llvm_fn_name) orelse blk: {
4427 // declare void @llvm.prefetch(i8*, i32, i32, i32)
4428 const llvm_void = self.context.voidType();
4429 const param_types = [_]*const llvm.Type{
4430 llvm_ptr_u8, llvm_u32, llvm_u32, llvm_u32,
4431 };
4432 const fn_type = llvm.functionType(llvm_void, &param_types, param_types.len, .False);
4433 break :blk self.dg.object.llvm_module.addFunction(llvm_fn_name, fn_type);
4434 };
4435
4436 const ptr = try self.resolveInst(prefetch.ptr);
4437 const ptr_u8 = self.builder.buildBitCast(ptr, llvm_ptr_u8, "");
4438
4439 const params = [_]*const llvm.Value{
4440 ptr_u8,
4441 llvm_u32.constInt(@enumToInt(prefetch.rw), .False),
4442 llvm_u32.constInt(prefetch.locality, .False),
4443 llvm_u32.constInt(@enumToInt(prefetch.cache), .False),
4444 };
4445 _ = self.builder.buildCall(fn_val, &params, params.len, .C, .Auto, "");
4446 return null;
4447 }
4448
44494387 fn getErrorNameTable(self: *FuncGen) !*const llvm.Value {
44504388 if (self.dg.object.error_name_table) |table| {
44514389 return table;
src/link/C/zig.h-6
......@@ -74,12 +74,6 @@
7474#define zig_frame_address() 0
7575#endif
7676
77#if defined(__GNUC__)
78#define zig_prefetch(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
79#else
80#define zig_prefetch(addr, rw, locality)
81#endif
82
8377#if __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_ATOMICS__)
8478#include <stdatomic.h>
8579#define zig_cmpxchg_strong(obj, expected, desired, succ, fail) atomic_compare_exchange_strong_explicit(obj, &(expected), desired, succ, fail)
src/print_air.zig-10
......@@ -226,7 +226,6 @@ const Writer = struct {
226226 .cmpxchg_weak, .cmpxchg_strong => try w.writeCmpxchg(s, inst),
227227 .fence => try w.writeFence(s, inst),
228228 .atomic_load => try w.writeAtomicLoad(s, inst),
229 .prefetch => try w.writePrefetch(s, inst),
230229 .atomic_store_unordered => try w.writeAtomicStore(s, inst, .Unordered),
231230 .atomic_store_monotonic => try w.writeAtomicStore(s, inst, .Monotonic),
232231 .atomic_store_release => try w.writeAtomicStore(s, inst, .Release),
......@@ -351,15 +350,6 @@ const Writer = struct {
351350 try s.print(", {s}", .{@tagName(atomic_load.order)});
352351 }
353352
354 fn writePrefetch(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
355 const prefetch = w.air.instructions.items(.data)[inst].prefetch;
356
357 try w.writeOperand(s, inst, 0, prefetch.ptr);
358 try s.print(", {s}, {d}, {s}", .{
359 @tagName(prefetch.rw), prefetch.locality, @tagName(prefetch.cache),
360 });
361 }
362
363353 fn writeAtomicStore(
364354 w: *Writer,
365355 s: anytype,
test/behavior.zig+1-1
......@@ -10,7 +10,6 @@ test {
1010 _ = @import("behavior/fn_in_struct_in_comptime.zig");
1111 _ = @import("behavior/hasdecl.zig");
1212 _ = @import("behavior/hasfield.zig");
13 _ = @import("behavior/prefetch.zig");
1413 _ = @import("behavior/pub_enum.zig");
1514 _ = @import("behavior/type_info.zig");
1615 _ = @import("behavior/type.zig");
......@@ -179,6 +178,7 @@ test {
179178 _ = @import("behavior/optional_stage1.zig");
180179 _ = @import("behavior/pointers_stage1.zig");
181180 _ = @import("behavior/popcount_stage1.zig");
181 _ = @import("behavior/prefetch.zig");
182182 _ = @import("behavior/ptrcast_stage1.zig");
183183 _ = @import("behavior/reflection.zig");
184184 _ = @import("behavior/saturating_arithmetic_stage1.zig");