srctree

</p>

{#code_begin|obj|export_builtin#}

comptime {

}

 

fn internalName() callconv(.C) void {}

 

}

}

 

 

fn exportIt() void {

@export(clear_cache, .{ .name = "__clear_cache", .linkage = linkage });

 

const builtin = @import("builtin");

const native_endian = builtin.cpu.arch.endian();

 

/// Determines the symbol's visibility to other objects.

/// For WebAssembly this allows the symbol to be resolved to other modules, but will not

/// export it to the host runtime.

pub const visibility: std.builtin.SymbolVisibility =

pub const want_aeabi = switch (builtin.abi) {

.eabi,

.eabihf,

 

/// This data structure is used by the Zig language code generation and

/// therefore must be kept in sync with the compiler implementation.

pub const GlobalLinkage = enum {

};

 

/// This data structure is used by the Zig language code generation and

/// therefore must be kept in sync with the compiler implementation.

pub const ExportOptions = struct {

name: []const u8,

section: ?[]const u8 = null,

visibility: SymbolVisibility = .default,

};

pub const ExternOptions = struct {

name: []const u8,

library_name: ?[]const u8 = null,

is_thread_local: bool = false,

};

 

 

const system = std.os.system;

 

pub const DynLib = switch (builtin.os.tag) {

ElfDynLib

else

DlDynLib,

 

 

pub const Options = struct {

name: InternPool.NullTerminatedString,

section: InternPool.OptionalNullTerminatedString = .none,

visibility: std.builtin.SymbolVisibility = .default,

};

 

.needed_comptime_reason = "export target must be comptime-known",

});

const options = try sema.resolveExportOptions(block, options_src, extra.options);

return;

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

const decl_index = function.owner_decl;

const gpa = sema.gpa;

const mod = sema.mod;

 

return;

 

try mod.ensureDeclAnalyzed(exported_decl_index);

return sema.fail(block, name_src, "exported symbol name cannot be empty", .{});

}

 

return sema.fail(block, visibility_src, "symbol '{s}' exported with internal linkage has non-default visibility {s}", .{

name, @tagName(visibility),

});

) CompileError!struct {

name: InternPool.NullTerminatedString,

library_name: InternPool.OptionalNullTerminatedString = .none,

is_thread_local: bool = false,

} {

const mod = sema.mod;

return sema.fail(block, name_src, "extern symbol name cannot be empty", .{});

}

 

return sema.fail(block, linkage_src, "extern symbol must use strong or weak linkage", .{});

}

 

else => |e| return e,

};

 

ty = try mod.optionalType(ty.toIntern());

}

const ptr_info = ty.ptrInfo(mod);

.is_extern = true,

.is_const = ptr_info.flags.is_const,

.is_threadlocal = options.is_thread_local,

} }),

),

}, options.name);

 

try fwd.writeAll(if (is_global) "zig_extern " else "static ");

const maybe_exports = dg.module.decl_exports.get(decl_index);

const export_weak_linkage = if (maybe_exports) |exports|

else

false;

if (variable.is_weak_linkage or export_weak_linkage) try fwd.writeAll("zig_weak_linkage ");

const is_variable_const = switch (ip.indexToKey(tv.val.toIntern())) {

.func => return for (exports.items[1..], 1..) |@"export", i| {

try fwd.writeAll("zig_extern ");

try o.dg.renderFunctionSignature(

fwd,

decl_index,

};

for (exports.items[1..]) |@"export"| {

try fwd.writeAll("zig_extern ");

const export_name = ip.stringToSlice(@"export".opts.name);

try o.dg.renderTypeAndName(

fwd,

try fwd_decl_writer.writeAll(if (is_global) "zig_extern " else "static ");

 

if (mod.decl_exports.get(decl_index)) |exports|

try o.dg.renderFunctionSignature(fwd_decl_writer, decl_index, .forward, .{ .export_index = 0 });

try fwd_decl_writer.writeAll(";\n");

try genExports(o);

 

if (comp.config.dll_export_fns)

global_index.setDllStorageClass(.dllexport, &o.builder);

global_index.setLinkage(switch (exports[0].opts.linkage) {

}, &o.builder);

global_index.setVisibility(switch (exports[0].opts.visibility) {

.default => .default,

 

}

}

 

try mod.failed_exports.putNoClobber(gpa, exp, try Module.ErrorMsg.create(

gpa,

exp.getSrcLoc(mod),

.{},

));

continue;

sym.type = atom.getSymbol(self).type;

 

switch (exp.opts.linkage) {

sym.storage_class = .EXTERNAL;

},

else => unreachable,

}

 

 

}

}

const stb_bits: u8 = switch (exp.opts.linkage) {

try mod.failed_exports.ensureUnusedCapacity(mod.gpa, 1);

mod.failed_exports.putAssumeCapacityNoClobber(exp, try Module.ErrorMsg.create(

gpa,

 

continue;

}

}

try mod.failed_exports.putNoClobber(mod.gpa, exp, try Module.ErrorMsg.create(

gpa,

exp.getSrcLoc(mod),

.{},

));

continue;

self.symtab.items(.atom)[global_nlist_index] = self.symtab.items(.atom)[nlist_idx];

 

switch (exp.opts.linkage) {

// Symbol should be hidden, or in MachO lingo, private extern.

global_nlist.n_type |= macho.N_PEXT;

},

// Weak linkage is specified as part of n_desc field.

// Symbol's n_type is like for a symbol with strong linkage.

global_nlist.n_desc |= macho.N_WEAK_DEF;

 

sym.name = export_name;

 

switch (exp.opts.linkage) {

sym.setFlag(.WASM_SYM_VISIBILITY_HIDDEN);

},

sym.setFlag(.WASM_SYM_BINDING_WEAK);

},

try mod.failed_exports.putNoClobber(gpa, exp, try Module.ErrorMsg.create(

gpa,

decl.srcLoc(mod),

 

\\}

\\export var strongBar: usize = 100;

\\comptime {

\\}

,

});

 

\\ return x;

\\}

\\comptime {

\\}

});