srctree

"${CMAKE_SOURCE_DIR}/src/TypedValue.zig"

anon_work_queue: std.fifo.LinearFifo(Job, .Dynamic),

.anon_work_queue = std.fifo.LinearFifo(Job, .Dynamic).init(gpa),

comp.anon_work_queue.deinit();

// In this main loop we give priority to non-anonymous Decls in the work queue, so

// that they can establish references to anonymous Decls, setting alive=true in the

// backend, preventing anonymous Decls from being prematurely destroyed.

if (comp.anon_work_queue.readItem()) |work_item| {

try processOneJob(comp, work_item, main_progress_node);

continue;

}

if (decl.alive) {

try module.linkerUpdateDecl(decl_index);

return;

}

 

// Instead of sending this decl to the linker, we actually will delete it

// because we found out that it in fact was never referenced.

module.deleteUnusedDecl(decl_index);

func_ty,

func_ty,

func_ty: Index,

.ty = @import("type.zig").Type.fromInterned(func_ty),

.alive = true,

const TypedValue = @import("TypedValue.zig");

/// The most recent Type of the Decl after a successful semantic analysis.

/// Populated when `has_tv`.

ty: Type,

/// Flag used by garbage collection to mark and sweep.

/// Decls which correspond to an AST node always have this field set to `true`.

/// Anonymous Decls are initialized with this field set to `false` and then it

/// is the responsibility of machine code backends to mark it `true` whenever

/// a `decl_ref` Value is encountered that points to this Decl.

/// When the `codegen_decl` job is encountered in the main work queue, if the

/// Decl is marked alive, then it sends the Decl to the linker. Otherwise it

/// deletes the Decl on the spot.

alive: bool,

pub fn tokSrcLoc(decl: Decl, token_index: Ast.TokenIndex) LazySrcLoc {

return .{ .token_offset = token_index - decl.srcToken() };

}

 

pub fn nodeSrcLoc(decl: Decl, node_index: Ast.Node.Index) LazySrcLoc {

return LazySrcLoc.nodeOffset(decl.nodeIndexToRelative(node_index));

}

 

pub fn srcToken(decl: Decl, zcu: *Zcu) Ast.TokenIndex {

const tree = &decl.getFileScope(zcu).tree;

return tree.firstToken(decl.src_node);

}

 

pub fn srcByteOffset(decl: Decl, zcu: *Zcu) u32 {

const tree = &decl.getFileScope(zcu).tree;

return tree.tokens.items(.start)[decl.srcToken()];

}

 

pub fn typedValue(decl: Decl) error{AnalysisFail}!TypedValue {

if (!decl.has_tv) return error.AnalysisFail;

return TypedValue{ .ty = decl.ty, .val = decl.val };

}

 

pub fn internValue(decl: *Decl, zcu: *Zcu) Allocator.Error!InternPool.Index {

const ip_index = try decl.val.intern(decl.ty, zcu);

decl.val = Value.fromInterned(ip_index);

return ip_index;

pub fn isFunction(decl: Decl, zcu: *const Zcu) !bool {

const tv = try decl.typedValue();

return tv.ty.zigTypeTag(zcu) == .Fn;

}

 

/// If the Decl owns its value and it is a struct, return it,

/// otherwise null.

pub fn getOwnedStruct(decl: Decl, zcu: *Zcu) ?InternPool.Key.StructType {

if (!decl.owns_tv) return null;

if (decl.val.ip_index == .none) return null;

return zcu.typeToStruct(decl.val.toType());

}

 

/// If the Decl owns its value and it is a union, return it,

/// otherwise null.

pub fn getOwnedUnion(decl: Decl, zcu: *Zcu) ?InternPool.LoadedUnionType {

if (!decl.owns_tv) return null;

if (decl.val.ip_index == .none) return null;

return zcu.typeToUnion(decl.val.toType());

std.debug.print(" ty={} val={}", .{ decl.ty, decl.val });

return decl.ty.abiAlignment(zcu);

new_decl.ty = Type.type;

new_decl.alive = true; // This Decl corresponds to a File and is therefore always alive.

const old_ty = decl.ty;

const decl_tv = try sema.resolveFinalDeclValue(&block_scope, init_src, result_ref);

try sema.resolveTypeLayout(decl_tv.ty);

if (!decl_tv.ty.eql(Type.type, mod)) {

decl_tv.ty.fmt(mod),

const ty = decl_tv.val.toType();

decl.ty = Type.fromInterned(InternPool.Index.type_type);

switch (decl_tv.val.toIntern()) {

else => switch (ip.indexToKey(decl_tv.val.toIntern())) {

is_inline = decl.owns_tv and decl_tv.ty.fnCallingConvention(mod) == .Inline;

decl.ty = decl_tv.ty;

decl.val = Value.fromInterned((try decl_tv.val.intern(decl_tv.ty, mod)));

const addrspace_ctx: Sema.AddressSpaceContext = switch (ip.indexToKey(decl_tv.val.toIntern())) {

.invalidate_decl_val = !decl.ty.eql(old_ty, mod) or

!decl.val.eql(old_val, decl.ty, mod) or

.invalidate_decl_ref = !decl.ty.eql(old_ty, mod) or

const has_runtime_bits = queue_linker_work and (is_func or try sema.typeHasRuntimeBits(decl.ty));

try sema.resolveTypeFully(decl.ty);

switch (decl.ty.zigTypeTag(zcu)) {

assert(decl.alive);

new_decl.alive = true; // This Decl corresponds to an AST node and is therefore always alive.

/// This function is exclusively called for anonymous decls.

/// All resources referenced by anonymous decls are owned by InternPool

/// so there is no cleanup to do here.

pub fn deleteUnusedDecl(mod: *Module, decl_index: Decl.Index) void {

const gpa = mod.gpa;

const ip = &mod.intern_pool;

 

ip.destroyDecl(gpa, decl_index);

 

if (mod.emit_h) |mod_emit_h| {

const decl_emit_h = mod_emit_h.declPtr(decl_index);

decl_emit_h.fwd_decl.deinit(gpa);

decl_emit_h.* = undefined;

}

}

 

// The Decl starts off with alive=false and the codegen backend will set alive=true

// if the Decl is referenced by an instruction or another constant. Otherwise,

// the Decl will be garbage collected by the `codegen_decl` task instead of sent

// to the linker.

if (mod.declPtr(decl_index).ty.isFnOrHasRuntimeBits(mod)) {

try mod.comp.anon_work_queue.writeItem(.{ .codegen_decl = decl_index });

const fn_ty = decl.ty;

.ty = undefined,

.alive = false,

pub fn createAnonymousDecl(mod: *Module, block: *Sema.Block, typed_value: TypedValue) !Decl.Index {

const src_decl = mod.declPtr(block.src_decl);

return mod.createAnonymousDeclFromDecl(src_decl, block.namespace, typed_value);

}

 

pub fn createAnonymousDeclFromDecl(

mod: *Module,

src_decl: *Decl,

namespace: Namespace.Index,

tv: TypedValue,

) !Decl.Index {

const new_decl_index = try mod.allocateNewDecl(namespace, src_decl.src_node);

errdefer mod.destroyDecl(new_decl_index);

const name = try mod.intern_pool.getOrPutStringFmt(mod.gpa, "{}__anon_{d}", .{

src_decl.name.fmt(&mod.intern_pool), @intFromEnum(new_decl_index),

});

try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, tv, name);

return new_decl_index;

}

 

typed_value: TypedValue,

assert(typed_value.ty.toIntern() == mod.intern_pool.typeOf(typed_value.val.toIntern()));

 

new_decl.ty = typed_value.ty;

new_decl.val = typed_value.val;

const test_fn_ty = decl.ty.slicePtrFieldType(mod).childType(mod);

const array_decl_index = d: {

const test_name_decl_index = n: {

const test_name_decl_ty = try mod.arrayType(.{

const test_name_decl_index = try mod.createAnonymousDeclFromDecl(decl, decl.src_namespace, .{

.ty = test_name_decl_ty,

.val = Value.fromInterned((try mod.intern(.{ .aggregate = .{

.ty = test_name_decl_ty.toIntern(),

.storage = .{ .bytes = test_decl_name },

} }))),

});

break :n test_name_decl_index;

try mod.linkerUpdateDecl(test_name_decl_index);

.addr = .{ .decl = test_name_decl_index },

.child = test_decl.ty.toIntern(),

const array_decl_ty = try mod.arrayType(.{

const array_decl_index = try mod.createAnonymousDeclFromDecl(decl, decl.src_namespace, .{

.ty = array_decl_ty,

.val = Value.fromInterned((try mod.intern(.{ .aggregate = .{

.ty = array_decl_ty.toIntern(),

.storage = .{ .elems = test_fn_vals },

} }))),

});

 

break :d array_decl_index;

try mod.linkerUpdateDecl(array_decl_index);

.addr = .{ .decl = array_decl_index },

decl.ty = new_ty;

pub fn markReferencedDeclsAlive(mod: *Module, val: Value) Allocator.Error!void {

switch (mod.intern_pool.indexToKey(val.toIntern())) {

.variable => |variable| try mod.markDeclIndexAlive(variable.decl),

.extern_func => |extern_func| try mod.markDeclIndexAlive(extern_func.decl),

.func => |func| try mod.markDeclIndexAlive(func.owner_decl),

.error_union => |error_union| switch (error_union.val) {

.err_name => {},

.payload => |payload| try mod.markReferencedDeclsAlive(Value.fromInterned(payload)),

},

.slice => |slice| {

try mod.markReferencedDeclsAlive(Value.fromInterned(slice.ptr));

try mod.markReferencedDeclsAlive(Value.fromInterned(slice.len));

},

.ptr => |ptr| switch (ptr.addr) {

.decl => |decl| try mod.markDeclIndexAlive(decl),

.anon_decl => {},

.int, .comptime_field, .comptime_alloc => {},

.eu_payload, .opt_payload => |parent| try mod.markReferencedDeclsAlive(Value.fromInterned(parent)),

.elem, .field => |base_index| try mod.markReferencedDeclsAlive(Value.fromInterned(base_index.base)),

},

.opt => |opt| if (opt.val != .none) try mod.markReferencedDeclsAlive(Value.fromInterned(opt.val)),

.aggregate => |aggregate| for (aggregate.storage.values()) |elem|

try mod.markReferencedDeclsAlive(Value.fromInterned(elem)),

.un => |un| {

if (un.tag != .none) try mod.markReferencedDeclsAlive(Value.fromInterned(un.tag));

try mod.markReferencedDeclsAlive(Value.fromInterned(un.val));

},

else => {},

}

}

 

pub fn markDeclAlive(mod: *Module, decl: *Decl) Allocator.Error!void {

if (decl.alive) return;

decl.alive = true;

 

_ = try decl.internValue(mod);

 

// This is the first time we are marking this Decl alive. We must

// therefore recurse into its value and mark any Decl it references

// as also alive, so that any Decl referenced does not get garbage collected.

try mod.markReferencedDeclsAlive(decl.val);

}

 

fn markDeclIndexAlive(mod: *Module, decl_index: Decl.Index) Allocator.Error!void {

return mod.markDeclAlive(mod.declPtr(decl_index));

}

 

ty: Type,

val: Value,

.ty = ty,

.val = Value.fromInterned(try sema.mod.intern(.{ .undef = ty.toIntern() })),

const TypedValue = @import("TypedValue.zig");

const inline_body = if (cond.val.toBool()) then_body else else_body;

const inline_body = if (cond.val.toBool()) then_body else else_body;

const wanted_type = Type.slice_const_u8;

const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);

const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, reason);

return val.toAllocatedBytes(wanted_type, sema.arena, sema.mod);

) CompileError!TypedValue {

const val = try sema.resolveConstDefinedValue(block, src, air_ref, reason);

return .{

.ty = sema.typeOf(air_ref),

.val = val,

};

) CompileError!TypedValue {

return .{

.ty = sema.typeOf(air_ref),

.val = val,

};

int_ty.fmt(sema.mod), val.fmtValue(int_ty, sema.mod),

int_ty.fmt(sema.mod), val.fmtValue(int_ty, sema.mod),

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = Value.fromInterned(wip_ty.index),

}, small.name_strategy, "struct", inst);

typed_value: TypedValue,

try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, typed_value, name);

try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, typed_value, name);

return sema.createAnonymousDeclTypeNamed(block, src, typed_value, .anon, anon_prefix, null);

try writer.print("{}", .{arg_val.fmtValue(sema.typeOf(arg), sema.mod)});

try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, typed_value, name);

try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, typed_value, name);

return sema.createAnonymousDeclTypeNamed(block, src, typed_value, .anon, anon_prefix, null);

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = Value.fromInterned(wip_ty.index),

}, small.name_strategy, "enum", inst);

const msg = try sema.errMsg(block, value_src, "enum tag value {} already taken", .{last_tag_val.?.fmtValue(int_tag_ty, sema.mod)});

const msg = try sema.errMsg(block, field_src, "enum tag value {} already taken", .{last_tag_val.?.fmtValue(int_tag_ty, sema.mod)});

last_tag_val.?.fmtValue(int_tag_ty, mod), int_tag_ty.fmt(mod),

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = Value.fromInterned(wip_ty.index),

}, small.name_strategy, "union", inst);

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = Value.fromInterned(wip_ty.index),

}, small.name_strategy, "opaque", inst);

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = error_set_ty.toValue(),

}, name_strategy, "error", inst);

const interned = try ct_alloc.val.intern(ct_alloc.ty, mod);

ct_alloc.val = Value.fromInterned(interned);

alloc.val = Value.fromInterned(result_val);

break :val try alloc.val.intern(alloc.ty, mod);

v.fmtValue(Type.usize, sema.mod),

arg_val.fmtValue(Type.usize, sema.mod),

sema.getComptimeAlloc(alloc_index).val = operand_val;

arg_ty.fmt(mod), val.fmtValue(arg_ty, mod),

