1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
const GhosttyLib = @This();
const std = @import("std");
const RunStep = std.Build.Step.Run;
const Config = @import("Config.zig");
const SharedDeps = @import("SharedDeps.zig");
const LibtoolStep = @import("LibtoolStep.zig");
const LipoStep = @import("LipoStep.zig");
/// The step that generates the file.
step: *std.Build.Step,
/// The final static library file
output: std.Build.LazyPath,
dsym: ?std.Build.LazyPath,
pub fn initStatic(
b: *std.Build,
deps: *const SharedDeps,
) !GhosttyLib {
const lib = b.addLibrary(.{
.name = "ghostty",
.root_module = b.createModule(.{
.root_source_file = b.path("src/main_c.zig"),
.target = deps.config.target,
.optimize = deps.config.optimize,
.strip = deps.config.strip,
.omit_frame_pointer = deps.config.strip,
.unwind_tables = if (deps.config.strip) .none else .sync,
}),
// Fails on self-hosted x86_64 on macOS
.use_llvm = true,
});
lib.linkLibC();
// These must be bundled since we're compiling into a static lib.
// Otherwise, you get undefined symbol errors.
lib.bundle_compiler_rt = true;
lib.bundle_ubsan_rt = true;
if (deps.config.target.result.os.tag == .windows) {
// Zig's ubsan emits /exclude-symbols linker directives that
// are incompatible with the MSVC linker (LNK4229).
lib.bundle_ubsan_rt = false;
}
// Add our dependencies. Get the list of all static deps so we can
// build a combined archive if necessary.
var lib_list = try deps.add(lib);
try lib_list.append(b.allocator, lib.getEmittedBin());
if (!deps.config.target.result.os.tag.isDarwin()) return .{
.step = &lib.step,
.output = lib.getEmittedBin(),
.dsym = null,
};
// Create a static lib that contains all our dependencies.
const libtool = LibtoolStep.create(b, .{
.name = "ghostty",
.out_name = "libghostty-fat.a",
.sources = lib_list.items,
});
libtool.step.dependOn(&lib.step);
return .{
.step = libtool.step,
.output = libtool.output,
// Static libraries cannot have dSYMs because they aren't linked.
.dsym = null,
};
}
pub fn initShared(
b: *std.Build,
deps: *const SharedDeps,
) !GhosttyLib {
const lib = b.addLibrary(.{
.name = "ghostty",
.linkage = .dynamic,
.root_module = b.createModule(.{
.root_source_file = b.path("src/main_c.zig"),
.target = deps.config.target,
.optimize = deps.config.optimize,
.strip = deps.config.strip,
.omit_frame_pointer = deps.config.strip,
.unwind_tables = if (deps.config.strip) .none else .sync,
}),
// Fails on self-hosted x86_64
.use_llvm = true,
});
_ = try deps.add(lib);
// On Windows with MSVC, building a DLL requires the full CRT library
// chain. linkLibC() (called via deps.add) provides msvcrt.lib, but
// that references symbols in vcruntime.lib and ucrt.lib. Zig's library
// search paths include the MSVC lib dir and the Windows SDK 'um' dir,
// but not the SDK 'ucrt' dir where ucrt.lib lives.
if (deps.config.target.result.os.tag == .windows and
deps.config.target.result.abi == .msvc)
{
// The CRT initialization code in msvcrt.lib calls __vcrt_initialize
// and __acrt_initialize, which are in the static CRT libraries.
lib.linkSystemLibrary("libvcruntime");
// ucrt.lib is in the Windows SDK 'ucrt' dir. Detect the SDK
// installation and add the UCRT library path.
const arch = deps.config.target.result.cpu.arch;
const sdk = std.zig.WindowsSdk.find(b.allocator, arch) catch null;
if (sdk) |s| {
if (s.windows10sdk) |w10| {
const arch_str: []const u8 = switch (arch) {
.x86_64 => "x64",
.x86 => "x86",
.aarch64 => "arm64",
else => "x64",
};
const ucrt_lib_path = std.fmt.allocPrint(
b.allocator,
"{s}\\Lib\\{s}\\ucrt\\{s}",
.{ w10.path, w10.version, arch_str },
) catch null;
if (ucrt_lib_path) |path| {
lib.addLibraryPath(.{ .cwd_relative = path });
}
}
}
lib.linkSystemLibrary("libucrt");
}
// Get our debug symbols
const dsymutil: ?std.Build.LazyPath = dsymutil: {
if (!deps.config.target.result.os.tag.isDarwin()) {
break :dsymutil null;
}
const dsymutil = RunStep.create(b, "dsymutil");
dsymutil.addArgs(&.{"dsymutil"});
dsymutil.addFileArg(lib.getEmittedBin());
dsymutil.addArgs(&.{"-o"});
const output = dsymutil.addOutputFileArg("libghostty.dSYM");
break :dsymutil output;
};
return .{
.step = &lib.step,
.output = lib.getEmittedBin(),
.dsym = dsymutil,
};
}
pub fn initMacOSUniversal(
b: *std.Build,
original_deps: *const SharedDeps,
) !GhosttyLib {
const aarch64 = try initStatic(b, &try original_deps.retarget(
b,
Config.genericMacOSTarget(b, .aarch64),
));
const x86_64 = try initStatic(b, &try original_deps.retarget(
b,
Config.genericMacOSTarget(b, .x86_64),
));
const universal = LipoStep.create(b, .{
.name = "ghostty",
.out_name = "libghostty.a",
.input_a = aarch64.output,
.input_b = x86_64.output,
});
return .{
.step = universal.step,
.output = universal.output,
// You can't run dsymutil on a universal binary, you have to
// do it on the individual binaries.
.dsym = null,
};
}
pub fn install(self: *const GhosttyLib, name: []const u8) void {
const b = self.step.owner;
const lib_install = b.addInstallLibFile(self.output, name);
b.getInstallStep().dependOn(&lib_install.step);
}
pub fn installHeader(self: *const GhosttyLib) void {
const b = self.step.owner;
const header_install = b.addInstallHeaderFile(
b.path("include/ghostty.h"),
"ghostty.h",
);
b.getInstallStep().dependOn(&header_install.step);
}
|
