authorgravatar for robin@voetter.nlRobin Voetter <robin@voetter.nl> 2021-10-21 16:54:34+02:00
committergravatar for robin@voetter.nlRobin Voetter <robin@voetter.nl> 2021-10-21 17:29:42+02:00
logfc034ca94f0682a06795616992f176f19ec9a83d
tree162caa58d75510d751b0da4807a8dbee0473a352
parent09c7d5aebc4f7fe96a89f93c0cf99cc03977ea5f

stage2: comptime elemVal and elemPtr for Many/C pointers

1 files changed, 57 insertions(+), 25 deletions(-)

src/Sema.zig+57-25
......@@ -351,6 +351,24 @@ pub const Block = struct {
351351 });
352352 }
353353
354 pub fn addPtrElemPtr(
355 block: *Block,
356 array_ptr: Air.Inst.Ref,
357 elem_index: Air.Inst.Ref,
358 elem_ptr_ty: Type,
359 ) !Air.Inst.Ref {
360 return block.addInst(.{
361 .tag = .ptr_elem_ptr,
362 .data = .{ .ty_pl = .{
363 .ty = try block.sema.addType(elem_ptr_ty),
364 .payload = try block.sema.addExtra(Air.Bin{
365 .lhs = array_ptr,
366 .rhs = elem_index,
367 }),
368 } },
369 });
370 }
371
354372 pub fn addInst(block: *Block, inst: Air.Inst) error{OutOfMemory}!Air.Inst.Ref {
355373 return Air.indexToRef(try block.addInstAsIndex(inst));
356374 }
......@@ -11500,10 +11518,10 @@ fn elemPtr(
1150011518 switch (array_ty.zigTypeTag()) {
1150111519 .Pointer => {
1150211520 // In all below cases, we have to deref the ptr operand to get the actual array pointer.
11503 const array = try sema.analyzeLoad(block, src, array_ptr, array_ptr_src);
11521 const array = try sema.analyzeLoad(block, array_ptr_src, array_ptr, array_ptr_src);
11522 const result_ty = try array_ty.elemPtrType(sema.arena);
1150411523 switch (array_ty.ptrSize()) {
1150511524 .Slice => {
11506 const result_ty = try array_ty.elemPtrType(sema.arena);
1150711525 const maybe_slice_val = try sema.resolveDefinedValue(block, array_ptr_src, array);
1150811526 const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
1150911527 const runtime_src = if (maybe_slice_val) |slice_val| rs: {
......@@ -11516,14 +11534,28 @@ fn elemPtr(
1151611534 try sema.requireRuntimeBlock(block, runtime_src);
1151711535 return block.addSliceElemPtr(array, elem_index, result_ty);
1151811536 },
11519 .Many, .C => return sema.fail(block, src, "TODO implement Sema for elemPtr for many/c pointer", .{}),
11537 .Many, .C => {
11538 const maybe_ptr_val = try sema.resolveDefinedValue(block, array_ptr_src, array);
11539 const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
11540
11541 const runtime_src = rs: {
11542 const ptr_val = maybe_ptr_val orelse break :rs array_ptr_src;
11543 const index_val = maybe_index_val orelse break :rs elem_index_src;
11544 const index = @intCast(usize, index_val.toUnsignedInt());
11545 const elem_ptr = try ptr_val.elemPtr(sema.arena, index);
11546 return sema.addConstant(result_ty, elem_ptr);
11547 };
11548
11549 try sema.requireRuntimeBlock(block, runtime_src);
11550 return block.addPtrElemPtr(array, elem_index, result_ty);
11551 },
1152011552 .One => {
1152111553 assert(array_ty.childType().zigTypeTag() == .Array); // Guaranteed by isIndexable
11522 return sema.elemPtrArray(block, src, array, elem_index, elem_index_src);
11554 return sema.elemPtrArray(block, array_ptr_src, array, elem_index, elem_index_src);
1152311555 },
1152411556 }
1152511557 },
11526 .Array => return sema.elemPtrArray(block, src, array_ptr, elem_index, elem_index_src),
11558 .Array => return sema.elemPtrArray(block, array_ptr_src, array_ptr, elem_index, elem_index_src),
1152711559 .Vector => return sema.fail(block, src, "TODO implement Sema for elemPtr for vector", .{}),
1152811560 else => unreachable,
1152911561 }
......@@ -11560,21 +11592,30 @@ fn elemVal(
1156011592 return block.addBinOp(.slice_elem_val, array, elem_index);
1156111593 },
1156211594 .Many, .C => {
11563 if (try sema.resolveDefinedValue(block, src, array)) |ptr_val| {
11564 _ = ptr_val;
11565 return sema.fail(block, src, "TODO implement Sema for elemVal for comptime known pointer", .{});
11566 }
11567 try sema.requireRuntimeBlock(block, src);
11595 const maybe_ptr_val = try sema.resolveDefinedValue(block, array_src, array);
11596 const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
11597
11598 const runtime_src = rs: {
11599 const ptr_val = maybe_ptr_val orelse break :rs array_src;
11600 const index_val = maybe_index_val orelse break :rs elem_index_src;
11601 const index = @intCast(usize, index_val.toUnsignedInt());
11602 const maybe_array_val = try ptr_val.pointerDeref(sema.arena);
11603 const array_val = maybe_array_val orelse break :rs array_src;
11604 const elem_val = try array_val.elemValue(sema.arena, index);
11605 return sema.addConstant(array_ty.elemType2(), elem_val);
11606 };
11607
11608 try sema.requireRuntimeBlock(block, runtime_src);
1156811609 return block.addBinOp(.ptr_elem_val, array, elem_index);
1156911610 },
1157011611 .One => {
1157111612 assert(array_ty.childType().zigTypeTag() == .Array); // Guaranteed by isIndexable
11572 const elem_ptr = try sema.elemPtr(block, src, array, elem_index, elem_index_src);
11573 return sema.analyzeLoad(block, src, elem_ptr, elem_index_src);
11613 const elem_ptr = try sema.elemPtr(block, array_src, array, elem_index, elem_index_src);
11614 return sema.analyzeLoad(block, array_src, elem_ptr, elem_index_src);
1157411615 },
1157511616 },
1157611617 .Array => {
11577 if (try sema.resolveMaybeUndefVal(block, src, array)) |array_val| {
11618 if (try sema.resolveMaybeUndefVal(block, array_src, array)) |array_val| {
1157811619 const elem_ty = array_ty.childType();
1157911620 if (array_val.isUndef()) return sema.addConstUndef(elem_ty);
1158011621 const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
......@@ -11584,10 +11625,10 @@ fn elemVal(
1158411625 return sema.addConstant(elem_ty, elem_val);
1158511626 }
1158611627 }
11587 try sema.requireRuntimeBlock(block, src);
11628 try sema.requireRuntimeBlock(block, array_src);
1158811629 return block.addBinOp(.array_elem_val, array, elem_index);
1158911630 },
11590 .Vector => return sema.fail(block, src, "TODO implement Sema for elemVal for vector", .{}),
11631 .Vector => return sema.fail(block, array_src, "TODO implement Sema for elemVal for vector", .{}),
1159111632 else => unreachable,
1159211633 }
1159311634}
......@@ -11615,16 +11656,7 @@ fn elemPtrArray(
1161511656 }
1161611657 // TODO safety check for array bounds
1161711658 try sema.requireRuntimeBlock(block, src);
11618 return block.addInst(.{
11619 .tag = .ptr_elem_ptr,
11620 .data = .{ .ty_pl = .{
11621 .ty = try sema.addType(result_ty),
11622 .payload = try sema.addExtra(Air.Bin{
11623 .lhs = array_ptr,
11624 .rhs = elem_index,
11625 }),
11626 } },
11627 });
11659 return block.addPtrElemPtr(array_ptr, elem_index, result_ty);
1162811660}
1162911661
1163011662fn coerce(