if (operand.val.getFunction(mod)) |function| {

.exported = .{ .value = operand.val.toIntern() },

if (!try sema.validateExternType(exported_decl.ty, .other)) {

const msg = try sema.errMsg(block, src, "unable to export type '{}'", .{exported_decl.ty.fmt(mod)});

try sema.explainWhyTypeIsNotExtern(msg, src_decl.toSrcLoc(src, mod), exported_decl.ty, .other);

try sema.addDeclaredHereNote(msg, exported_decl.ty);

// This decl is alive no matter what, since it's being exported

try mod.markDeclAlive(exported_decl);

switch (fn_owner_decl.ty.fnCallingConvention(mod)) {

const owner_info = mod.typeToFunc(fn_owner_decl.ty).?;

const result_interned = try result_val.intern2(sema.fn_ret_ty, mod);

const result_interned = try result_val.intern2(sema.fn_ret_ty, mod);

const result_transformed = try sema.resolveAdHocInferredErrorSet(block, call_src, result_interned);

if (!func_ty.eql(func_decl.ty, mod)) {

func_ty.fmt(mod), func_decl.ty.fmt(mod),

memoized_arg_values[arg_i.*] = try resolved_arg_val.intern(Type.fromInterned(param_ty), mod);

memoized_arg_values[arg_i.*] = try resolved_arg_val.intern(ics.caller().typeOf(uncasted_arg), mod);

int_val.fmtValue(sema.typeOf(operand), mod), dest_ty.fmt(mod),

dest_ty.fmt(mod), int_val.fmtValue(sema.typeOf(operand), mod),

rhs_elem.fmtValue(scalar_ty, mod),

rhs_val.fmtValue(scalar_ty, mod),

rhs_elem.fmtValue(scalar_ty, mod),

rhs_val.fmtValue(scalar_ty, mod),

rhs_elem.fmtValue(scalar_ty, mod),

rhs_val.fmtValue(scalar_ty, mod),

rhs_elem.fmtValue(scalar_ty, mod),

rhs_val.fmtValue(scalar_ty, mod),

elem.* = try (try elem_val.bitwiseNot(scalar_type, sema.arena, mod)).intern(scalar_type, mod);

(try sema.pointerDeref(block, lhs_src, lhs_val, lhs_ty)).?

(try sema.pointerDeref(block, rhs_src, rhs_val, rhs_ty)).?

element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);

element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);

// TODO: in the Many case here this should only work if the type

// has a sentinel, and this code should compute the length based

// on the sentinel value.

.Slice, .Many => {

.len = val.sliceLen(mod),

.C => {},

if (try sema.resolveDefinedValue(block, lhs_src, lhs)) |lhs_val| {

(try sema.pointerDeref(block, lhs_src, lhs_val, lhs_ty)).?

const elem_val = (try lhs_sub_val.maybeElemValueFull(sema, mod, 0)).?;

const elem_val = (try lhs_sub_val.maybeElemValueFull(sema, mod, lhs_i)).?;

.{ lhs_ty.fmt(mod), rhs_ty.fmt(mod), rem.fmtValue(resolved_type, mod) },

scalar.* = try (try sema.intRemScalar(lhs_elem, rhs_elem, scalar_ty)).intern(scalar_ty, mod);

try (try mod.enumValueFieldIndex(signedness_ty, @intFromEnum(info.signedness))).intern(signedness_ty, mod),

try (try mod.enumValueFieldIndex(ptr_size_ty, @intFromEnum(info.flags.size))).intern(ptr_size_ty, mod),

try (try mod.enumValueFieldIndex(addrspace_ty, @intFromEnum(info.flags.address_space))).intern(addrspace_ty, mod),

.tag = try tag_val.intern(tag_ty, mod),

.val = try init_val.intern(field_ty, mod),

.tag = try tag_val.intern(tag_ty, mod),

.val = try val.intern(field_ty, mod),

field_val.* = try init_val.intern(Type.fromInterned(field_ty.*), mod);

for (elem_vals, resolved_args, 0..) |*val, arg, i| {

const elem_ty = if (is_tuple)

array_ty.structFieldType(i, mod)

else

array_ty.elemType2(mod);

val.* = try ((sema.resolveValue(arg) catch unreachable).?).intern(elem_ty, mod);

elem.* = try (try eval(elem_val, scalar_ty, sema.arena, sema.mod)).intern(scalar_ty, mod);

val.fmtValue(enum_ty, sema.mod), enum_decl.name.fmt(ip),

if (try sema.anyUndef(Value.fromInterned(union_val.val))) return sema.failWithUseOfUndef(block, src);

const len = try sema.usizeCast(block, src, payload_val.sliceLen(mod));

const elem_val = (try payload_val.maybeElemValueFull(sema, mod, i)).?;

if (decls_val.sliceLen(mod) > 0) {

return try sema.reifyStruct(block, inst, src, layout, backing_integer_val, fields_val, name_strategy, is_tuple_val.toBool());

if (decls_val.sliceLen(mod) > 0) {

return sema.reifyEnum(block, inst, src, tag_type_val.toType(), is_exhaustive_val.toBool(), fields_val, name_strategy);

if (decls_val.sliceLen(mod) > 0) {

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = Value.fromInterned(wip_ty.index),

}, name_strategy, "opaque", inst);

if (decls_val.sliceLen(mod) > 0) {

return sema.reifyUnion(block, inst, src, layout, tag_type_val, fields_val, name_strategy);

const params_val = try Value.fromInterned(union_val.val).fieldValue(mod, struct_type.nameIndex(

const args_len = try sema.usizeCast(block, src, params_val.sliceLen(mod));

const elem_val = (try params_val.maybeElemValueFull(sema, mod, i)).?;

const fields_len: u32 = @intCast(fields_val.sliceLen(mod));

const field_info = (try fields_val.maybeElemValueFull(sema, mod, field_idx)).?;

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = Value.fromInterned(wip_ty.index),

}, name_strategy, "enum", inst);

const field_info = (try fields_val.maybeElemValueFull(sema, mod, field_idx)).?;

field_value_val.fmtValue(Type.comptime_int, mod),

const msg = try sema.errMsg(block, src, "enum tag value {} already taken", .{field_value_val.fmtValue(Type.comptime_int, mod)});

const fields_len: u32 = @intCast(fields_val.sliceLen(mod));

const field_info = (try fields_val.maybeElemValueFull(sema, mod, field_idx)).?;

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = Value.fromInterned(wip_ty.index),

}, name_strategy, "union", inst);

const field_info = (try fields_val.maybeElemValueFull(sema, mod, field_idx)).?;

const field_info = (try fields_val.maybeElemValueFull(sema, mod, field_idx)).?;

const fields_len: u32 = @intCast(fields_val.sliceLen(mod));

const field_info = (try fields_val.maybeElemValueFull(sema, mod, field_idx)).?;

const new_decl_index = try sema.createAnonymousDeclTypeNamed(block, src, .{

.ty = Type.type,

.val = Value.fromInterned(wip_ty.index),

}, name_strategy, "struct", inst);

const field_info = (try fields_val.maybeElemValueFull(sema, mod, field_idx)).?;

Value.fromInterned(dest_info.sentinel).fmtValue(Type.fromInterned(dest_info.child), mod),

Value.fromInterned(src_info.sentinel).fmtValue(Type.fromInterned(src_info.child), mod),

Value.fromInterned(dest_info.sentinel).fmtValue(Type.fromInterned(dest_info.child), mod),

elem.* = try (try elem_val.intTrunc(operand_scalar_ty, sema.arena, dest_info.signedness, dest_info.bits, mod)).intern(dest_scalar_ty, mod);

elem.* = try (try elem_val.byteSwap(scalar_ty, mod, sema.arena)).intern(scalar_ty, mod);

elem.* = try (try elem_val.bitReverse(scalar_ty, mod, sema.arena)).intern(scalar_ty, mod);

const name_val = try sema.resolveConstDefinedValue(block, name_src, name_operand, .{

const name_ty = Type.slice_const_u8;

const name = try name_val.toAllocatedBytes(name_ty, sema.arena, mod);

const section_ty = Type.slice_const_u8;

try section_val.toAllocatedBytes(section_ty, sema.arena, mod)

values[i] = try (try (if (int >= 0) a_val else b_val).elemValue(mod, unsigned)).intern(elem_ty, mod);

elem.* = try (try (if (should_choose_a) a_val else b_val).elemValue(mod, i)).intern(elem_ty, mod);

dest_len_val.fmtValue(Type.usize, sema.mod),

src_len_val.fmtValue(Type.usize, sema.mod),

const ret_ty_tv = sema.resolveInstConst(block, ret_src, ret_ty_ref, .{

const ty = ret_ty_tv.val.toType();

break :blk ty;

const name_val = try sema.resolveConstDefinedValue(block, name_src, name_ref, .{

const name = try name_val.toAllocatedBytes(Type.slice_const_u8, sema.arena, mod);

const library_name = try library_name_payload.toAllocatedBytes(Type.slice_const_u8, sema.arena, mod);

try mod.initNewAnonDecl(new_decl_index, sema.owner_decl.src_line, .{

.ty = Type.fromInterned(ptr_info.child),

.val = Value.fromInterned(

}, options.name);

const tv = try mod.declPtr(decl_index).typedValue();

assert(tv.ty.zigTypeTag(mod) == .Fn);

assert(try sema.fnHasRuntimeBits(tv.ty));

const func_index = tv.val.toIntern();

try mod.ensureFuncBodyAnalysisQueued(func_index);

mod.panic_func_index = func_index;

.base = try struct_ptr_val.intern(struct_ptr_ty, mod),

const slice_len = slice_val.sliceLen(mod);

try mod.intRef(Type.usize, slice_val.sliceLen(mod))

const slice_len = slice_val.sliceLen(mod);

break :len try mod.intRef(Type.usize, slice_val.sliceLen(mod));

return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(mod), val.fmtValue(inst_ty, mod) });

.{ dest_ty.fmt(mod), val.fmtValue(inst_ty, mod) },

sentinel.actual.fmtValue(sentinel.ty, mod), sentinel.wanted.fmtValue(sentinel.ty, mod),

sentinel.wanted.fmtValue(sentinel.ty, mod),

sentinel.actual.fmtValue(sentinel.ty, mod), sentinel.wanted.fmtValue(sentinel.ty, mod),

sentinel.wanted.fmtValue(sentinel.ty, mod),

val_ptr.* = Value.fromInterned((try val_ptr.intern(operand_ty, mod)));

if (!operand_val.eql(val_ptr.*, operand_ty, mod)) {

val_ptr.* = Value.fromInterned((try operand_val.intern(operand_ty, mod)));

reinterpret.val_ptr.*.writeToMemory(mut_kit.ty, mod, buffer) catch |err| switch (err) {

reinterpret.val_ptr.* = Value.fromInterned((try val.intern(mut_kit.ty, mod)));

direct: *Value,

val_ptr: *Value,

return sema.beginComptimePtrMutationInner(block, src, alloc.ty, &alloc.val, ptr_elem_ty, .{ .alloc = alloc_index });

const duped = try sema.arena.create(Value);

duped.* = Value.fromInterned(comptime_field);

Type.fromInterned(mod.intern_pool.typeOf(comptime_field)),

if (val_ptr.ip_index == .none and val_ptr.tag() == .eu_payload) {

return ComptimePtrMutationKit{

.root = parent.root,

.pointee = .{ .direct = &val_ptr.castTag(.eu_payload).?.data },

.ty = payload_ty,

};

} else {

// representation of the error union from `undef` to `opt_payload`.

 

const payload = try sema.arena.create(Value.Payload.SubValue);

payload.* = .{

.base = .{ .tag = .eu_payload },

.data = Value.fromInterned((try mod.intern(.{ .undef = payload_ty.toIntern() }))),

};

 

val_ptr.* = Value.initPayload(&payload.base);

 

return ComptimePtrMutationKit{

.root = parent.root,

.pointee = .{ .direct = &payload.data },

.ty = payload_ty,

};

.reinterpret => return ComptimePtrMutationKit{

switch (val_ptr.ip_index) {

.none => return ComptimePtrMutationKit{

.root = parent.root,

.pointee = .{ .direct = &val_ptr.castTag(.opt_payload).?.data },

.ty = payload_ty,

},

else => {

const payload_val = switch (mod.intern_pool.indexToKey(val_ptr.ip_index)) {

.undef => try mod.intern(.{ .undef = payload_ty.toIntern() }),

.opt => |opt| switch (opt.val) {

.none => try mod.intern(.{ .undef = payload_ty.toIntern() }),

else => |payload| payload,

},

else => unreachable,

};

 

// An optional has been initialized to undefined at comptime and now we

// are for the first time setting the payload. We must change the

// representation of the optional from `undef` to `opt_payload`.

 

const payload = try sema.arena.create(Value.Payload.SubValue);

payload.* = .{

.base = .{ .tag = .opt_payload },

.data = Value.fromInterned(payload_val),

};

 

val_ptr.* = Value.initPayload(&payload.base);

 

return ComptimePtrMutationKit{

.root = parent.root,

.pointee = .{ .direct = &payload.data },

.ty = payload_ty,

};

},

.reinterpret => return ComptimePtrMutationKit{

switch (val_ptr.ip_index) {

.none => switch (val_ptr.tag()) {

.bytes => {

// An array is memory-optimized to store a slice of bytes, but we are about

// to modify an individual field and the representation has to change.

// If we wanted to avoid this, there would need to be special detection

// elsewhere to identify when writing a value to an array element that is stored

// using the `bytes` tag, and handle it without making a call to this function.

const arena = sema.arena;

const bytes = val_ptr.castTag(.bytes).?.data;

const dest_len = parent.ty.arrayLenIncludingSentinel(mod);

// bytes.len may be one greater than dest_len because of the case when

// assigning `[N:S]T` to `[N]T`. This is allowed; the sentinel is omitted.

assert(bytes.len >= dest_len);

const elems = try arena.alloc(Value, @intCast(dest_len));

for (elems, 0..) |*elem, i| {

elem.* = try mod.intValue(elem_ty, bytes[i]);

}

val_ptr.* = try Value.Tag.aggregate.create(arena, elems);

 

return beginComptimePtrMutationInner(

sema,

block,

src,

elem_ty,

&elems[@intCast(elem_ptr.index)],

ptr_elem_ty,

parent.root,

);

},

.repeated => {

// An array is memory-optimized to store only a single element value, and

// that value is understood to be the same for the entire length of the array.

// However, now we want to modify an individual field and so the

// representation has to change. If we wanted to avoid this, there would

// need to be special detection elsewhere to identify when writing a value to an

// array element that is stored using the `repeated` tag, and handle it

// without making a call to this function.

const arena = sema.arena;

 

const repeated_val = try val_ptr.castTag(.repeated).?.data.intern(parent.ty.childType(mod), mod);

const array_len_including_sentinel =

try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel(mod));

const elems = try arena.alloc(Value, array_len_including_sentinel);

@memset(elems, Value.fromInterned(repeated_val));

 

val_ptr.* = try Value.Tag.aggregate.create(arena, elems);

 

return beginComptimePtrMutationInner(

sema,

block,

src,

elem_ty,

&elems[@intCast(elem_ptr.index)],

ptr_elem_ty,

parent.root,

);

},

 

.aggregate => return beginComptimePtrMutationInner(

sema,

block,

src,

elem_ty,

&val_ptr.castTag(.aggregate).?.data[@intCast(elem_ptr.index)],

ptr_elem_ty,

parent.root,

),

 

else => unreachable,

},

else => switch (mod.intern_pool.indexToKey(val_ptr.toIntern())) {

.undef => {

// An array has been initialized to undefined at comptime and now we

// are for the first time setting an element. We must change the representation

// of the array from `undef` to `array`.

const arena = sema.arena;

 

const array_len_including_sentinel =

try sema.usizeCast(block, src, parent.ty.arrayLenIncludingSentinel(mod));

const elems = try arena.alloc(Value, array_len_including_sentinel);

@memset(elems, Value.fromInterned((try mod.intern(.{ .undef = elem_ty.toIntern() }))));

 

val_ptr.* = try Value.Tag.aggregate.create(arena, elems);

 

return beginComptimePtrMutationInner(

sema,

block,

src,

elem_ty,

&elems[@intCast(elem_ptr.index)],

ptr_elem_ty,

parent.root,

);

},

else => unreachable,

},

}

return ComptimePtrMutationKit{

return ComptimePtrMutationKit{

.direct => |val_ptr| switch (val_ptr.ip_index) {

.empty_struct => {

const duped = try sema.arena.create(Value);

duped.* = val_ptr.*;

return beginComptimePtrMutationInner(

sema,

duped,

ptr_elem_ty,

parent.root,

);

},

.none => switch (val_ptr.tag()) {

.aggregate => return beginComptimePtrMutationInner(

sema,

block,

src,

parent.ty.structFieldType(field_index, mod),

&val_ptr.castTag(.aggregate).?.data[field_index],

.repeated => {

const arena = sema.arena;

 

const elems = try arena.alloc(Value, parent.ty.structFieldCount(mod));

@memset(elems, val_ptr.castTag(.repeated).?.data);

val_ptr.* = try Value.Tag.aggregate.create(arena, elems);

 

return beginComptimePtrMutationInner(

sema,

parent.ty.structFieldType(field_index, mod),

&elems[field_index],

);

.@"union" => {

const payload = &val_ptr.castTag(.@"union").?.data;

if (layout == .auto or (payload.tag != null and hypothetical_tag.eql(payload.tag.?, tag_type, mod))) {

payload.tag = hypothetical_tag;

&payload.val,

 

payload.val = try payload.val.unintern(sema.arena, mod);

return ComptimePtrMutationKit{

.slice => switch (field_index) {

Value.slice_ptr_index => return beginComptimePtrMutationInner(

sema,

block,

src,

parent.ty.slicePtrFieldType(mod),

&val_ptr.castTag(.slice).?.data.ptr,

ptr_elem_ty,

parent.root,

),

 

Value.slice_len_index => return beginComptimePtrMutationInner(

sema,

block,

src,

Type.usize,

&val_ptr.castTag(.slice).?.data.len,

ptr_elem_ty,

parent.root,

),

 

else => unreachable,

},

else => unreachable,

},

else => switch (mod.intern_pool.indexToKey(val_ptr.toIntern())) {

.undef => {

// A struct or union has been initialized to undefined at comptime and now we

// are for the first time setting a field. We must change the representation

// of the struct/union from `undef` to `struct`/`union`.

const arena = sema.arena;

 

switch (parent.ty.zigTypeTag(mod)) {

.Struct => {

const fields = try arena.alloc(Value, parent.ty.structFieldCount(mod));

for (fields, 0..) |*field, i| field.* = Value.fromInterned((try mod.intern(.{

.undef = parent.ty.structFieldType(i, mod).toIntern(),

})));

 

val_ptr.* = try Value.Tag.aggregate.create(arena, fields);

 

return beginComptimePtrMutationInner(

sema,

block,

src,

parent.ty.structFieldType(field_index, mod),

&fields[field_index],

ptr_elem_ty,

parent.root,

);

},

.Union => {

const payload = try arena.create(Value.Payload.Union);

const tag_ty = parent.ty.unionTagTypeHypothetical(mod);

const payload_ty = parent.ty.structFieldType(field_index, mod);

payload.* = .{ .data = .{

.tag = try mod.enumValueFieldIndex(tag_ty, field_index),

.val = Value.fromInterned((try mod.intern(.{ .undef = payload_ty.toIntern() }))),

} };

 

val_ptr.* = Value.initPayload(&payload.base);

 

return beginComptimePtrMutationInner(

sema,

block,

src,

payload_ty,

&payload.data.val,

ptr_elem_ty,

parent.root,

);

},

.Pointer => {

assert(parent.ty.isSlice(mod));

const ptr_ty = parent.ty.slicePtrFieldType(mod);

val_ptr.* = try Value.Tag.slice.create(arena, .{

.ptr = Value.fromInterned((try mod.intern(.{ .undef = ptr_ty.toIntern() }))),

.len = Value.fromInterned((try mod.intern(.{ .undef = .usize_type }))),

});

 

switch (field_index) {

Value.slice_ptr_index => return beginComptimePtrMutationInner(

sema,

block,

src,

ptr_ty,

&val_ptr.castTag(.slice).?.data.ptr,

ptr_elem_ty,

parent.root,

),

Value.slice_len_index => return beginComptimePtrMutationInner(

sema,

block,

src,

Type.usize,

&val_ptr.castTag(.slice).?.data.len,

ptr_elem_ty,

parent.root,

),

 

else => unreachable,

}

},

else => unreachable,

}

},

else => unreachable,

},

return ComptimePtrMutationKit{

decl_val: *Value,

decl_val.* = try decl_val.unintern(sema.arena, mod);

const TypedValueAndOffset = struct {

tv: TypedValue,

byte_offset: usize,

};

 

pointee: ?TypedValue,

parent: ?TypedValueAndOffset,

/// Whether the `pointee` could be mutated by further

/// semantic analysis and a copy must be performed.

is_mutable: bool,

const decl_tv = try decl.typedValue();

 

const layout_defined = decl.ty.hasWellDefinedLayout(mod);

.parent = if (layout_defined) .{ .tv = decl_tv, .byte_offset = 0 } else null,

.pointee = decl_tv,

.is_mutable = false,

.ty_without_well_defined_layout = if (!layout_defined) decl.ty else null,

const alloc_tv: TypedValue = .{

.ty = alloc.ty,

.val = alloc.val,

};

const layout_defined = alloc.ty.hasWellDefinedLayout(mod);

.parent = if (layout_defined) .{ .tv = alloc_tv, .byte_offset = 0 } else null,

.pointee = alloc_tv,

.is_mutable = true,

.ty_without_well_defined_layout = if (!layout_defined) alloc.ty else null,

const decl_tv: TypedValue = .{ .ty = decl_ty, .val = Value.fromInterned(decl_val) };

.parent = if (layout_defined) .{ .tv = decl_tv, .byte_offset = 0 } else null,

.pointee = decl_tv,

.is_mutable = false,

const payload_ty = switch (ptr.addr) {

.eu_payload => container_ty.errorUnionPayload(mod),

.opt_payload => container_ty.optionalChild(mod),

else => unreachable,

};

if (deref.pointee) |*tv| {

(try sema.coerceInMemoryAllowed(block, container_ty, tv.ty, false, target, src, src)) == .ok or

(try sema.coerceInMemoryAllowed(block, tv.ty, container_ty, false, target, src, src)) == .ok;

const payload_val = switch (tv.val.ip_index) {

.none => tv.val.cast(Value.Payload.SubValue).?.data,

.null_value => return sema.fail(block, src, "attempt to use null value", .{}),

else => Value.fromInterned(switch (ip.indexToKey(tv.val.toIntern())) {

}),

tv.* = TypedValue{ .ty = payload_ty, .val = payload_val };

.comptime_field => |comptime_field| blk: {

const field_ty = Type.fromInterned(ip.typeOf(comptime_field));

break :blk ComptimePtrLoadKit{

.parent = null,

.pointee = .{ .ty = field_ty, .val = Value.fromInterned(comptime_field) },

.is_mutable = false,

.ty_without_well_defined_layout = field_ty,

};

const ty_matches = if (deref.pointee != null and deref.pointee.?.ty.isArrayOrVector(mod)) x: {

const deref_elem_ty = deref.pointee.?.ty.childType(mod);

break :x (try sema.coerceInMemoryAllowed(block, deref_elem_ty, elem_ty, false, target, src, src)) == .ok or

(try sema.coerceInMemoryAllowed(block, elem_ty, deref_elem_ty, false, target, src, src)) == .ok;

var array_tv = deref.pointee.?;

const check_len = array_tv.ty.arrayLenIncludingSentinel(mod);

deref.pointee = if (elem_ptr.index + len <= check_len) TypedValue{

.ty = try mod.arrayType(.{

.len = len,

.child = elem_ty.toIntern(),

}),

.val = try array_tv.val.sliceArray(sema, elem_idx, elem_idx + len),

if (array_tv.ty.sentinel(mod)) |sent| {

deref.pointee = TypedValue{

.ty = elem_ty,

.val = sent,

};

deref.pointee = TypedValue{

.ty = elem_ty,

.val = try array_tv.val.elemValue(mod, @intCast(elem_ptr.index)),

};

const tv = deref.pointee orelse {

deref.pointee = null;

break :blk deref;

};

(try sema.coerceInMemoryAllowed(block, container_ty, tv.ty, false, target, src, src)) == .ok or

(try sema.coerceInMemoryAllowed(block, tv.ty, container_ty, false, target, src, src)) == .ok;

if (container_ty.isSlice(mod)) {

deref.pointee = switch (field_index) {

Value.slice_ptr_index => TypedValue{

.ty = container_ty.slicePtrFieldType(mod),

.val = tv.val.slicePtr(mod),

},

Value.slice_len_index => TypedValue{

.ty = Type.usize,

.val = Value.fromInterned(ip.indexToKey(try tv.val.intern(tv.ty, mod)).slice.len),

},

else => unreachable,

};

} else {

const field_ty = container_ty.structFieldType(field_index, mod);

deref.pointee = TypedValue{

.ty = field_ty,

.val = try tv.val.fieldValue(mod, field_index),

};

}

if (deref.pointee) |tv| {

if (deref.parent == null and tv.ty.hasWellDefinedLayout(mod)) {

deref.parent = .{ .tv = tv, .byte_offset = 0 };

.ptr = try mod.intern(.{ .ptr = .{

.ty = dest_ty.slicePtrFieldType(mod).toIntern(),

.addr = switch (mod.intern_pool.indexToKey(val.toIntern())) {

.undef => .{ .int = try mod.intern(.{ .undef = .usize_type }) },

.ptr => |ptr| ptr.addr,

else => unreachable,

},

} }),

(try mod.getCoerced(Value.fromInterned((try val.intern(inst_ty, mod))), dest_ty)).toIntern(),

union_ty.fmt(sema.mod), val.fmtValue(tag_ty, sema.mod),

val.* = try elem_val.intern(dest_elem_ty, mod);

val.* = try elem_val.intern(dest_elem_ty, mod);

Value.fromInterned((try sema.refValue(val.toIntern()))),

const decl_tv = try mod.declPtr(decl_index).typedValue();

const owner_decl = mod.declPtr(switch (mod.intern_pool.indexToKey(decl_tv.val.toIntern())) {

.child = decl_tv.ty.toIntern(),

.is_const = if (decl_tv.val.getVariable(mod)) |variable| variable.is_const else true,

const tv = try decl.typedValue();

if (tv.ty.zigTypeTag(mod) != .Fn) return;

if (!try sema.fnHasRuntimeBits(tv.ty)) return;

const func_index = tv.val.toIntern();

if (!mod.intern_pool.isFuncBody(func_index)) return; // undef or extern function

try mod.ensureFuncBodyAnalysisQueued(func_index);

return mod.intRef(Type.usize, slice_val.sliceLen(sema.mod));

Value.zero_comptime_int.fmtValue(Type.comptime_int, mod),

start_value.fmtValue(Type.comptime_int, mod),

Value.one_comptime_int.fmtValue(Type.comptime_int, mod),

end_value.fmtValue(Type.comptime_int, mod),

.{end_value.fmtValue(Type.comptime_int, mod)},

end_val.fmtValue(Type.usize, mod),

len_val.fmtValue(Type.usize, mod),

const slice_len = slice_val.sliceLen(mod);

end_val.fmtValue(Type.usize, mod),

slice_val.sliceLen(mod),

start_val.fmtValue(Type.usize, mod),

end_val.fmtValue(Type.usize, mod),

expected_sentinel.fmtValue(elem_ty, mod),

actual_sentinel.fmtValue(elem_ty, mod),

return Air.internedToRef((try mod.getCoerced(

Value.fromInterned((try new_ptr_val.intern(new_ptr_ty, mod))),

return_ty,

)).toIntern());

break :blk try mod.intRef(Type.usize, slice_val.sliceLen(mod));

.val = .{ .payload = try val.intern(dest_payload_ty, mod) },

const ies_func_info = mod.typeToFunc(ies_func_owner_decl.ty).?;

const field_init = try default_val.intern(field_ty, mod);

if (Value.fromInterned(field_init).canMutateComptimeVarState(mod)) {

struct_type.field_inits.get(ip)[field_i] = field_init;

const msg = try sema.errMsg(&block_scope, field_src, "enum tag value {} already taken", .{enum_tag_val.fmtValue(int_tag_ty, mod)});

try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, .{

.ty = Type.noreturn,

.val = Value.@"unreachable",

}, name);

new_decl.ty = Type.type;

try mod.initNewAnonDecl(new_decl_index, src_decl.src_line, .{

.ty = Type.noreturn,

.val = Value.@"unreachable",

}, name);

new_decl.ty = Type.type;

field_val.* = try field_opv.intern(field_ty, mod);

if (deref.pointee) |tv| {

(try sema.coerceInMemoryAllowed(block, load_ty, tv.ty, false, target, src, src)) == .ok or

(try sema.coerceInMemoryAllowed(block, tv.ty, load_ty, false, target, src, src)) == .ok;

const uncoerced_val = if (deref.is_mutable) try tv.val.intern(tv.ty, mod) else tv.val.toIntern();

const coerced_val = try mod.getCoerced(Value.fromInterned(uncoerced_val), load_ty);

if (deref.pointee) |tv| if (load_sz <= try sema.typeAbiSize(tv.ty))

return DerefResult{ .val = (try sema.bitCastVal(block, src, tv.val, tv.ty, load_ty, 0)) orelse return .runtime_load };

if (deref.parent) |parent| if (load_sz + parent.byte_offset <= try sema.typeAbiSize(parent.tv.ty))

return DerefResult{ .val = (try sema.bitCastVal(block, src, parent.tv.val, parent.tv.ty, load_ty, parent.byte_offset)) orelse return .runtime_load };

return DerefResult{ .needed_well_defined = bad_ty };

return DerefResult{ .out_of_bounds = deref.parent.?.tv.ty };

scalar.* = try val.intern(scalar_ty, mod);

scalar.* = try val.intern(scalar_ty, mod);

of.* = try of_math_result.overflow_bit.intern(Type.u1, mod);

scalar.* = try of_math_result.wrapped_result.intern(scalar_ty, mod);

const elem_ty = float_ty.scalarType(mod);

const scalar_ty = int_ty.scalarType(mod);

scalar.* = try (try sema.intFromFloatScalar(block, src, elem_val, elem_ty, int_ty.scalarType(mod), mode)).intern(scalar_ty, mod);

return sema.intFromFloatScalar(block, src, val, float_ty, int_ty, mode);

float_ty: Type,

.{ val.fmtValue(float_ty, mod), int_ty.fmt(mod) },

val.fmtValue(float_ty, sema.mod), int_ty.fmt(sema.mod),

of.* = try of_math_result.overflow_bit.intern(Type.u1, mod);

scalar.* = try of_math_result.wrapped_result.intern(scalar_ty, mod);

scalar.* = try Value.makeBool(res_bool).intern(Type.bool, mod);

fn anyUndef(sema: *Sema, val: Value) !bool {

if (val.ip_index == .none) return switch (val.tag()) {

.eu_payload => try sema.anyUndef(val.castTag(.eu_payload).?.data),

.opt_payload => try sema.anyUndef(val.castTag(.opt_payload).?.data),

.repeated => try sema.anyUndef(val.castTag(.repeated).?.data),

.slice => {

const slice = val.castTag(.slice).?.data;

for (0..@intCast(slice.len.toUnsignedInt(mod))) |idx| {

if (try sema.anyUndef((try slice.ptr.maybeElemValueFull(sema, mod, idx)).?)) return true;

}

return false;

},

.bytes => false,

.aggregate => for (val.castTag(.aggregate).?.data) |elem| {

if (try sema.anyUndef(elem)) break true;

} else false,

.@"union" => {

const un = val.castTag(.@"union").?.data;

if (un.tag) |t| {

if (try sema.anyUndef(t)) return true;

}

return sema.anyUndef(un.val);

},

};

return switch (val.toIntern()) {

else => switch (mod.intern_pool.indexToKey(val.toIntern())) {

.undef => true,

.simple_value => |v| v == .undefined,

.slice => |slice| for (0..@intCast(Value.fromInterned(slice.len).toUnsignedInt(mod))) |idx| {

if (try sema.anyUndef((try val.maybeElemValueFull(sema, mod, idx)).?)) break true;

} else false,

.aggregate => |aggregate| for (0..aggregate.storage.values().len) |i| {

const elem = mod.intern_pool.indexToKey(val.toIntern()).aggregate.storage.values()[i];

if (try sema.anyUndef(Value.fromInterned(elem))) break true;

} else false,

else => false,

const ip = &zcu.intern_pool;

const slice_ty = Type.fromInterned(ip.typeOf(slice_val.toIntern()));

const array_ty = Type.fromInterned(ip.typeOf(array_val.toIntern()));

assert(Type.fromInterned(ip.typeOf(slice_val.toIntern())).isSlice(zcu));

return try sema.pointerDeref(block, src, casted_ptr, ptr_ty) orelse {

return sema.failWithNeededComptime(block, src, reason);

};

const std = @import("std");

const Type = @import("type.zig").Type;

const Value = @import("Value.zig");

const Module = @import("Module.zig");

const Allocator = std.mem.Allocator;

const TypedValue = @This();

const Target = std.Target;

 

ty: Type,

val: Value,

 

/// Memory management for TypedValue. The main purpose of this type

/// is to be small and have a deinit() function to free associated resources.

pub const Managed = struct {

/// If the tag value is less than Tag.no_payload_count, then no pointer

/// dereference is needed.

typed_value: TypedValue,

/// If this is `null` then there is no memory management needed.

arena: ?*std.heap.ArenaAllocator.State = null,

 

pub fn deinit(self: *Managed, allocator: Allocator) void {

if (self.arena) |a| a.promote(allocator).deinit();

self.* = undefined;

}

};

 

/// Assumes arena allocation. Does a recursive copy.

pub fn copy(self: TypedValue, arena: Allocator) error{OutOfMemory}!TypedValue {

return TypedValue{

.ty = self.ty,

.val = try self.val.copy(arena),

};

}

 

pub fn eql(a: TypedValue, b: TypedValue, mod: *Module) bool {

if (a.ty.toIntern() != b.ty.toIntern()) return false;

return a.val.eql(b.val, a.ty, mod);

}

 

pub fn hash(tv: TypedValue, hasher: *std.hash.Wyhash, mod: *Module) void {

return tv.val.hash(tv.ty, hasher, mod);

}

 

pub fn intFromEnum(tv: TypedValue, mod: *Module) Allocator.Error!Value {

return tv.val.intFromEnum(tv.ty, mod);

}

 

const max_aggregate_items = 100;

const max_string_len = 256;

 

const FormatContext = struct {

tv: TypedValue,

mod: *Module,

};

 

pub fn format(

ctx: FormatContext,

comptime fmt: []const u8,

options: std.fmt.FormatOptions,

writer: anytype,

) !void {

_ = options;

comptime std.debug.assert(fmt.len == 0);

return ctx.tv.print(writer, 3, ctx.mod) catch |err| switch (err) {

error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function

else => |e| return e,

};

}

 

/// Prints the Value according to the Type, not according to the Value Tag.

pub fn print(

tv: TypedValue,

writer: anytype,

level: u8,

mod: *Module,

) (@TypeOf(writer).Error || Allocator.Error)!void {

var val = tv.val;

var ty = tv.ty;

const ip = &mod.intern_pool;

while (true) switch (val.ip_index) {

.none => switch (val.tag()) {

.aggregate => return printAggregate(ty, val, writer, level, mod),

.@"union" => {

if (level == 0) {

return writer.writeAll(".{ ... }");

}

const payload = val.castTag(.@"union").?.data;

try writer.writeAll(".{ ");

 

if (payload.tag) |tag| {

try print(.{

.ty = Type.fromInterned(ip.loadUnionType(ty.toIntern()).enum_tag_ty),

.val = tag,

}, writer, level - 1, mod);

try writer.writeAll(" = ");

const field_ty = ty.unionFieldType(tag, mod).?;

try print(.{

.ty = field_ty,

.val = payload.val,

}, writer, level - 1, mod);

} else {

try writer.writeAll("(unknown tag) = ");

const backing_ty = try ty.unionBackingType(mod);

try print(.{

.ty = backing_ty,

.val = payload.val,

}, writer, level - 1, mod);

}

 

return writer.writeAll(" }");

},

.bytes => return writer.print("\"{}\"", .{std.zig.fmtEscapes(val.castTag(.bytes).?.data)}),

.repeated => {

if (level == 0) {

return writer.writeAll(".{ ... }");

}

var i: u32 = 0;

try writer.writeAll(".{ ");

const elem_tv = TypedValue{

.ty = ty.elemType2(mod),

.val = val.castTag(.repeated).?.data,

};

const len = ty.arrayLen(mod);

const max_len = @min(len, max_aggregate_items);

while (i < max_len) : (i += 1) {

if (i != 0) try writer.writeAll(", ");

try print(elem_tv, writer, level - 1, mod);

}

if (len > max_aggregate_items) {

try writer.writeAll(", ...");

}

return writer.writeAll(" }");

},

.slice => {

if (level == 0) {

return writer.writeAll(".{ ... }");

}

const payload = val.castTag(.slice).?.data;

const elem_ty = ty.elemType2(mod);

const len = payload.len.toUnsignedInt(mod);

 

if (elem_ty.eql(Type.u8, mod)) str: {

const max_len: usize = @min(len, max_string_len);

var buf: [max_string_len]u8 = undefined;

 

var i: u32 = 0;

while (i < max_len) : (i += 1) {

const maybe_elem_val = payload.ptr.maybeElemValue(mod, i) catch |err| switch (err) {

error.OutOfMemory => @panic("OOM"), // TODO: eliminate this panic

};

const elem_val = maybe_elem_val orelse return writer.writeAll(".{ (reinterpreted data) }");

if (elem_val.isUndef(mod)) break :str;

buf[i] = std.math.cast(u8, elem_val.toUnsignedInt(mod)) orelse break :str;

}

 

// TODO would be nice if this had a bit of unicode awareness.

const truncated = if (len > max_string_len) " (truncated)" else "";

return writer.print("\"{}{s}\"", .{ std.zig.fmtEscapes(buf[0..max_len]), truncated });

}

 

try writer.writeAll(".{ ");

 

const max_len = @min(len, max_aggregate_items);

var i: u32 = 0;

while (i < max_len) : (i += 1) {

if (i != 0) try writer.writeAll(", ");

const maybe_elem_val = payload.ptr.maybeElemValue(mod, i) catch |err| switch (err) {

error.OutOfMemory => @panic("OOM"), // TODO: eliminate this panic

};

const elem_val = maybe_elem_val orelse return writer.writeAll("(reinterpreted data) }");

try print(.{

.ty = elem_ty,

.val = elem_val,

}, writer, level - 1, mod);

}

if (len > max_aggregate_items) {

try writer.writeAll(", ...");

}

return writer.writeAll(" }");

},

.eu_payload => {

val = val.castTag(.eu_payload).?.data;

ty = ty.errorUnionPayload(mod);

},

.opt_payload => {

val = val.castTag(.opt_payload).?.data;

ty = ty.optionalChild(mod);

},

},

else => switch (ip.indexToKey(val.toIntern())) {

.int_type,

.ptr_type,

.array_type,

.vector_type,

.opt_type,

.anyframe_type,

.error_union_type,

.simple_type,

.struct_type,

.anon_struct_type,

.union_type,

.opaque_type,

.enum_type,

.func_type,

.error_set_type,

.inferred_error_set_type,

=> return Type.print(val.toType(), writer, mod),

.undef => return writer.writeAll("undefined"),

.simple_value => |simple_value| switch (simple_value) {

.void => return writer.writeAll("{}"),

.empty_struct => return printAggregate(ty, val, writer, level, mod),

.generic_poison => return writer.writeAll("(generic poison)"),

else => return writer.writeAll(@tagName(simple_value)),

},

.variable => return writer.writeAll("(variable)"),

.extern_func => |extern_func| return writer.print("(extern function '{}')", .{

mod.declPtr(extern_func.decl).name.fmt(ip),

}),

.func => |func| return writer.print("(function '{}')", .{

mod.declPtr(func.owner_decl).name.fmt(ip),

}),

.int => |int| switch (int.storage) {

inline .u64, .i64, .big_int => |x| return writer.print("{}", .{x}),

.lazy_align => |lazy_ty| return writer.print("{d}", .{

Type.fromInterned(lazy_ty).abiAlignment(mod),

}),

.lazy_size => |lazy_ty| return writer.print("{d}", .{

Type.fromInterned(lazy_ty).abiSize(mod),

}),

},

.err => |err| return writer.print("error.{}", .{

err.name.fmt(ip),

}),

.error_union => |error_union| switch (error_union.val) {

.err_name => |err_name| return writer.print("error.{}", .{

err_name.fmt(ip),

}),

.payload => |payload| {

val = Value.fromInterned(payload);

ty = ty.errorUnionPayload(mod);

},

},

.enum_literal => |enum_literal| return writer.print(".{}", .{

enum_literal.fmt(ip),

}),

.enum_tag => |enum_tag| {

if (level == 0) {

return writer.writeAll("(enum)");

}

const enum_type = ip.loadEnumType(ty.toIntern());

if (enum_type.tagValueIndex(ip, val.toIntern())) |tag_index| {

try writer.print(".{i}", .{enum_type.names.get(ip)[tag_index].fmt(ip)});

return;

}

try writer.writeAll("@enumFromInt(");

try print(.{

.ty = Type.fromInterned(ip.typeOf(enum_tag.int)),

.val = Value.fromInterned(enum_tag.int),

}, writer, level - 1, mod);

try writer.writeAll(")");

return;

},

.empty_enum_value => return writer.writeAll("(empty enum value)"),

.float => |float| switch (float.storage) {

inline else => |x| return writer.print("{d}", .{@as(f64, @floatCast(x))}),

},

.slice => |slice| {

const ptr_ty = switch (ip.indexToKey(slice.ptr)) {

.ptr => |ptr| ty: {

if (ptr.addr == .int) return print(.{

.ty = Type.fromInterned(ptr.ty),

.val = Value.fromInterned(slice.ptr),

}, writer, level - 1, mod);

break :ty ip.indexToKey(ptr.ty).ptr_type;

},

.undef => |ptr_ty| ip.indexToKey(ptr_ty).ptr_type,

else => unreachable,

};

if (level == 0) {

return writer.writeAll(".{ ... }");

}

const elem_ty = Type.fromInterned(ptr_ty.child);

const len = Value.fromInterned(slice.len).toUnsignedInt(mod);

if (elem_ty.eql(Type.u8, mod)) str: {

const max_len = @min(len, max_string_len);

var buf: [max_string_len]u8 = undefined;

for (buf[0..max_len], 0..) |*c, i| {

const maybe_elem = try val.maybeElemValue(mod, i);

const elem = maybe_elem orelse return writer.writeAll(".{ (reinterpreted data) }");

if (elem.isUndef(mod)) break :str;

c.* = @as(u8, @intCast(elem.toUnsignedInt(mod)));

}

const truncated = if (len > max_string_len) " (truncated)" else "";

return writer.print("\"{}{s}\"", .{ std.zig.fmtEscapes(buf[0..max_len]), truncated });

}

try writer.writeAll(".{ ");

const max_len = @min(len, max_aggregate_items);

for (0..max_len) |i| {

if (i != 0) try writer.writeAll(", ");

const maybe_elem = try val.maybeElemValue(mod, i);

const elem = maybe_elem orelse return writer.writeAll("(reinterpreted data) }");

try print(.{

.ty = elem_ty,

.val = elem,

}, writer, level - 1, mod);

}

if (len > max_aggregate_items) {

try writer.writeAll(", ...");

}

return writer.writeAll(" }");

},

.ptr => |ptr| {

switch (ptr.addr) {

.decl => |decl_index| {

const decl = mod.declPtr(decl_index);

if (level == 0) return writer.print("(decl '{}')", .{decl.name.fmt(ip)});

return print(.{

.ty = decl.ty,

.val = decl.val,

}, writer, level - 1, mod);

},

.anon_decl => |anon_decl| {

const decl_val = anon_decl.val;

if (level == 0) return writer.print("(anon decl '{d}')", .{

@intFromEnum(decl_val),

});

return print(.{

.ty = Type.fromInterned(ip.typeOf(decl_val)),

.val = Value.fromInterned(decl_val),

}, writer, level - 1, mod);

},

.comptime_alloc => {

// TODO: we need a Sema to print this!

return writer.writeAll("(comptime alloc)");

},

.comptime_field => |field_val_ip| {

return print(.{

.ty = Type.fromInterned(ip.typeOf(field_val_ip)),

.val = Value.fromInterned(field_val_ip),

}, writer, level - 1, mod);

},

.int => |int_ip| {

try writer.writeAll("@ptrFromInt(");

try print(.{

.ty = Type.usize,

.val = Value.fromInterned(int_ip),

}, writer, level - 1, mod);

try writer.writeByte(')');

},

.eu_payload => |eu_ip| {

try writer.writeAll("(payload of ");

try print(.{

.ty = Type.fromInterned(ip.typeOf(eu_ip)),

.val = Value.fromInterned(eu_ip),

}, writer, level - 1, mod);

try writer.writeAll(")");

},

.opt_payload => |opt_ip| {

try print(.{

.ty = Type.fromInterned(ip.typeOf(opt_ip)),

.val = Value.fromInterned(opt_ip),

}, writer, level - 1, mod);

try writer.writeAll(".?");

},

.elem => |elem| {

if (level == 0) {

try writer.writeAll("(...)");

} else {

try print(.{

.ty = Type.fromInterned(ip.typeOf(elem.base)),

.val = Value.fromInterned(elem.base),

}, writer, level - 1, mod);

}

try writer.print("[{}]", .{elem.index});

},

.field => |field| {

const ptr_container_ty = Type.fromInterned(ip.typeOf(field.base));

if (level == 0) {

try writer.writeAll("(...)");

} else {

try print(.{

.ty = ptr_container_ty,

.val = Value.fromInterned(field.base),

}, writer, level - 1, mod);

}

 

const container_ty = ptr_container_ty.childType(mod);

switch (container_ty.zigTypeTag(mod)) {

.Struct => {

if (container_ty.structFieldName(@intCast(field.index), mod).unwrap()) |field_name| {

try writer.print(".{i}", .{field_name.fmt(ip)});

} else {

try writer.print("[{d}]", .{field.index});

}

},

.Union => {

const field_name = mod.typeToUnion(container_ty).?.loadTagType(ip).names.get(ip)[@intCast(field.index)];

try writer.print(".{i}", .{field_name.fmt(ip)});

},

.Pointer => {

std.debug.assert(container_ty.isSlice(mod));

try writer.writeAll(switch (field.index) {

Value.slice_ptr_index => ".ptr",

Value.slice_len_index => ".len",

else => unreachable,

});

},

else => unreachable,

}

},

}

return;

},

.opt => |opt| switch (opt.val) {

.none => return writer.writeAll("null"),

else => |payload| {

val = Value.fromInterned(payload);

ty = ty.optionalChild(mod);

},

},

.aggregate => |aggregate| switch (aggregate.storage) {

.bytes => |bytes| {

// Strip the 0 sentinel off of strings before printing

const zero_sent = blk: {

const sent = ty.sentinel(mod) orelse break :blk false;

break :blk sent.eql(Value.zero_u8, Type.u8, mod);

};

const str = if (zero_sent) bytes[0 .. bytes.len - 1] else bytes;

return writer.print("\"{}\"", .{std.zig.fmtEscapes(str)});

},

.elems, .repeated_elem => return printAggregate(ty, val, writer, level, mod),

},

.un => |un| {

try writer.writeAll(".{ ");

if (level > 0) {

if (un.tag != .none) {

try print(.{

.ty = ty.unionTagTypeHypothetical(mod),

.val = Value.fromInterned(un.tag),

}, writer, level - 1, mod);

try writer.writeAll(" = ");

const field_ty = ty.unionFieldType(Value.fromInterned(un.tag), mod).?;

try print(.{

.ty = field_ty,

.val = Value.fromInterned(un.val),

}, writer, level - 1, mod);

} else {

try writer.writeAll("(unknown tag) = ");

const backing_ty = try ty.unionBackingType(mod);

try print(.{

.ty = backing_ty,

.val = Value.fromInterned(un.val),

}, writer, level - 1, mod);

}

} else try writer.writeAll("...");

return writer.writeAll(" }");

},

.memoized_call => unreachable,

},

};

}

 

fn printAggregate(

ty: Type,

val: Value,

writer: anytype,

level: u8,

mod: *Module,

) (@TypeOf(writer).Error || Allocator.Error)!void {

if (level == 0) {

return writer.writeAll(".{ ... }");

}

const ip = &mod.intern_pool;

if (ty.zigTypeTag(mod) == .Struct) {

try writer.writeAll(".{");

const max_len = @min(ty.structFieldCount(mod), max_aggregate_items);

 

for (0..max_len) |i| {

if (i != 0) try writer.writeAll(", ");

 

const field_name = ty.structFieldName(@intCast(i), mod);

 

if (field_name.unwrap()) |name| try writer.print(".{} = ", .{name.fmt(ip)});

try print(.{

.ty = ty.structFieldType(i, mod),

.val = try val.fieldValue(mod, i),

}, writer, level - 1, mod);

}

if (ty.structFieldCount(mod) > max_aggregate_items) {

try writer.writeAll(", ...");

}

return writer.writeAll("}");

} else {

const elem_ty = ty.elemType2(mod);

const len = ty.arrayLen(mod);

 

if (elem_ty.eql(Type.u8, mod)) str: {

const max_len: usize = @min(len, max_string_len);

var buf: [max_string_len]u8 = undefined;

 

var i: u32 = 0;

while (i < max_len) : (i += 1) {

const elem = try val.fieldValue(mod, i);

if (elem.isUndef(mod)) break :str;

buf[i] = std.math.cast(u8, elem.toUnsignedInt(mod)) orelse break :str;

}

 

const truncated = if (len > max_string_len) " (truncated)" else "";

return writer.print("\"{}{s}\"", .{ std.zig.fmtEscapes(buf[0..max_len]), truncated });

}

 

try writer.writeAll(".{ ");

 

const max_len = @min(len, max_aggregate_items);

var i: u32 = 0;

while (i < max_len) : (i += 1) {

if (i != 0) try writer.writeAll(", ");

try print(.{

.ty = elem_ty,

.val = try val.fieldValue(mod, i),

}, writer, level - 1, mod);

}

if (len > max_aggregate_items) {

try writer.writeAll(", ...");

}

return writer.writeAll(" }");

}

}

const TypedValue = @import("TypedValue.zig");

/// We are migrating towards using this for every Value object. However, many

/// values are still represented the legacy way. This is indicated by using

/// InternPool.Index.none.

/// This is the raw data, with no bookkeeping, no memory awareness,

/// no de-duplication, and no type system awareness.

/// This union takes advantage of the fact that the first page of memory

/// is unmapped, giving us 4096 possible enum tags that have no payload.

legacy: extern union {

ptr_otherwise: *Payload,

},

 

// Keep in sync with tools/stage2_pretty_printers_common.py

pub const Tag = enum(usize) {

// The first section of this enum are tags that require no payload.

// After this, the tag requires a payload.

 

/// When the type is error union:

/// * If the tag is `.@"error"`, the error union is an error.

/// * If the tag is `.eu_payload`, the error union is a payload.

/// * A nested error such as `anyerror!(anyerror!T)` in which the the outer error union

/// is non-error, but the inner error union is an error, is represented as

/// a tag of `.eu_payload`, with a sub-tag of `.@"error"`.

eu_payload,

/// When the type is optional:

/// * If the tag is `.null_value`, the optional is null.

/// * If the tag is `.opt_payload`, the optional is a payload.

/// * A nested optional such as `??T` in which the the outer optional

/// is non-null, but the inner optional is null, is represented as

/// a tag of `.opt_payload`, with a sub-tag of `.null_value`.

opt_payload,

/// Pointer and length as sub `Value` objects.

slice,

/// A slice of u8 whose memory is managed externally.

bytes,

/// This value is repeated some number of times. The amount of times to repeat

/// is stored externally.

repeated,

/// An instance of a struct, array, or vector.

/// Each element/field stored as a `Value`.

/// In the case of sentinel-terminated arrays, the sentinel value *is* stored,

/// so the slice length will be one more than the type's array length.

aggregate,

/// An instance of a union.

@"union",

 

pub fn Type(comptime t: Tag) type {

return switch (t) {

.eu_payload,

.opt_payload,

.repeated,

=> Payload.SubValue,

.slice => Payload.Slice,

.bytes => Payload.Bytes,

.aggregate => Payload.Aggregate,

.@"union" => Payload.Union,

};

}

 

pub fn create(comptime t: Tag, ally: Allocator, data: Data(t)) error{OutOfMemory}!Value {

const ptr = try ally.create(t.Type());

ptr.* = .{

.base = .{ .tag = t },

.data = data,

};

return Value{

.ip_index = .none,

.legacy = .{ .ptr_otherwise = &ptr.base },

};

}

 

pub fn Data(comptime t: Tag) type {

return std.meta.fieldInfo(t.Type(), .data).type;

}

};

 

pub fn initPayload(payload: *Payload) Value {

return Value{

.ip_index = .none,

.legacy = .{ .ptr_otherwise = payload },

};

}

 

pub fn tag(self: Value) Tag {

assert(self.ip_index == .none);

return self.legacy.ptr_otherwise.tag;

}

 

/// Prefer `castTag` to this.

pub fn cast(self: Value, comptime T: type) ?*T {

if (self.ip_index != .none) {

return null;

}

if (@hasField(T, "base_tag")) {

return self.castTag(T.base_tag);

}

inline for (@typeInfo(Tag).Enum.fields) |field| {

const t = @as(Tag, @enumFromInt(field.value));

if (self.legacy.ptr_otherwise.tag == t) {

if (T == t.Type()) {

return @fieldParentPtr(T, "base", self.legacy.ptr_otherwise);

}

return null;

}

}

unreachable;

}

 

pub fn castTag(self: Value, comptime t: Tag) ?*t.Type() {

if (self.ip_index != .none) return null;

 

if (self.legacy.ptr_otherwise.tag == t)

return @fieldParentPtr(t.Type(), "base", self.legacy.ptr_otherwise);

 

return null;

}

 

if (start_val.ip_index != .none) {

try out_stream.print("(interned: {})", .{start_val.toIntern()});

return;

}

var val = start_val;

while (true) switch (val.tag()) {

.aggregate => {

return out_stream.writeAll("(aggregate)");

},

.@"union" => {

return out_stream.writeAll("(union value)");

},

.bytes => return out_stream.print("\"{}\"", .{std.zig.fmtEscapes(val.castTag(.bytes).?.data)}),

.repeated => {

try out_stream.writeAll("(repeated) ");

val = val.castTag(.repeated).?.data;

},

.eu_payload => {

try out_stream.writeAll("(eu_payload) ");

val = val.castTag(.repeated).?.data;

},

.opt_payload => {

try out_stream.writeAll("(opt_payload) ");

val = val.castTag(.repeated).?.data;

},

.slice => return out_stream.writeAll("(slice)"),

};

pub fn fmtValue(val: Value, ty: Type, mod: *Module) std.fmt.Formatter(TypedValue.format) {

.tv = .{ .ty = ty, .val = val },

pub fn intern2(val: Value, ty: Type, mod: *Module) Allocator.Error!InternPool.Index {

if (val.ip_index != .none) return val.ip_index;

return intern(val, ty, mod);

}

 

pub fn intern(val: Value, ty: Type, mod: *Module) Allocator.Error!InternPool.Index {

if (val.ip_index != .none) return (try mod.getCoerced(val, ty)).toIntern();

const ip = &mod.intern_pool;

switch (val.tag()) {

.eu_payload => {

const pl = val.castTag(.eu_payload).?.data;

return mod.intern(.{ .error_union = .{

.ty = ty.toIntern(),

.val = .{ .payload = try pl.intern(ty.errorUnionPayload(mod), mod) },

} });

},

.opt_payload => {

const pl = val.castTag(.opt_payload).?.data;

return mod.intern(.{ .opt = .{

.ty = ty.toIntern(),

.val = try pl.intern(ty.optionalChild(mod), mod),

} });

},

.slice => {

const pl = val.castTag(.slice).?.data;

return mod.intern(.{ .slice = .{

.ty = ty.toIntern(),

.len = try pl.len.intern(Type.usize, mod),

.ptr = try pl.ptr.intern(ty.slicePtrFieldType(mod), mod),

} });

},

.bytes => {

const pl = val.castTag(.bytes).?.data;

return mod.intern(.{ .aggregate = .{

.ty = ty.toIntern(),

.storage = .{ .bytes = pl },

} });

},

.repeated => {

const pl = val.castTag(.repeated).?.data;

return mod.intern(.{ .aggregate = .{

.ty = ty.toIntern(),

.storage = .{ .repeated_elem = try pl.intern(ty.childType(mod), mod) },

} });

},

.aggregate => {

const len = @as(usize, @intCast(ty.arrayLen(mod)));

const old_elems = val.castTag(.aggregate).?.data[0..len];

const new_elems = try mod.gpa.alloc(InternPool.Index, old_elems.len);

defer mod.gpa.free(new_elems);

const ty_key = ip.indexToKey(ty.toIntern());

for (new_elems, old_elems, 0..) |*new_elem, old_elem, field_i|

new_elem.* = try old_elem.intern(switch (ty_key) {

.struct_type => ty.structFieldType(field_i, mod),

.anon_struct_type => |info| Type.fromInterned(info.types.get(ip)[field_i]),

inline .array_type, .vector_type => |info| Type.fromInterned(info.child),

else => unreachable,

}, mod);

return mod.intern(.{ .aggregate = .{

.ty = ty.toIntern(),

.storage = .{ .elems = new_elems },

} });

},

.@"union" => {

const pl = val.castTag(.@"union").?.data;

if (pl.tag) |pl_tag| {

return mod.intern(.{ .un = .{

.ty = ty.toIntern(),

.tag = try pl_tag.intern(ty.unionTagTypeHypothetical(mod), mod),

.val = try pl.val.intern(ty.unionFieldType(pl_tag, mod).?, mod),

} });

} else {

return mod.intern(.{ .un = .{

.ty = ty.toIntern(),

.tag = .none,

.val = try pl.val.intern(try ty.unionBackingType(mod), mod),

} });

}

},

}

}

 

pub fn unintern(val: Value, arena: Allocator, mod: *Module) Allocator.Error!Value {

return if (val.ip_index == .none) val else switch (mod.intern_pool.indexToKey(val.toIntern())) {

.int_type,

.ptr_type,

.array_type,

.vector_type,

.opt_type,

.anyframe_type,

.error_union_type,

.simple_type,

.struct_type,

.anon_struct_type,

.union_type,

.opaque_type,

.enum_type,

.func_type,

.error_set_type,

.inferred_error_set_type,

 

.undef,

.simple_value,

.variable,

.extern_func,

.func,

.int,

.err,

.enum_literal,

.enum_tag,

.empty_enum_value,

.float,

.ptr,

=> val,

 

.error_union => |error_union| switch (error_union.val) {

.err_name => val,

.payload => |payload| Tag.eu_payload.create(arena, Value.fromInterned(payload)),

},

 

.slice => |slice| Tag.slice.create(arena, .{

.ptr = Value.fromInterned(slice.ptr),

.len = Value.fromInterned(slice.len),

}),

 

.opt => |opt| switch (opt.val) {

.none => val,

else => |payload| Tag.opt_payload.create(arena, Value.fromInterned(payload)),

},

 

.aggregate => |aggregate| switch (aggregate.storage) {

.bytes => |bytes| Tag.bytes.create(arena, try arena.dupe(u8, bytes)),

.elems => |old_elems| {

const new_elems = try arena.alloc(Value, old_elems.len);

for (new_elems, old_elems) |*new_elem, old_elem| new_elem.* = Value.fromInterned(old_elem);

return Tag.aggregate.create(arena, new_elems);

},

.repeated_elem => |elem| Tag.repeated.create(arena, Value.fromInterned(elem)),

},

 

.un => |un| Tag.@"union".create(arena, .{

// toValue asserts that the value cannot be .none which is valid on unions.

.tag = if (un.tag == .none) null else Value.fromInterned(un.tag),

.val = Value.fromInterned(un.val),

}),

 

.memoized_call => unreachable,

};

}

 

return .{

.ip_index = i,

.legacy = undefined,

};

return if (val.ip_index != .none) switch (mod.intern_pool.indexToKey(val.toIntern())) {

} else null;

return if (val.ip_index != .none) switch (mod.intern_pool.indexToKey(val.toIntern())) {

} else null;

return if (val.ip_index != .none) switch (mod.intern_pool.indexToKey(val.toIntern())) {

} else null;

const elem_ty = Type.fromInterned(mod.intern_pool.typeOf(elem.base)).elemType2(mod);

const struct_ty = Type.fromInterned(mod.intern_pool.typeOf(field.base)).childType(mod);

fn isDeclRef(val: Value, mod: *Module) bool {

.decl, .comptime_alloc, .comptime_field, .anon_decl => return true,

.int => return false,

else => return false,

const field_val = switch (val.ip_index) {

.none => switch (val.tag()) {

.bytes => {

buffer[off] = val.castTag(.bytes).?.data[i];

continue;

},

.aggregate => val.castTag(.aggregate).?.data[i],

.repeated => val.castTag(.repeated).?.data,

else => unreachable,

else => Value.fromInterned(switch (ip.indexToKey(val.toIntern()).aggregate.storage) {

.bytes => |bytes| {

buffer[off] = bytes[i];

continue;

},

.elems => |elems| elems[i],

.repeated_elem => |elem| elem,

}),

};

if (val.isDeclRef(mod)) return error.ReinterpretDeclRef;

const field_val = switch (val.ip_index) {

.none => switch (val.tag()) {

.bytes => unreachable,

.aggregate => val.castTag(.aggregate).?.data[i],

.repeated => val.castTag(.repeated).?.data,

else => unreachable,

},

else => Value.fromInterned(switch (ip.indexToKey(val.toIntern()).aggregate.storage) {

.bytes => unreachable,

.elems => |elems| elems[i],

.repeated_elem => |elem| elem,

}),

};

if (val.isDeclRef(mod)) return error.ReinterpretDeclRef;

elem.* = try (try readFromMemory(elem_ty, mod, buffer[offset..], arena)).intern(elem_ty, mod);

field_val.* = try (try readFromMemory(field_ty, mod, buffer[off..(off + sz)], arena)).intern(field_ty, mod);

const val = try (try readFromMemory(array_ty, mod, buffer, arena)).intern(array_ty, mod);

.Int, .Enum => |ty_tag| {

if (bits <= 64) {

const int_ty = switch (ty_tag) {

.Int => ty,

.Enum => ty.intTagType(mod),

else => unreachable,

};

return mod.getCoerced(switch (int_info.signedness) {

.signed => return mod.intValue(

int_ty,

std.mem.readVarPackedInt(i64, buffer, bit_offset, bits, endian, .signed),

),

.unsigned => return mod.intValue(

int_ty,

std.mem.readVarPackedInt(u64, buffer, bit_offset, bits, endian, .unsigned),

),

}, ty);

}

elems[tgt_elem_i] = try (try readFromPackedMemory(elem_ty, mod, buffer, bit_offset + bits, arena)).intern(elem_ty, mod);

field_val.* = try (try readFromPackedMemory(field_ty, mod, buffer, bit_offset + bits, arena)).intern(field_ty, mod);

pub fn sliceLen(val: Value, mod: *Module) u64 {

const ip = &mod.intern_pool;

return switch (ip.indexToKey(val.toIntern())) {

.ptr => |ptr| switch (ip.indexToKey(switch (ptr.addr) {

.decl => |decl| mod.declPtr(decl).ty.toIntern(),

.comptime_alloc => @panic("TODO"),

.anon_decl => |anon_decl| ip.typeOf(anon_decl.val),

.comptime_field => |comptime_field| ip.typeOf(comptime_field),

else => unreachable,

})) {

.array_type => |array_type| array_type.len,

else => 1,

.slice => |slice| Value.fromInterned(slice.len).toUnsignedInt(mod),

};

}

 

/// Asserts the value is a single-item pointer to an array, or an array,

/// or an unknown-length pointer, and returns the element value at the index.

pub fn elemValue(val: Value, mod: *Module, index: usize) Allocator.Error!Value {

return (try val.maybeElemValue(mod, index)).?;

}

 

/// Like `elemValue`, but returns `null` instead of asserting on failure.

pub fn maybeElemValue(val: Value, mod: *Module, index: usize) Allocator.Error!?Value {

return val.maybeElemValueFull(null, mod, index);

}

 

pub fn maybeElemValueFull(val: Value, sema: ?*Sema, mod: *Module, index: usize) Allocator.Error!?Value {

return switch (val.ip_index) {

.none => switch (val.tag()) {

.bytes => try mod.intValue(Type.u8, val.castTag(.bytes).?.data[index]),

.repeated => val.castTag(.repeated).?.data,

.aggregate => val.castTag(.aggregate).?.data[index],

.slice => val.castTag(.slice).?.data.ptr.maybeElemValueFull(sema, mod, index),

else => null,

},

else => switch (mod.intern_pool.indexToKey(val.toIntern())) {

.undef => |ty| Value.fromInterned((try mod.intern(.{

.undef = Type.fromInterned(ty).elemType2(mod).toIntern(),

}))),

.slice => |slice| return Value.fromInterned(slice.ptr).maybeElemValueFull(sema, mod, index),

.ptr => |ptr| switch (ptr.addr) {

.decl => |decl| mod.declPtr(decl).val.maybeElemValueFull(sema, mod, index),

.anon_decl => |anon_decl| Value.fromInterned(anon_decl.val).maybeElemValueFull(sema, mod, index),

.comptime_alloc => |idx| if (sema) |s| s.getComptimeAlloc(idx).val.maybeElemValueFull(sema, mod, index) else null,

.int, .eu_payload => null,

.opt_payload => |base| Value.fromInterned(base).maybeElemValueFull(sema, mod, index),

.comptime_field => |field_val| Value.fromInterned(field_val).maybeElemValueFull(sema, mod, index),

.elem => |elem| Value.fromInterned(elem.base).maybeElemValueFull(sema, mod, index + @as(usize, @intCast(elem.index))),

.field => |field| if (Value.fromInterned(field.base).pointerDecl(mod)) |decl_index| {

const base_decl = mod.declPtr(decl_index);

const field_val = try base_decl.val.fieldValue(mod, @as(usize, @intCast(field.index)));

return field_val.maybeElemValueFull(sema, mod, index);

} else null,

},

.opt => |opt| Value.fromInterned(opt.val).maybeElemValueFull(sema, mod, index),

.aggregate => |aggregate| {

const len = mod.intern_pool.aggregateTypeLen(aggregate.ty);

if (index < len) return Value.fromInterned(switch (aggregate.storage) {

.bytes => |bytes| try mod.intern(.{ .int = .{

.ty = .u8_type,

.storage = .{ .u64 = bytes[index] },

} }),

.elems => |elems| elems[index],

.repeated_elem => |elem| elem,

});

assert(index == len);

return Value.fromInterned(mod.intern_pool.indexToKey(aggregate.ty).array_type.sentinel);

},

else => null,

},

};

return switch (val.ip_index) {

.none => switch (val.tag()) {

.slice => val.castTag(.slice).?.data.ptr.sliceArray(sema, start, end),

.bytes => Tag.bytes.create(sema.arena, val.castTag(.bytes).?.data[start..end]),

.repeated => val,

.aggregate => Tag.aggregate.create(sema.arena, val.castTag(.aggregate).?.data[start..end]),

else => switch (mod.intern_pool.indexToKey(val.toIntern())) {

.ptr => |ptr| switch (ptr.addr) {

.decl => |decl| try mod.declPtr(decl).val.sliceArray(sema, start, end),

.comptime_alloc => |idx| sema.getComptimeAlloc(idx).val.sliceArray(sema, start, end),

.comptime_field => |comptime_field| Value.fromInterned(comptime_field)

.sliceArray(sema, start, end),

.elem => |elem| Value.fromInterned(elem.base)

.sliceArray(sema, start + @as(usize, @intCast(elem.index)), end + @as(usize, @intCast(elem.index))),

else => unreachable,

},

.aggregate => |aggregate| Value.fromInterned((try mod.intern(.{ .aggregate = .{

.ty = switch (mod.intern_pool.indexToKey(mod.intern_pool.typeOf(val.toIntern()))) {

.array_type => |array_type| try mod.arrayType(.{

.len = @as(u32, @intCast(end - start)),

.child = array_type.child,

.sentinel = if (end == array_type.len) array_type.sentinel else .none,

}),

.vector_type => |vector_type| try mod.vectorType(.{

.len = @as(u32, @intCast(end - start)),

.child = vector_type.child,

}),

else => unreachable,

}.toIntern(),

.storage = switch (aggregate.storage) {

.bytes => .{ .bytes = try sema.arena.dupe(u8, mod.intern_pool.indexToKey(val.toIntern()).aggregate.storage.bytes[start..end]) },

.elems => .{ .elems = try sema.arena.dupe(InternPool.Index, mod.intern_pool.indexToKey(val.toIntern()).aggregate.storage.elems[start..end]) },

.repeated_elem => |elem| .{ .repeated_elem = elem },

},

} }))),

else => unreachable,

},

};

return switch (val.ip_index) {

.none => switch (val.tag()) {

.aggregate => {

const field_values = val.castTag(.aggregate).?.data;

return field_values[index];

},

.@"union" => {

const payload = val.castTag(.@"union").?.data;

// TODO assert the tag is correct

return payload.val;

},

else => unreachable,

},

else => switch (mod.intern_pool.indexToKey(val.toIntern())) {

.undef => |ty| Value.fromInterned((try mod.intern(.{

.undef = Type.fromInterned(ty).structFieldType(index, mod).toIntern(),

}))),

.aggregate => |aggregate| Value.fromInterned(switch (aggregate.storage) {

.bytes => |bytes| try mod.intern(.{ .int = .{

.ty = .u8_type,

.storage = .{ .u64 = bytes[index] },

} }),

.elems => |elems| elems[index],

.repeated_elem => |elem| elem,

}),

// TODO assert the tag is correct

.un => |un| Value.fromInterned(un.val),

else => unreachable,

},

if (val.ip_index == .none) return val.castTag(.@"union").?.data.tag;

if (val.ip_index == .none) return val.castTag(.@"union").?.data.val;

.elem => |elem| if (Type.fromInterned(mod.intern_pool.typeOf(elem.base)).elemType2(mod).eql(elem_ty, mod))

return val.ip_index != .none and mod.intern_pool.isUndef(val.toIntern());

scalar.* = try (try floatFromIntScalar(elem_val, scalar_ty, mod, opt_sema)).intern(scalar_ty, mod);

scalar.* = try (try intAddSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, mod)).intern(scalar_ty, mod);

scalar.* = try (try intSubSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, mod)).intern(scalar_ty, mod);

of.* = try of_math_result.overflow_bit.intern(Type.u1, mod);

scalar.* = try of_math_result.wrapped_result.intern(scalar_ty, mod);

scalar.* = try (try numberMulWrapScalar(lhs_elem, rhs_elem, scalar_ty, arena, mod)).intern(scalar_ty, mod);

scalar.* = try (try intMulSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, mod)).intern(scalar_ty, mod);

scalar.* = try (try bitwiseNotScalar(elem_val, scalar_ty, arena, mod)).intern(scalar_ty, mod);

scalar.* = try (try bitwiseAndScalar(lhs_elem, rhs_elem, scalar_ty, allocator, mod)).intern(scalar_ty, mod);

scalar.* = try (try bitwiseNandScalar(lhs_elem, rhs_elem, scalar_ty, arena, mod)).intern(scalar_ty, mod);

scalar.* = try (try bitwiseOrScalar(lhs_elem, rhs_elem, scalar_ty, allocator, mod)).intern(scalar_ty, mod);

scalar.* = try (try bitwiseXorScalar(lhs_elem, rhs_elem, scalar_ty, allocator, mod)).intern(scalar_ty, mod);

scalar.* = try val.intern(scalar_ty, mod);

scalar.* = try (try intDivFloorScalar(lhs_elem, rhs_elem, scalar_ty, allocator, mod)).intern(scalar_ty, mod);

scalar.* = try (try intModScalar(lhs_elem, rhs_elem, scalar_ty, allocator, mod)).intern(scalar_ty, mod);

if (val.ip_index == .none) return false;

if (val.ip_index == .none) return false;

if (val.ip_index == .none) return false;

scalar.* = try (try floatRemScalar(lhs_elem, rhs_elem, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try floatModScalar(lhs_elem, rhs_elem, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try val.intern(scalar_ty, mod);

scalar.* = try (try intTruncScalar(elem_val, scalar_ty, allocator, signedness, bits, mod)).intern(scalar_ty, mod);

scalar.* = try (try intTruncScalar(elem_val, scalar_ty, allocator, signedness, @as(u16, @intCast(bits_elem.toUnsignedInt(mod))), mod)).intern(scalar_ty, mod);

scalar.* = try (try shlScalar(lhs_elem, rhs_elem, scalar_ty, allocator, mod)).intern(scalar_ty, mod);

of.* = try of_math_result.overflow_bit.intern(Type.u1, mod);

scalar.* = try of_math_result.wrapped_result.intern(scalar_ty, mod);

scalar.* = try (try shlSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, mod)).intern(scalar_ty, mod);

scalar.* = try (try shlTruncScalar(lhs_elem, rhs_elem, scalar_ty, arena, mod)).intern(scalar_ty, mod);

scalar.* = try (try shrScalar(lhs_elem, rhs_elem, scalar_ty, allocator, mod)).intern(scalar_ty, mod);

scalar.* = try (try floatNegScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try floatAddScalar(lhs_elem, rhs_elem, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try floatSubScalar(lhs_elem, rhs_elem, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try floatDivScalar(lhs_elem, rhs_elem, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try floatDivFloorScalar(lhs_elem, rhs_elem, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try floatDivTruncScalar(lhs_elem, rhs_elem, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try floatMulScalar(lhs_elem, rhs_elem, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try sqrtScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try sinScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try cosScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try tanScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try expScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try exp2Scalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try logScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try log2Scalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try log10Scalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try absScalar(elem_val, scalar_ty, mod, arena)).intern(scalar_ty, mod);

scalar.* = try (try floorScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try ceilScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try roundScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try truncScalar(elem_val, scalar_ty, mod)).intern(scalar_ty, mod);

scalar.* = try (try mulAddScalar(scalar_ty, mulend1_elem, mulend2_elem, addend_elem, mod)).intern(scalar_ty, mod);

/// This type is not copyable since it may contain pointers to its inner data.

pub const Payload = struct {

tag: Tag,

 

pub const Slice = struct {

base: Payload,

data: struct {

ptr: Value,

len: Value,

},

};

 

pub const Bytes = struct {

base: Payload,

/// Includes the sentinel, if any.

data: []const u8,

};

 

pub const SubValue = struct {

base: Payload,

data: Value,

};

 

pub const Aggregate = struct {

base: Payload,

/// Field values. The types are according to the struct or array type.

/// The length is provided here so that copying a Value does not depend on the Type.

data: []Value,

};

 

pub const Union = struct {

pub const base_tag = Tag.@"union";

 

base: Payload = .{ .tag = base_tag },

data: Data,

 

pub const Data = struct {

tag: ?Value,

val: Value,

};

};

};

 

pub const zero_usize: Value = .{ .ip_index = .zero_usize, .legacy = undefined };

pub const zero_u8: Value = .{ .ip_index = .zero_u8, .legacy = undefined };

pub const zero_comptime_int: Value = .{ .ip_index = .zero, .legacy = undefined };

pub const one_comptime_int: Value = .{ .ip_index = .one, .legacy = undefined };

pub const negative_one_comptime_int: Value = .{ .ip_index = .negative_one, .legacy = undefined };

pub const undef: Value = .{ .ip_index = .undef, .legacy = undefined };

pub const @"void": Value = .{ .ip_index = .void_value, .legacy = undefined };

pub const @"null": Value = .{ .ip_index = .null_value, .legacy = undefined };

pub const @"false": Value = .{ .ip_index = .bool_false, .legacy = undefined };

pub const @"true": Value = .{ .ip_index = .bool_true, .legacy = undefined };

pub const @"unreachable": Value = .{ .ip_index = .unreachable_value, .legacy = undefined };

pub const generic_poison: Value = .{ .ip_index = .generic_poison, .legacy = undefined };

pub const generic_poison_type: Value = .{ .ip_index = .generic_poison_type, .legacy = undefined };

pub const empty_struct: Value = .{ .ip_index = .empty_struct, .legacy = undefined };

 

/// This function is used in the debugger pretty formatters in tools/ to fetch the

/// Tag to Payload mapping to facilitate fancy debug printing for this type.

fn dbHelper(self: *Value, tag_to_payload_map: *map: {

const tags = @typeInfo(Tag).Enum.fields;

var fields: [tags.len]std.builtin.Type.StructField = undefined;

for (&fields, tags) |*field, t| field.* = .{

.name = t.name ++ "",

.type = *@field(Tag, t.name).Type(),

.default_value = null,

.is_comptime = false,

.alignment = 0,

};

break :map @Type(.{ .Struct = .{

.layout = .@"extern",

.fields = &fields,

.decls = &.{},

.is_tuple = false,

} });

}) void {

_ = self;

_ = tag_to_payload_map;

}

 

comptime {

if (!builtin.strip_debug_info) {

_ = &dbHelper;

}

}

const TypedValue = @import("../../TypedValue.zig");

const fn_type = fn_owner_decl.ty;

const inst_index = inst.toIndex() orelse return self.genTypedValue(.{

.ty = inst_ty,

.val = (try self.air.value(inst, mod)).?,

});

fn genTypedValue(self: *Self, arg_tv: TypedValue) InnerError!MCValue {

arg_tv,

const TypedValue = @import("../../TypedValue.zig");

const fn_type = fn_owner_decl.ty;

const inst_index = inst.toIndex() orelse return self.genTypedValue(.{

.ty = inst_ty,

.val = (try self.air.value(inst, mod)).?,

});

fn genTypedValue(self: *Self, arg_tv: TypedValue) InnerError!MCValue {

arg_tv,

const TypedValue = @import("../../TypedValue.zig");

const fn_type = fn_owner_decl.ty;

const inst_index = inst.toIndex() orelse return self.genTypedValue(.{

.ty = inst_ty,

.val = (try self.air.value(inst, mod)).?,

});

fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {

typed_value,

const TypedValue = @import("../../TypedValue.zig");

const fn_type = fn_owner_decl.ty;

fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {

typed_value,

return self.genTypedValue(.{

.ty = ty,

.val = (try self.air.value(ref, mod)).?,

});

const TypedValue = @import("../../TypedValue.zig");

const sym_index = try func.bin_file.lowerUnnamedConst(.{ .ty = ty, .val = val }, func.decl_index);

const fn_info = mod.typeToFunc(func.decl.ty).?;

var cc_result = try func.resolveCallingConventionValues(func.decl.ty);

const fn_info = mod.typeToFunc(func.decl.ty).?;

const fn_info = mod.typeToFunc(func.decl.ty).?;

const fn_info = mod.typeToFunc(func.decl.ty).?;

const ext_info = mod.typeToFunc(ext_decl.ty).?;

return func.fail("Expected a function, but instead found type '{}'", .{func_val.tag()});

const cc = mod.typeToFunc(func.decl.ty).?.cc;

const mod = func.bin_file.base.comp.module.?;

const decl = mod.declPtr(decl_index);

try mod.markDeclAlive(decl);

const ptr_ty = try mod.singleMutPtrType(decl.ty);

return func.lowerDeclRefValue(.{ .ty = ptr_ty, .val = ptr_val }, decl_index, offset);

fn lowerDeclRefValue(func: *CodeGen, tv: TypedValue, decl_index: InternPool.DeclIndex, offset: u32) InnerError!WValue {

return func.lowerDeclRefValue(tv, func_val.owner_decl, offset);

return func.lowerDeclRefValue(tv, func_val.decl, offset);

if (decl.ty.zigTypeTag(mod) != .Fn and !decl.ty.hasRuntimeBitsIgnoreComptime(mod)) {

try mod.markDeclAlive(decl);

if (decl.ty.zigTypeTag(mod) == .Fn) {

const err_tv: TypedValue = switch (error_union.val) {

.ty = ty.errorUnionSet(mod),

.val = Value.fromInterned((try mod.intern(.{ .err = .{

.ty = err_int_ty,

.val = try mod.intValue(err_int_ty, 0),

return func.lowerConstant(err_tv.val, err_tv.ty);

return .{ .memory = try func.bin_file.lowerUnnamedConst(.{ .ty = ty, .val = val }, owner_decl) };

.decl => |decl| return func.lowerDeclRefValue(.{ .ty = ty, .val = val }, decl, 0),

.{ .ty = name_ty, .val = Value.fromInterned(name_val) },

const TypedValue = @import("../../TypedValue.zig");

const fn_type = fn_owner_decl.ty;

const tag_mcv = try self.genTypedValue(.{ .ty = enum_ty, .val = tag_val });

const splat_mcv = try self.genTypedValue(.{ .ty = splat_ty, .val = Value.fromInterned(splat_val) });

const mask_mcv = try self.genTypedValue(.{

.ty = mask_ty,

.val = Value.fromInterned((try mod.intern(.{ .aggregate = .{

.ty = mask_ty.toIntern(),

.storage = .{ .elems = &([1]InternPool.Index{

(try rhs_ty.childType(mod).maxIntScalar(mod, Type.u8)).toIntern(),

} ++ [1]InternPool.Index{

(try mod.intValue(Type.u8, 0)).toIntern(),

} ** 15) },

} }))),

});

const sign_mcv = try self.genTypedValue(.{ .ty = vec_ty, .val = switch (tag) {

} });

const not_mcv = try self.genTypedValue(.{

.ty = lhs_ty,

.val = try unsigned_ty.maxInt(mod, unsigned_ty),

});

.decl => |decl| mod.intern_pool.indexToKey(try mod.declPtr(decl).internValue(mod)),

try mod.markDeclAlive(mod.declPtr(func.owner_decl));

try mod.markDeclAlive(owner_decl);

.segment, .x87, .mmx, .sse => try self.genSetReg(dst_reg, ty, try self.genTypedValue(.{

.ty = ty,

.val = try mod.undefValue(ty),

}), opts),

const mask_mcv = try self.genTypedValue(.{

.ty = mask_ty,

.val = Value.fromInterned(try mod.intern(.{ .aggregate = .{

.ty = mask_ty.toIntern(),

.storage = .{ .elems = mask_elems[0..vec_len] },

} })),

});

const mask_mcv = try self.genTypedValue(.{

.ty = mask_ty,

.val = Value.fromInterned(try mod.intern(.{ .aggregate = .{

.ty = mask_ty.toIntern(),

.storage = .{ .elems = mask_elems[0..vec_len] },

} })),

});

const select_mask_mcv = try self.genTypedValue(.{

.ty = select_mask_ty,

.val = Value.fromInterned(try mod.intern(.{ .aggregate = .{

.ty = select_mask_ty.toIntern(),

.storage = .{ .elems = select_mask_elems[0..mask_elems.len] },

} })),

});

const lhs_mask_mcv = try self.genTypedValue(.{

.ty = lhs_mask_ty,

.val = Value.fromInterned(try mod.intern(.{ .aggregate = .{

.ty = lhs_mask_ty.toIntern(),

.storage = .{ .elems = lhs_mask_elems[0..max_abi_size] },

} })),

});

const rhs_mask_mcv = try self.genTypedValue(.{

.ty = rhs_mask_ty,

.val = Value.fromInterned(try mod.intern(.{ .aggregate = .{

.ty = rhs_mask_ty.toIntern(),

.storage = .{ .elems = rhs_mask_elems[0..max_abi_size] },

} })),

});

lhs_ty.fmt(mod), rhs_ty.fmt(mod), dst_ty.fmt(mod),

Value.fromInterned(extra.mask).fmtValue(

Type.fromInterned(mod.intern_pool.typeOf(extra.mask)),

mod,

),

try self.genTypedValue(.{ .ty = elem_ty, .val = sentinel }),

const const_mcv = try self.genTypedValue(.{ .ty = ty, .val = Value.fromInterned(ip_index) });

fn genTypedValue(self: *Self, arg_tv: TypedValue) InnerError!MCValue {

return switch (try codegen.genTypedValue(self.bin_file, self.src_loc, arg_tv, self.owner.getDecl(mod))) {

const TypedValue = @import("TypedValue.zig");

arg_tv: TypedValue,

const typed_value = arg_tv;

log.debug("generateSymbol: ty = {}, val = {}", .{

typed_value.ty.fmt(mod),

typed_value.val.fmtValue(typed_value.ty, mod),

});

if (typed_value.val.isUndefDeep(mod)) {

const abi_size = math.cast(usize, typed_value.ty.abiSize(mod)) orelse return error.Overflow;

switch (ip.indexToKey(typed_value.val.toIntern())) {

const abi_size = math.cast(usize, typed_value.ty.abiSize(mod)) orelse return error.Overflow;

const val = typed_value.val.toBigInt(&space, mod);

val.writeTwosComplement(try code.addManyAsSlice(abi_size), endian);

const payload_ty = typed_value.ty.errorUnionPayload(mod);

const abi_align = typed_value.ty.abiAlignment(mod);

switch (try generateSymbol(bin_file, src_loc, .{

.ty = payload_ty,

.val = Value.fromInterned(switch (error_union.val) {

.err_name => try mod.intern(.{ .undef = payload_ty.toIntern() }),

.payload => |payload| payload,

}),

}, code, debug_output, reloc_info)) {

const int_tag_ty = typed_value.ty.intTagType(mod);

switch (try generateSymbol(bin_file, src_loc, .{

.ty = int_tag_ty,

.val = try mod.getCoerced(Value.fromInterned(enum_tag.int), int_tag_ty),

}, code, debug_output, reloc_info)) {

const abi_size = math.cast(usize, typed_value.ty.abiSize(mod)) orelse return error.Overflow;

.ptr => switch (try lowerParentPtr(bin_file, src_loc, typed_value.val.toIntern(), code, debug_output, reloc_info)) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = typed_value.ty.slicePtrFieldType(mod),

.val = Value.fromInterned(slice.ptr),

}, code, debug_output, reloc_info)) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = Type.usize,

.val = Value.fromInterned(slice.len),

}, code, debug_output, reloc_info)) {

const payload_type = typed_value.ty.optionalChild(mod);

const payload_val = typed_value.val.optionalValue(mod);

const abi_size = math.cast(usize, typed_value.ty.abiSize(mod)) orelse return error.Overflow;

if (typed_value.ty.optionalReprIsPayload(mod)) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = payload_type,

.val = value,

}, code, debug_output, reloc_info)) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = payload_type,

.val = value,

}, code, debug_output, reloc_info)) {

.aggregate => |aggregate| switch (ip.indexToKey(typed_value.ty.toIntern())) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = Type.fromInterned(array_type.child),

.val = Value.fromInterned(switch (aggregate.storage) {

.bytes => unreachable,

.elems => |elems| elems[@as(usize, @intCast(index))],

.repeated_elem => |elem| if (index < array_type.len)

elem

else

array_type.sentinel,

}),

}, code, debug_output, reloc_info)) {

const abi_size = math.cast(usize, typed_value.ty.abiSize(mod)) orelse

switch (try generateSymbol(bin_file, src_loc, .{

.ty = Type.fromInterned(vector_type.child),

.val = Value.fromInterned(switch (aggregate.storage) {

.bytes => unreachable,

.elems => |elems| elems[

math.cast(usize, index) orelse return error.Overflow

],

.repeated_elem => |elem| elem,

}),

}, code, debug_output, reloc_info)) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = Type.fromInterned(field_ty),

.val = Value.fromInterned(field_val),

}, code, debug_output, reloc_info)) {

const padded_field_end = typed_value.ty.structFieldOffset(index + 1, mod);

const struct_type = ip.loadStructType(typed_value.ty.toIntern());

const abi_size = math.cast(usize, typed_value.ty.abiSize(mod)) orelse

switch (try generateSymbol(bin_file, src_loc, .{

.ty = Type.fromInterned(field_ty),

.val = Value.fromInterned(field_val),

}, &tmp_list, debug_output, reloc_info)) {

const field_val = switch (ip.indexToKey(typed_value.val.toIntern()).aggregate.storage) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = Type.fromInterned(field_ty),

.val = Value.fromInterned(field_val),

}, code, debug_output, reloc_info)) {

const layout = typed_value.ty.unionGetLayout(mod);

return generateSymbol(bin_file, src_loc, .{

.ty = typed_value.ty.unionTagTypeSafety(mod).?,

.val = Value.fromInterned(un.tag),

}, code, debug_output, reloc_info);

switch (try generateSymbol(bin_file, src_loc, .{

.ty = typed_value.ty.unionTagTypeSafety(mod).?,

.val = Value.fromInterned(un.tag),

}, code, debug_output, reloc_info)) {

const union_obj = mod.typeToUnion(typed_value.ty).?;

const field_index = typed_value.ty.unionTagFieldIndex(Value.fromInterned(un.tag), mod).?;

switch (try generateSymbol(bin_file, src_loc, .{

.ty = field_ty,

.val = Value.fromInterned(un.val),

}, code, debug_output, reloc_info)) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = Type.fromInterned(ip.typeOf(un.val)),

.val = Value.fromInterned(un.val),

}, code, debug_output, reloc_info)) {

switch (try generateSymbol(bin_file, src_loc, .{

.ty = Type.fromInterned(union_obj.enum_tag_ty),

.val = Value.fromInterned(un.tag),

}, code, debug_output, reloc_info)) {

.int => |int| try generateSymbol(bin_file, src_loc, .{

.ty = Type.usize,

.val = Value.fromInterned(int),

}, code, debug_output, reloc_info),

const is_fn_body = decl.ty.zigTypeTag(zcu) == .Fn;

if (!is_fn_body and !decl.ty.hasRuntimeBits(zcu)) {

try zcu.markDeclAlive(decl);

 

tv: TypedValue,

log.debug("genDeclRef: ty = {}, val = {}", .{ tv.ty.fmt(zcu), tv.val.fmtValue(tv.ty, zcu) });

const decl_index = switch (zcu.intern_pool.indexToKey(try ptr_decl.internValue(zcu))) {

if (!decl.ty.isFnOrHasRuntimeBitsIgnoreComptime(zcu)) {

if (tv.ty.castPtrToFn(zcu)) |fn_ty| {

} else if (tv.ty.zigTypeTag(zcu) == .Pointer) {

const elem_ty = tv.ty.elemType2(zcu);

try zcu.markDeclAlive(decl);

 

const is_threadlocal = tv.val.isPtrToThreadLocal(zcu) and !single_threaded;

tv: TypedValue,

log.debug("genUnnamedConst: ty = {}, val = {}", .{ tv.ty.fmt(zcu), tv.val.fmtValue(tv.ty, zcu) });

const local_sym_index = lf.lowerUnnamedConst(tv, owner_decl_index) catch |err| {

arg_tv: TypedValue,

const typed_value = arg_tv;

log.debug("genTypedValue: ty = {}, val = {}", .{

typed_value.ty.fmt(zcu),

typed_value.val.fmtValue(typed_value.ty, zcu),

});

if (typed_value.val.isUndef(zcu))

if (!typed_value.ty.isSlice(zcu)) switch (zcu.intern_pool.indexToKey(typed_value.val.toIntern())) {

.decl => |decl| return genDeclRef(lf, src_loc, typed_value, decl),

switch (typed_value.ty.zigTypeTag(zcu)) {

.Pointer => switch (typed_value.ty.ptrSize(zcu)) {

else => switch (typed_value.val.toIntern()) {

else => switch (zcu.intern_pool.indexToKey(typed_value.val.toIntern())) {

return GenResult.mcv(.{ .immediate = typed_value.val.toUnsignedInt(zcu) });

const info = typed_value.ty.intInfo(zcu);

.signed => @as(u64, @bitCast(typed_value.val.toSignedInt(zcu))),

.unsigned => typed_value.val.toUnsignedInt(zcu),

return GenResult.mcv(.{ .immediate = @intFromBool(typed_value.val.toBool()) });

if (typed_value.ty.isPtrLikeOptional(zcu)) {

return genTypedValue(lf, src_loc, .{

.ty = typed_value.ty.optionalChild(zcu),

.val = typed_value.val.optionalValue(zcu) orelse return GenResult.mcv(.{ .immediate = 0 }),

}, owner_decl_index);

} else if (typed_value.ty.abiSize(zcu) == 1) {

return GenResult.mcv(.{ .immediate = @intFromBool(!typed_value.val.isNull(zcu)) });

const enum_tag = zcu.intern_pool.indexToKey(typed_value.val.toIntern()).enum_tag;

const int_tag_ty = zcu.intern_pool.typeOf(enum_tag.int);

return genTypedValue(lf, src_loc, .{

.ty = Type.fromInterned(int_tag_ty),

.val = Value.fromInterned(enum_tag.int),

}, owner_decl_index);

const err_name = zcu.intern_pool.indexToKey(typed_value.val.toIntern()).err.name;

const err_type = typed_value.ty.errorUnionSet(zcu);

const payload_type = typed_value.ty.errorUnionPayload(zcu);

switch (zcu.intern_pool.indexToKey(typed_value.val.toIntern()).error_union.val) {

.err_name => |err_name| return genTypedValue(lf, src_loc, .{

.ty = err_type,

.val = Value.fromInterned((try zcu.intern(.{ .err = .{

} }))),

}, owner_decl_index),

.payload => return genTypedValue(lf, src_loc, .{

.ty = err_int_ty,

.val = try zcu.intValue(err_int_ty, 0),

}, owner_decl_index),

return genUnnamedConst(lf, src_loc, typed_value, owner_decl_index);

const TypedValue = @import("../TypedValue.zig");

if (ty.isPtrAtRuntime(mod) and !decl.ty.isFnOrHasRuntimeBits(mod)) {

const need_typecast = if (ty.castPtrToFn(mod)) |_| false else !ty.childType(mod).eql(decl.ty, mod);

const fn_cty_idx = try dg.typeToIndex(fn_decl.ty, kind);

const fn_info = mod.typeToFunc(fn_decl.ty).?;

fn declIsGlobal(dg: *DeclGen, tv: TypedValue) bool {

return switch (mod.intern_pool.indexToKey(tv.val.ip_index)) {

const is_global = variable.is_extern or dg.declIsGlobal(.{ .ty = decl.ty, .val = decl.val });

decl.ty,

try mod.markDeclAlive(decl);

const tv: TypedValue = .{ .ty = decl.ty, .val = Value.fromInterned((try decl.internValue(mod))) };

const is_variable_const = switch (ip.indexToKey(tv.val.toIntern())) {

decl.ty,

const fn_cty = try o.dg.typeToCType(fn_decl.ty, .complete);

const tv: TypedValue = .{

.ty = decl.ty,

.val = decl.val,

};

const is_global = o.dg.declIsGlobal(tv);

const tv: TypedValue = .{ .ty = decl.ty, .val = Value.fromInterned((try decl.internValue(mod))) };

if (!tv.ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) return;

if (tv.val.getExternFunc(mod)) |_| {

} else if (tv.val.getVariable(mod)) |variable| {

const is_global = variable.is_extern or o.dg.declIsGlobal(tv);

try o.dg.renderTypeAndName(w, tv.ty, decl_c_value, .{}, decl.alignment, .complete);

try o.dg.renderValue(w, tv.ty, Value.fromInterned(variable.init), .StaticInitializer);

try genDeclValue(o, tv, is_global, decl_c_value, decl.alignment, decl.@"linksection");

tv: TypedValue,

try o.dg.renderTypeAndName(fwd_decl_writer, tv.ty, decl_c_value, Const, alignment, .complete);

try o.dg.renderTypeAndName(w, tv.ty, decl_c_value, Const, alignment, .complete);

try o.dg.renderValue(w, tv.ty, tv.val, .StaticInitializer);

const tv: TypedValue = .{

.ty = decl.ty,

.val = decl.val,

};

switch (tv.ty.zigTypeTag(mod)) {

.Fn => if (dg.declIsGlobal(tv)) {

TypedValue{ .ty = Type.bool, .val = Value.true }

TypedValue{ .ty = optional_ty, .val = try mod.getCoerced(Value.null, optional_ty) }

TypedValue{ .ty = err_int_ty, .val = try mod.intValue(err_int_ty, 0) }

break :rhs TypedValue{ .ty = opt_slice_ptr_ty, .val = try mod.nullValue(opt_slice_ptr_ty) };

break :rhs TypedValue{ .ty = Type.bool, .val = Value.true };

try f.object.dg.renderValue(writer, rhs.ty, rhs.val, .Other);

const fn_cty = try f.typeToCType(decl.ty, .complete);

const TypedValue = @import("../TypedValue.zig");

const fn_info = zcu.typeToFunc(decl.ty).?;

const debug_decl_type = try o.lowerDebugType(decl.ty);

if (mod.getTarget().isWasm() and try decl.isFunction(mod)) {

const zig_fn_type = decl.ty;

try o.lowerType(decl.ty),

const fn_decl = mod.declPtr(fn_decl_index);

try mod.markDeclAlive(fn_decl);

const fn_decl = mod.declPtr(fn_decl_index);

try mod.markDeclAlive(fn_decl);

try mod.markDeclAlive(decl);

const ptr_ty = try mod.singleMutPtrType(decl.ty);

const is_fn_body = decl.ty.zigTypeTag(mod) == .Fn;

if ((!is_fn_body and !decl.ty.hasRuntimeBits(mod)) or

(is_fn_body and mod.typeToFunc(decl.ty).?.is_generic)) return o.lowerPtrToVoid(ty);

 

try mod.markDeclAlive(decl);

try o.lowerDebugType(decl.ty),

const llvm_val = try self.resolveValue(.{

.ty = self.typeOf(inst),

.val = (try self.air.value(inst, mod)).?,

});

fn resolveValue(self: *FuncGen, tv: TypedValue) Error!Builder.Constant {

const llvm_val = try o.lowerValue(tv.val.toIntern());

if (!isByRef(tv.ty, mod)) return llvm_val;

variable_index.setAlignment(tv.ty.abiAlignment(mod).toLlvm(), &o.builder);

const ty = try mod.intern(.{ .opt_type = .usize_type });

o.null_opt_usize = try self.resolveValue(.{

.ty = Type.fromInterned(ty),

.val = Value.fromInterned((try mod.intern(.{ .opt = .{ .ty = ty, .val = .none } }))),

});

const msg_len = msg_decl.ty.childType(mod).arrayLen(mod);

const msg_ptr = try o.lowerValue(try msg_decl.internValue(mod));

const fn_info = mod.typeToFunc(panic_decl.ty).?;

const fn_info = mod.typeToFunc(self.dg.decl.ty).?;

const fn_info = mod.typeToFunc(self.dg.decl.ty).?;

const llvm_elem = try self.resolveValue(.{

.ty = array_info.elem_type,

.val = sent_val,

});

try mod.markDeclAlive(decl);

log.debug("constant: ty = {}, val = {}", .{ ty.fmt(mod), val.fmtValue(ty, mod) });

if (!decl.ty.isFnOrHasRuntimeBitsIgnoreComptime(mod)) {

const decl_ptr_ty_ref = try self.ptrType(decl.ty, final_storage_class);

assert(decl.ty.zigTypeTag(mod) == .Fn);

const fn_info = mod.typeToFunc(decl.ty).?;

const prototype_ty_ref = try self.resolveType(decl.ty, .direct);

const ptr_ty_ref = try self.ptrType(decl.ty, final_storage_class);

const ptr_ty_ref = try self.ptrType(decl.ty, .Function);

const val_id = try self.constant(decl.ty, init_val, .indirect);

const fn_info = mod.typeToFunc(decl.ty).?;

const fn_info = mod.typeToFunc(decl.ty).?;

const TypedValue = @import("TypedValue.zig");

pub fn lowerUnnamedConst(base: *File, tv: TypedValue, decl_index: InternPool.DeclIndex) UpdateDeclError!u32 {

return @fieldParentPtr(t.Type(), "base", base).lowerUnnamedConst(tv, decl_index);

.is_naked_fn = decl.ty.fnCallingConvention(module) == .Naked,

const tv: @import("../TypedValue.zig") = .{

.ty = Type.fromInterned(module.intern_pool.typeOf(anon_decl)),

.val = Value.fromInterned(anon_decl),

};

codegen.genDeclValue(&object, tv, false, c_value, alignment, .none) catch |err| switch (err) {

pub fn lowerUnnamedConst(self: *Coff, tv: TypedValue, decl_index: InternPool.DeclIndex) !u32 {

const atom_index = switch (try self.lowerConst(sym_name, tv, tv.ty.abiAlignment(mod), self.rdata_section_index.?, decl.srcLoc(mod))) {

fn lowerConst(self: *Coff, name: []const u8, tv: TypedValue, required_alignment: InternPool.Alignment, sect_id: u16, src_loc: Module.SrcLoc) !LowerConstResult {

const res = try codegen.generateSymbol(&self.base, src_loc, tv, &code_buffer, .none, .{

const res = try codegen.generateSymbol(&self.base, decl.srcLoc(mod), .{

.ty = decl.ty,

.val = decl_val,

}, &code_buffer, .none, .{

const ty = decl.ty;

const decl_cc = exported_decl.ty.fnCallingConvention(mod);

const tv = TypedValue{ .ty = ty, .val = val };

tv,

const TypedValue = @import("../TypedValue.zig");

switch (decl.ty.zigTypeTag(mod)) {

const fn_ret_type = decl.ty.fnReturnType(mod);

switch (decl.ty.zigTypeTag(zcu)) {

pub fn lowerUnnamedConst(self: *Elf, typed_value: TypedValue, decl_index: InternPool.DeclIndex) !u32 {

return self.zigObjectPtr().?.lowerUnnamedConst(self, typed_value, decl_index);

const TypedValue = @import("../TypedValue.zig");

const tv = TypedValue{ .ty = ty, .val = val };

tv,

const shdr_index = switch (decl.ty.zigTypeTag(mod)) {

try codegen.generateSymbol(&elf_file.base, decl.srcLoc(mod), .{

.ty = decl.ty,

.val = decl_val,

}, &code_buffer, .{

try codegen.generateSymbol(&elf_file.base, decl.srcLoc(mod), .{

.ty = decl.ty,

.val = decl_val,

}, &code_buffer, .none, .{

typed_value: TypedValue,

typed_value,

typed_value.ty.abiAlignment(mod),

tv: TypedValue,

const res = try codegen.generateSymbol(&elf_file.base, src_loc, tv, &code_buffer, .{

const TypedValue = @import("../../TypedValue.zig");

pub fn lowerUnnamedConst(self: *MachO, typed_value: TypedValue, decl_index: InternPool.DeclIndex) !u32 {

return self.getZigObject().?.lowerUnnamedConst(self, typed_value, decl_index);

const TypedValue = @import("../TypedValue.zig");

const val = Value.fromInterned(decl_val);

const tv = TypedValue{ .ty = ty, .val = val };

tv,

const res =

try codegen.generateSymbol(&macho_file.base, decl.srcLoc(mod), .{

.ty = decl.ty,

.val = decl_val,

}, &code_buffer, dio, .{

const sect_id: u8 = switch (decl.ty.zigTypeTag(mod)) {

typed_value: TypedValue,

typed_value,

typed_value.ty.abiAlignment(mod),

tv: TypedValue,

const res = try codegen.generateSymbol(&macho_file.base, src_loc, tv, &code_buffer, .{

const TypedValue = @import("../../TypedValue.zig");

const TypedValue = @import("../TypedValue.zig");

if (decl.ty.zigTypeTag(mod) == .Fn) {

pub fn lowerUnnamedConst(self: *Plan9, tv: TypedValue, decl_index: InternPool.DeclIndex) !u32 {

const res = try codegen.generateSymbol(&self.base, decl.srcLoc(mod), tv, &code_buffer, .{

const res = try codegen.generateSymbol(&self.base, decl.srcLoc(mod), .{

.ty = decl.ty,

.val = decl_val,

}, &code_buffer, .{ .none = {} }, .{

const is_fn = (decl.ty.zigTypeTag(mod) == .Fn);

const mod = self.base.comp.module.?;

const ty = Type.fromInterned(mod.intern_pool.typeOf(decl_val));

const tv = TypedValue{ .ty = ty, .val = val };

const res = try codegen.generateSymbol(&self.base, src_loc, tv, &code_buffer, .{ .none = {} }, .{ .parent_atom_index = index });

const execution_model = switch (decl.ty.fnCallingConvention(mod)) {

const TypedValue = @import("../TypedValue.zig");

pub fn lowerUnnamedConst(wasm: *Wasm, tv: TypedValue, decl_index: InternPool.DeclIndex) !u32 {

return wasm.zigObjectPtr().?.lowerUnnamedConst(wasm, tv, decl_index);

.{ .ty = decl.ty, .val = val },

switch (decl.ty.zigTypeTag(mod)) {

const mod = wasm_file.base.comp.module.?;

const ty = Type.fromInterned(mod.intern_pool.typeOf(decl_val));

const tv: TypedValue = .{ .ty = ty, .val = Value.fromInterned(decl_val) };

switch (try zig_object.lowerConst(wasm_file, name, tv, src_loc)) {