Commit 757d13d7843879de618247733f22f4fc515cc467 | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-04-23 20:23:16-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-04-23 20:23:16-04:00
log	757d13d7843879de618247733f22f4fc515cc467
tree	fd901a6065b3dc6d23e261e63e9567fccf52ec77
parent	0ac502f37257c607fc835840d02f0401c5e59442

codegen supports embedded-in-code constants

also coerce no longer requires a bitcast

3 files changed, 90 insertions(+), 11 deletions(-)

src-self-hosted
- codegen.zig
- ir.zig
- ir
  - text.zig

src-self-hosted/codegen.zig+28-1

...	@@ -81,6 +81,7 @@ const Function = struct {	...	@@ -81,6 +81,7 @@ const Function = struct {
81	.constant => unreachable, // excluded from function bodies	81	.constant => unreachable, // excluded from function bodies
82	.assembly => return self.genAsm(inst.cast(ir.Inst.Assembly).?),	82	.assembly => return self.genAsm(inst.cast(ir.Inst.Assembly).?),
83	.ptrtoint => return self.genPtrToInt(inst.cast(ir.Inst.PtrToInt).?),	83	.ptrtoint => return self.genPtrToInt(inst.cast(ir.Inst.PtrToInt).?),
		84	.bitcast => return self.genBitCast(inst.cast(ir.Inst.BitCast).?),
84	}	85	}
85	}	86	}
86		87
...	@@ -282,7 +283,26 @@ const Function = struct {	...	@@ -282,7 +283,26 @@ const Function = struct {
282	.rsi => switch (mcv) {	283	.rsi => switch (mcv) {
283	.none, .unreach => unreachable,	284	.none, .unreach => unreachable,
284	.immediate => return self.fail(src, "TODO implement x86_64 genSetReg %rsi = immediate", .{}),	285	.immediate => return self.fail(src, "TODO implement x86_64 genSetReg %rsi = immediate", .{}),
285	.embedded_in_code => return self.fail(src, "TODO implement x86_64 genSetReg %rsi = embedded_in_code", .{}),	286	.embedded_in_code => \|code_offset\| {
		287	// Examples:
		288	// lea rsi, [rip + 0x01020304]
		289	// lea rsi, [rip - 7]
		290	// f: 48 8d 35 04 03 02 01 lea rsi,[rip+0x1020304] # 102031a <_start+0x102031a>
		291	// 16: 48 8d 35 f9 ff ff ff lea rsi,[rip+0xfffffffffffffff9] # 16 <_start+0x16>
		292	//
		293	// We need the offset from RIP in a signed i32 twos complement.
		294	// The instruction is 7 bytes long and RIP points to the next instruction.
		295	try self.code.resize(self.code.items.len + 7);
		296	const rip = self.code.items.len;
		297	const big_offset = @intCast(i64, code_offset) - @intCast(i64, rip);
		298	const offset = @intCast(i32, big_offset);
		299	self.code.items[self.code.items.len - 7] = 0x48;
		300	self.code.items[self.code.items.len - 6] = 0x8d;
		301	self.code.items[self.code.items.len - 5] = 0x35;
		302	const imm_ptr = self.code.items[self.code.items.len - 4 ..][0..4];
		303	mem.writeIntLittle(i32, imm_ptr, offset);
		304	return;
		305	},
286	.register => return self.fail(src, "TODO implement x86_64 genSetReg %rsi = register", .{}),	306	.register => return self.fail(src, "TODO implement x86_64 genSetReg %rsi = register", .{}),
287	},	307	},
288	.rdx => switch (mcv) {	308	.rdx => switch (mcv) {
...	@@ -302,6 +322,11 @@ const Function = struct {	...	@@ -302,6 +322,11 @@ const Function = struct {
302	return self.resolveInst(inst.args.ptr);	322	return self.resolveInst(inst.args.ptr);
303	}	323	}
304		324
		325	fn genBitCast(self: Function, inst: ir.Inst.BitCast) !MCValue {
		326	const operand = try self.resolveInst(inst.args.operand);
		327	return operand;
		328	}
		329
305	fn resolveInst(self: Function, inst: ir.Inst) !MCValue {	330	fn resolveInst(self: Function, inst: ir.Inst) !MCValue {
306	if (self.inst_table.getValue(inst)) \|mcv\| {	331	if (self.inst_table.getValue(inst)) \|mcv\| {
307	return mcv;	332	return mcv;
...	@@ -344,6 +369,8 @@ const Function = struct {	...	@@ -344,6 +369,8 @@ const Function = struct {
344	}	369	}
345	return MCValue{ .immediate = typed_value.val.toUnsignedInt() };	370	return MCValue{ .immediate = typed_value.val.toUnsignedInt() };
346	},	371	},
		372	.ComptimeInt => unreachable, // semantic analysis prevents this
		373	.ComptimeFloat => unreachable, // semantic analysis prevents this
347	else => return self.fail(src, "TODO implement const of type '{}'", .{typed_value.ty}),	374	else => return self.fail(src, "TODO implement const of type '{}'", .{typed_value.ty}),
348	}	375	}
349	}	376	}

src-self-hosted/ir.zig+35-10

 @@ -24,6 +24,7 @@ pub const Inst = struct {
         constant,
         assembly,
         ptrtoint,
+        bitcast,
     };
     pub fn cast(base: *Inst, comptime T: type) ?*T {
 @@ -45,6 +46,7 @@ pub const Inst = struct {
             .assembly,
             .ptrtoint,
+            .bitcast,
             => null,
         };
     }
 @@ -84,6 +86,15 @@ pub const Inst = struct {
             ptr: *Inst,
         },
     };
+    pub const BitCast = struct {
+        pub const base_tag = Tag.bitcast;
+        base: Inst,
+        args: struct {
+            operand: *Inst,
+        },
+    };
 };
 pub const TypedValue = struct {
 @@ -234,7 +245,7 @@ const Analyze = struct {
     fn resolveConstString(self: *Analyze, func: ?*Fn, old_inst: *text.Inst) ![]u8 {
         const new_inst = try self.resolveInst(func, old_inst);
         const wanted_type = Type.initTag(.const_slice_u8);
-        const coerced_inst = try self.coerce(wanted_type, new_inst);
+        const coerced_inst = try self.coerce(func, wanted_type, new_inst);
         const val = try self.resolveConstValue(coerced_inst);
         return val.toAllocatedBytes(&self.arena.allocator);
     }
 @@ -242,7 +253,7 @@ const Analyze = struct {
     fn resolveType(self: *Analyze, func: ?*Fn, old_inst: *text.Inst) !Type {
         const new_inst = try self.resolveInst(func, old_inst);
         const wanted_type = Type.initTag(.@"type");
-        const coerced_inst = try self.coerce(wanted_type, new_inst);
+        const coerced_inst = try self.coerce(func, wanted_type, new_inst);
         const val = try self.resolveConstValue(coerced_inst);
         return val.toType();
     }
 @@ -409,6 +420,7 @@ const Analyze = struct {
             .primitive => return self.analyzeInstPrimitive(func, old_inst.cast(text.Inst.Primitive).?),
             .fntype => return self.analyzeInstFnType(func, old_inst.cast(text.Inst.FnType).?),
             .intcast => return self.analyzeInstIntCast(func, old_inst.cast(text.Inst.IntCast).?),
+            .bitcast => return self.analyzeInstBitCast(func, old_inst.cast(text.Inst.BitCast).?),
         }
     }
 @@ -472,7 +484,7 @@ const Analyze = struct {
     fn analyzeInstAs(self: *Analyze, func: ?*Fn, as: *text.Inst.As) InnerError!*Inst {
         const dest_type = try self.resolveType(func, as.positionals.dest_type);
         const new_inst = try self.resolveInst(func, as.positionals.value);
-        return self.coerce(dest_type, new_inst);
+        return self.coerce(func, dest_type, new_inst);
     }
     fn analyzeInstPtrToInt(self: *Analyze, func: ?*Fn, ptrtoint: *text.Inst.PtrToInt) InnerError!*Inst {
 @@ -545,12 +557,18 @@ const Analyze = struct {
         }
         if (dest_is_comptime_int or new_inst.value() != null) {
-            return self.coerce(dest_type, new_inst);
+            return self.coerce(func, dest_type, new_inst);
         }
         return self.fail(intcast.base.src, "TODO implement analyze widen or shorten int", .{});
     }
+    fn analyzeInstBitCast(self: *Analyze, func: ?*Fn, inst: *text.Inst.BitCast) InnerError!*Inst {
+        const dest_type = try self.resolveType(func, inst.positionals.dest_type);
+        const operand = try self.resolveInst(func, inst.positionals.operand);
+        return self.bitcast(func, dest_type, operand);
+    }
     fn analyzeInstDeref(self: *Analyze, func: ?*Fn, deref: *text.Inst.Deref) InnerError!*Inst {
         const ptr = try self.resolveInst(func, deref.positionals.ptr);
         const elem_ty = switch (ptr.ty.zigTypeTag()) {
 @@ -583,7 +601,8 @@ const Analyze = struct {
             elem.* = try self.resolveConstString(func, assembly.kw_args.clobbers[i]);
         }
         for (args) |*elem, i| {
-            elem.* = try self.resolveInst(func, assembly.kw_args.args[i]);
+            const arg = try self.resolveInst(func, assembly.kw_args.args[i]);
+            elem.* = try self.coerce(func, Type.initTag(.usize), arg);
         }
         const f = try self.requireFunctionBody(func, assembly.base.src);
 @@ -602,10 +621,14 @@ const Analyze = struct {
         return self.addNewInstArgs(f, unreach.base.src, Type.initTag(.noreturn), Inst.Unreach, {});
     }
-    fn coerce(self: *Analyze, dest_type: Type, inst: *Inst) !*Inst {
+    fn coerce(self: *Analyze, func: ?*Fn, dest_type: Type, inst: *Inst) !*Inst {
+        // If the types are the same, we can return the operand.
+        if (dest_type.eql(inst.ty))
+            return inst;
         const in_memory_result = coerceInMemoryAllowed(dest_type, inst.ty);
         if (in_memory_result == .ok) {
-            return self.bitcast(dest_type, inst);
+            return self.bitcast(func, dest_type, inst);
         }
         // *[N]T to []T
 @@ -634,12 +657,14 @@ const Analyze = struct {
         return self.fail(inst.src, "TODO implement type coercion", .{});
     }
-    fn bitcast(self: *Analyze, dest_type: Type, inst: *Inst) !*Inst {
+    fn bitcast(self: *Analyze, func: ?*Fn, dest_type: Type, inst: *Inst) !*Inst {
         if (inst.value()) |val| {
             // Keep the comptime Value representation; take the new type.
             return self.constInst(inst.src, .{ .ty = dest_type, .val = val });
         }
-        return self.fail(inst.src, "TODO implement runtime bitcast", .{});
+        // TODO validate the type size and other compile errors
+        const f = try self.requireFunctionBody(func, inst.src);
+        return self.addNewInstArgs(f, inst.src, dest_type, Inst.BitCast, Inst.Args(Inst.BitCast){ .operand = inst });
     }
     fn coerceArrayPtrToSlice(self: *Analyze, dest_type: Type, inst: *Inst) !*Inst {
 @@ -713,7 +738,7 @@ pub fn main() anyerror!void {
         std.process.exit(1);
     }
-    const output_zir = false;
+    const output_zir = true;
     if (output_zir) {
         var new_zir_module = try text.emit_zir(allocator, analyzed_module);
         defer new_zir_module.deinit(allocator);

src-self-hosted/ir/text.zig+27

...	@@ -31,6 +31,7 @@ pub const Inst = struct {	...	@@ -31,6 +31,7 @@ pub const Inst = struct {
31	primitive,	31	primitive,
32	fntype,	32	fntype,
33	intcast,	33	intcast,
		34	bitcast,
34	};	35	};
35		36
36	pub fn TagToType(tag: Tag) type {	37	pub fn TagToType(tag: Tag) type {
...	@@ -48,6 +49,7 @@ pub const Inst = struct {	...	@@ -48,6 +49,7 @@ pub const Inst = struct {
48	.primitive => Primitive,	49	.primitive => Primitive,
49	.fntype => FnType,	50	.fntype => FnType,
50	.intcast => IntCast,	51	.intcast => IntCast,
		52	.bitcast => BitCast,
51	};	53	};
52	}	54	}
53		55
...	@@ -258,6 +260,17 @@ pub const Inst = struct {	...	@@ -258,6 +260,17 @@ pub const Inst = struct {
258	},	260	},
259	kw_args: struct {},	261	kw_args: struct {},
260	};	262	};
		263
		264	pub const BitCast = struct {
		265	pub const base_tag = Tag.bitcast;
		266	base: Inst,
		267
		268	positionals: struct {
		269	dest_type: *Inst,
		270	operand: *Inst,
		271	},
		272	kw_args: struct {},
		273	};
261	};	274	};
262		275
263	pub const ErrorMsg = struct {	276	pub const ErrorMsg = struct {
...	@@ -331,6 +344,7 @@ pub const Module = struct {	...	@@ -331,6 +344,7 @@ pub const Module = struct {
331	.primitive => return self.writeInstToStreamGeneric(stream, .primitive, decl, inst_table),	344	.primitive => return self.writeInstToStreamGeneric(stream, .primitive, decl, inst_table),
332	.fntype => return self.writeInstToStreamGeneric(stream, .fntype, decl, inst_table),	345	.fntype => return self.writeInstToStreamGeneric(stream, .fntype, decl, inst_table),
333	.intcast => return self.writeInstToStreamGeneric(stream, .intcast, decl, inst_table),	346	.intcast => return self.writeInstToStreamGeneric(stream, .intcast, decl, inst_table),
		347	.bitcast => return self.writeInstToStreamGeneric(stream, .bitcast, decl, inst_table),
334	}	348	}
335	}	349	}
336		350
...	@@ -957,6 +971,19 @@ const EmitZIR = struct {	...	@@ -957,6 +971,19 @@ const EmitZIR = struct {
957	};	971	};
958	break :blk &new_inst.base;	972	break :blk &new_inst.base;
959	},	973	},
		974	.bitcast => blk: {
		975	const old_inst = inst.cast(ir.Inst.BitCast).?;
		976	const new_inst = try self.arena.allocator.create(Inst.BitCast);
		977	new_inst.* = .{
		978	.base = .{ .src = inst.src, .tag = Inst.BitCast.base_tag },
		979	.positionals = .{
		980	.dest_type = try self.emitType(inst.src, inst.ty),
		981	.operand = try self.resolveInst(&inst_table, old_inst.args.operand),
		982	},
		983	.kw_args = .{},
		984	};
		985	break :blk &new_inst.base;
		986	},
960	};	987	};
961	try instructions.append(new_inst);	988	try instructions.append(new_inst);
962	try inst_table.putNoClobber(inst, new_inst);	989	try inst_table.putNoClobber(inst, new_inst);