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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
|
"""Bazel implementations of standard rules."""
load("@bazel_gazelle//:def.bzl", _gazelle = "gazelle")
load("@bazel_skylib//rules:build_test.bzl", _build_test = "build_test")
load("@bazel_skylib//:bzl_library.bzl", _bzl_library = "bzl_library")
load("@bazel_tools//tools/cpp:cc_flags_supplier.bzl", _cc_flags_supplier = "cc_flags_supplier")
load("@io_bazel_rules_go//go:def.bzl", "GoLibrary", _go_binary = "go_binary", _go_context = "go_context", _go_embed_data = "go_embed_data", _go_library = "go_library", _go_path = "go_path", _go_test = "go_test")
load("@io_bazel_rules_go//proto:def.bzl", _go_grpc_library = "go_grpc_library", _go_proto_library = "go_proto_library")
load("@rules_cc//cc:defs.bzl", _cc_binary = "cc_binary", _cc_library = "cc_library", _cc_proto_library = "cc_proto_library", _cc_test = "cc_test")
load("@rules_pkg//:pkg.bzl", _pkg_deb = "pkg_deb", _pkg_tar = "pkg_tar")
load("@com_github_grpc_grpc//bazel:cc_grpc_library.bzl", _cc_grpc_library = "cc_grpc_library")
build_test = _build_test
bzl_library = _bzl_library
cc_library = _cc_library
cc_flags_supplier = _cc_flags_supplier
cc_proto_library = _cc_proto_library
cc_test = _cc_test
cc_toolchain = "@bazel_tools//tools/cpp:current_cc_toolchain"
gazelle = _gazelle
go_embed_data = _go_embed_data
go_path = _go_path
gtest = "@com_google_googletest//:gtest"
grpcpp = "@com_github_grpc_grpc//:grpc++"
gbenchmark = "@com_google_benchmark//:benchmark"
loopback = "//tools/bazeldefs:loopback"
pkg_deb = _pkg_deb
pkg_tar = _pkg_tar
py_binary = native.py_binary
rbe_platform = native.platform
rbe_toolchain = native.toolchain
vdso_linker_option = "-fuse-ld=gold "
def short_path(path):
return path
def proto_library(name, has_services = None, **kwargs):
native.proto_library(
name = name,
**kwargs
)
def cc_grpc_library(name, **kwargs):
_cc_grpc_library(name = name, grpc_only = True, **kwargs)
def _go_proto_or_grpc_library(go_library_func, name, **kwargs):
deps = [
dep.replace("_proto", "_go_proto")
for dep in (kwargs.pop("deps", []) or [])
]
go_library_func(
name = name + "_go_proto",
importpath = "gvisor.dev/gvisor/" + native.package_name() + "/" + name + "_go_proto",
proto = ":" + name + "_proto",
deps = deps,
**kwargs
)
def go_proto_library(name, **kwargs):
_go_proto_or_grpc_library(_go_proto_library, name, **kwargs)
def go_grpc_and_proto_libraries(name, **kwargs):
_go_proto_or_grpc_library(_go_grpc_library, name, **kwargs)
def cc_binary(name, static = False, **kwargs):
"""Run cc_binary.
Args:
name: name of the target.
static: make a static binary if True
**kwargs: the rest of the args.
"""
if static:
# How to statically link a c++ program that uses threads, like for gRPC:
# https://gcc.gnu.org/legacy-ml/gcc-help/2010-05/msg00029.html
if "linkopts" not in kwargs:
kwargs["linkopts"] = []
kwargs["linkopts"] += [
"-static",
"-lstdc++",
"-Wl,--whole-archive",
"-lpthread",
"-Wl,--no-whole-archive",
]
_cc_binary(
name = name,
**kwargs
)
def go_binary(name, static = False, pure = False, x_defs = None, **kwargs):
"""Build a go binary.
Args:
name: name of the target.
static: build a static binary.
pure: build without cgo.
x_defs: additional definitions.
**kwargs: rest of the arguments are passed to _go_binary.
"""
if static:
kwargs["static"] = "on"
if pure:
kwargs["pure"] = "on"
_go_binary(
name = name,
x_defs = x_defs,
**kwargs
)
def go_importpath(target):
"""Returns the importpath for the target."""
return target[GoLibrary].importpath
def go_library(name, **kwargs):
_go_library(
name = name,
importpath = "gvisor.dev/gvisor/" + native.package_name(),
**kwargs
)
def go_test(name, pure = False, library = None, **kwargs):
"""Build a go test.
Args:
name: name of the output binary.
pure: should it be built without cgo.
library: the library to embed.
**kwargs: rest of the arguments to pass to _go_test.
"""
if pure:
kwargs["pure"] = "on"
if library:
kwargs["embed"] = [library]
_go_test(
name = name,
**kwargs
)
def go_rule(rule, implementation, **kwargs):
"""Wraps a rule definition with Go attributes.
Args:
rule: rule function (typically rule or aspect).
implementation: implementation function.
**kwargs: other arguments to pass to rule.
Returns:
The result of invoking the rule.
"""
attrs = kwargs.pop("attrs", dict())
attrs["_go_context_data"] = attr.label(default = "@io_bazel_rules_go//:go_context_data")
attrs["_stdlib"] = attr.label(default = "@io_bazel_rules_go//:stdlib")
toolchains = kwargs.get("toolchains", []) + ["@io_bazel_rules_go//go:toolchain"]
return rule(implementation, attrs = attrs, toolchains = toolchains, **kwargs)
def go_test_library(target):
if hasattr(target.attr, "embed") and len(target.attr.embed) > 0:
return target.attr.embed[0]
return None
def go_context(ctx, goos = None, goarch = None, std = False):
"""Extracts a standard Go context struct.
Args:
ctx: the starlark context (required).
goos: the GOOS value.
goarch: the GOARCH value.
std: ignored.
Returns:
A context Go struct with pointers to Go toolchain components.
"""
# We don't change anything for the standard library analysis. All Go files
# are available in all instances. Note that this includes the standard
# library sources, which are analyzed by nogo.
go_ctx = _go_context(ctx)
if goos == None:
goos = go_ctx.sdk.goos
elif goos != go_ctx.sdk.goos:
fail("Internal GOOS (%s) doesn't match GoSdk GOOS (%s)." % (goos, go_ctx.sdk.goos))
if goarch == None:
goarch = go_ctx.sdk.goarch
elif goarch != go_ctx.sdk.goarch:
fail("Internal GOARCH (%s) doesn't match GoSdk GOARCH (%s)." % (goarch, go_ctx.sdk.goarch))
return struct(
go = go_ctx.go,
env = go_ctx.env,
nogo_args = [],
stdlib_srcs = go_ctx.sdk.srcs,
runfiles = depset([go_ctx.go] + go_ctx.sdk.srcs + go_ctx.sdk.tools + go_ctx.stdlib.libs),
goos = go_ctx.sdk.goos,
goarch = go_ctx.sdk.goarch,
tags = go_ctx.tags,
)
def select_arch(amd64 = "amd64", arm64 = "arm64", default = None, **kwargs):
values = {
"@bazel_tools//src/conditions:linux_x86_64": amd64,
"@bazel_tools//src/conditions:linux_aarch64": arm64,
}
if default:
values["//conditions:default"] = default
return select(values, **kwargs)
def select_system(linux = ["__linux__"], **kwargs):
return linux # Only Linux supported.
def select_goarch():
return select_arch(arm64 = "arm64", amd64 = "amd64")
def select_goos():
return select_system(linux = "linux")
def default_installer():
return None
def default_net_util():
return [] # Nothing needed.
def coreutil():
return [] # Nothing needed.
|
