authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2021-04-29 17:26:21-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2021-04-29 17:26:21-07:00
log47585cbe12251ef8b32f2e711b5f2bb48d54cbe5
tree5823b9ab3ae1b9d46b5dd4334d006661e0b65e4e
parent478dac53468704909cd97bb5d47f9b1b92972022

Sema: rename TZIR to AIR

Analyzed Intermediate Representation

1 files changed, 29 insertions(+), 29 deletions(-)

src/Sema.zig+29-29
......@@ -1,7 +1,7 @@
11//! Semantic analysis of ZIR instructions.
22//! Shared to every Block. Stored on the stack.
3//! State used for compiling a `Zir` into TZIR.
4//! Transforms untyped ZIR instructions into semantically-analyzed TZIR instructions.
3//! State used for compiling a `Zir` into AIR.
4//! Transforms untyped ZIR instructions into semantically-analyzed AIR instructions.
55//! Does type checking, comptime control flow, and safety-check generation.
66//! This is the the heart of the Zig compiler.
77
......@@ -11,7 +11,7 @@ gpa: *Allocator,
1111/// Points to the arena allocator of the Decl.
1212arena: *Allocator,
1313code: Zir,
14/// Maps ZIR to TZIR.
14/// Maps ZIR to AIR.
1515inst_map: []*Inst,
1616/// When analyzing an inline function call, owner_decl is the Decl of the caller
1717/// and `src_decl` of `Scope.Block` is the `Decl` of the callee.
......@@ -26,9 +26,9 @@ owner_func: ?*Module.Fn,
2626/// This starts out the same as `owner_func` and then diverges in the case of
2727/// an inline or comptime function call.
2828func: ?*Module.Fn,
29/// For now, TZIR requires arg instructions to be the first N instructions in the
30/// TZIR code. We store references here for the purpose of `resolveInst`.
31/// This can get reworked with TZIR memory layout changes, into simply:
29/// For now, AIR requires arg instructions to be the first N instructions in the
30/// AIR code. We store references here for the purpose of `resolveInst`.
31/// This can get reworked with AIR memory layout changes, into simply:
3232/// > Denormalized data to make `resolveInst` faster. This is 0 if not inside a function,
3333/// > otherwise it is the number of parameters of the function.
3434/// > param_count: u32
......@@ -505,17 +505,17 @@ fn zirExtended(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) InnerErro
505505 }
506506}
507507
508/// TODO when we rework TZIR memory layout, this function will no longer have a possible error.
508/// TODO when we rework AIR memory layout, this function will no longer have a possible error.
509509pub fn resolveInst(sema: *Sema, zir_ref: Zir.Inst.Ref) error{OutOfMemory}!*ir.Inst {
510510 var i: usize = @enumToInt(zir_ref);
511511
512512 // First section of indexes correspond to a set number of constant values.
513513 if (i < Zir.Inst.Ref.typed_value_map.len) {
514 // TODO when we rework TZIR memory layout, this function can be as simple as:
514 // TODO when we rework AIR memory layout, this function can be as simple as:
515515 // if (zir_ref < Zir.const_inst_list.len + sema.param_count)
516516 // return zir_ref;
517517 // Until then we allocate memory for a new, mutable `ir.Inst` to match what
518 // TZIR expects.
518 // AIR expects.
519519 return sema.mod.constInst(sema.arena, .unneeded, Zir.Inst.Ref.typed_value_map[i]);
520520 }
521521 i -= Zir.Inst.Ref.typed_value_map.len;
......@@ -526,7 +526,7 @@ pub fn resolveInst(sema: *Sema, zir_ref: Zir.Inst.Ref) error{OutOfMemory}!*ir.In
526526 }
527527 i -= sema.param_inst_list.len;
528528
529 // Finally, the last section of indexes refers to the map of ZIR=>TZIR.
529 // Finally, the last section of indexes refers to the map of ZIR=>AIR.
530530 return sema.inst_map[i];
531531}
532532
......@@ -536,17 +536,17 @@ fn resolveConstString(
536536 src: LazySrcLoc,
537537 zir_ref: Zir.Inst.Ref,
538538) ![]u8 {
539 const tzir_inst = try sema.resolveInst(zir_ref);
539 const air_inst = try sema.resolveInst(zir_ref);
540540 const wanted_type = Type.initTag(.const_slice_u8);
541 const coerced_inst = try sema.coerce(block, wanted_type, tzir_inst, src);
541 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
542542 const val = try sema.resolveConstValue(block, src, coerced_inst);
543543 return val.toAllocatedBytes(sema.arena);
544544}
545545
546546fn resolveType(sema: *Sema, block: *Scope.Block, src: LazySrcLoc, zir_ref: Zir.Inst.Ref) !Type {
547 const tzir_inst = try sema.resolveInst(zir_ref);
547 const air_inst = try sema.resolveInst(zir_ref);
548548 const wanted_type = Type.initTag(.@"type");
549 const coerced_inst = try sema.coerce(block, wanted_type, tzir_inst, src);
549 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
550550 const val = try sema.resolveConstValue(block, src, coerced_inst);
551551 return val.toType(sema.arena);
552552}
......@@ -585,8 +585,8 @@ fn resolveAlreadyCoercedInt(
585585 comptime Int: type,
586586) !Int {
587587 comptime assert(@typeInfo(Int).Int.bits <= 64);
588 const tzir_inst = try sema.resolveInst(zir_ref);
589 const val = try sema.resolveConstValue(block, src, tzir_inst);
588 const air_inst = try sema.resolveInst(zir_ref);
589 const val = try sema.resolveConstValue(block, src, air_inst);
590590 switch (@typeInfo(Int).Int.signedness) {
591591 .signed => return @intCast(Int, val.toSignedInt()),
592592 .unsigned => return @intCast(Int, val.toUnsignedInt()),
......@@ -600,8 +600,8 @@ fn resolveInt(
600600 zir_ref: Zir.Inst.Ref,
601601 dest_type: Type,
602602) !u64 {
603 const tzir_inst = try sema.resolveInst(zir_ref);
604 const coerced = try sema.coerce(block, dest_type, tzir_inst, src);
603 const air_inst = try sema.resolveInst(zir_ref);
604 const coerced = try sema.coerce(block, dest_type, air_inst, src);
605605 const val = try sema.resolveConstValue(block, src, coerced);
606606
607607 return val.toUnsignedInt();
......@@ -613,10 +613,10 @@ pub fn resolveInstConst(
613613 src: LazySrcLoc,
614614 zir_ref: Zir.Inst.Ref,
615615) InnerError!TypedValue {
616 const tzir_inst = try sema.resolveInst(zir_ref);
617 const val = try sema.resolveConstValue(block, src, tzir_inst);
616 const air_inst = try sema.resolveInst(zir_ref);
617 const val = try sema.resolveConstValue(block, src, air_inst);
618618 return TypedValue{
619 .ty = tzir_inst.ty,
619 .ty = air_inst.ty,
620620 .val = val,
621621 };
622622}
......@@ -1552,7 +1552,7 @@ fn zirLoop(sema: *Sema, parent_block: *Scope.Block, inst: Zir.Inst.Index) InnerE
15521552 const extra = sema.code.extraData(Zir.Inst.Block, inst_data.payload_index);
15531553 const body = sema.code.extra[extra.end..][0..extra.data.body_len];
15541554
1555 // TZIR expects a block outside the loop block too.
1555 // AIR expects a block outside the loop block too.
15561556 const block_inst = try sema.arena.create(Inst.Block);
15571557 block_inst.* = .{
15581558 .base = .{
......@@ -3723,7 +3723,7 @@ fn analyzeSwitch(
37233723 defer merges.results.deinit(gpa);
37243724 defer merges.br_list.deinit(gpa);
37253725
3726 // TODO when reworking TZIR memory layout make multi cases get generated as cases,
3726 // TODO when reworking AIR memory layout make multi cases get generated as cases,
37273727 // not as part of the "else" block.
37283728 const cases = try sema.arena.alloc(Inst.SwitchBr.Case, scalar_cases_len);
37293729
......@@ -4788,9 +4788,9 @@ fn zirBoolBr(
47884788 const rhs_result = try sema.resolveBody(rhs_block, body);
47894789 _ = try rhs_block.addBr(src, block_inst, rhs_result);
47904790
4791 const tzir_then_body: ir.Body = .{ .instructions = try sema.arena.dupe(*Inst, then_block.instructions.items) };
4792 const tzir_else_body: ir.Body = .{ .instructions = try sema.arena.dupe(*Inst, else_block.instructions.items) };
4793 _ = try child_block.addCondBr(src, lhs, tzir_then_body, tzir_else_body);
4791 const air_then_body: ir.Body = .{ .instructions = try sema.arena.dupe(*Inst, then_block.instructions.items) };
4792 const air_else_body: ir.Body = .{ .instructions = try sema.arena.dupe(*Inst, else_block.instructions.items) };
4793 _ = try child_block.addCondBr(src, lhs, air_then_body, air_else_body);
47944794
47954795 block_inst.body = .{
47964796 .instructions = try sema.arena.dupe(*Inst, child_block.instructions.items),
......@@ -4879,18 +4879,18 @@ fn zirCondbr(
48794879 defer sub_block.instructions.deinit(sema.gpa);
48804880
48814881 _ = try sema.analyzeBody(&sub_block, then_body);
4882 const tzir_then_body: ir.Body = .{
4882 const air_then_body: ir.Body = .{
48834883 .instructions = try sema.arena.dupe(*Inst, sub_block.instructions.items),
48844884 };
48854885
48864886 sub_block.instructions.shrinkRetainingCapacity(0);
48874887
48884888 _ = try sema.analyzeBody(&sub_block, else_body);
4889 const tzir_else_body: ir.Body = .{
4889 const air_else_body: ir.Body = .{
48904890 .instructions = try sema.arena.dupe(*Inst, sub_block.instructions.items),
48914891 };
48924892
4893 _ = try parent_block.addCondBr(src, cond, tzir_then_body, tzir_else_body);
4893 _ = try parent_block.addCondBr(src, cond, air_then_body, air_else_body);
48944894 return always_noreturn;
48954895}
48964896