-
Notifications
You must be signed in to change notification settings - Fork 0
/
rules.bzl
212 lines (179 loc) · 5.58 KB
/
rules.bzl
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
""" Rules """
load("@bazel_skylib//rules:native_binary.bzl", "native_binary")
def cargo_flash(name, file, chip, bin = False):
"""Use cargo-flash to load an elf file onto a chip
To find the supported chip targets use the following command
bazel run @rust_embedded//:cargo-flash -- --list-chips
Args:
name: the target name as a string
file: the label to the elf file
chip: string, the target chip
bin: set to True the file is a binary, False by default
"""
file_type = "bin" if bin else "elf"
tool = "@rust_embedded//:cargo-flash"
args = [
"--chip {}".format(chip),
"--{} $(execpath {})".format(file_type, file),
]
script = """
#! /usr/bin/env bash
set -euo pipefail
bash -c \\"$(execpath {}) {}\\"
""".format(tool, " ".join(args))
native.genrule(
name = name,
srcs = [file],
outs = [name + ".sh"],
executable = True,
tools = [tool],
cmd = """echo "{}" > $@""".format(script),
)
def cargo_embed_config(
name,
protocol = "Swd",
flash = "true",
reset = "true",
halt = "true",
log_level = "ERROR",
gdb_enabled = "false",
gdb_connection_string = "0.0.0.0:3333"):
""" generate a custom cargo-embed config
Args:
name: the config label
protocol: [Swd|Jtag]
flash: [true|false]
reset: [true|false]
halt: [true|false]
log_level: [OFF|ERROR|WARN|DEBUG]
gdb_enabled: [true|false]
gdb_connection_string: the server address
"""
config = """
[default.probe]
protocol = \\"{}\\"
[default.flashing]
enabled = {}
[default.reset]
enabled = {}
halt_afterwards = {}
[default.general]
log_level = \\"{}\\"
[default.gdb]
enabled = {}
gdb_connection_string = \\"{}\\"
""".format(protocol, flash, reset, halt, log_level, gdb_enabled, gdb_connection_string)
native.genrule(
name = name,
outs = [name + ".toml"],
cmd = """echo "{}" > $@""".format(config),
)
def cargo_embed(name, file, chip, config = None):
"""Use cargo-embed with a custom config
You can flash the probe, start a gdb server and
more using the cargo-embed binary
Args:
name: the target name as a string
file: the label to the elf file
chip: string, the target chip
config: the label of a custom config file
"""
srcs = [file]
tool = "@rust_embedded//:cargo-embed"
args = [
"--chip {}".format(chip),
"--artifact-path $(execpath {})".format(file),
]
if config:
srcs.append(config)
args.append("--custom-config $(execpath {})".format(config))
script = """
#! /usr/bin/env bash
set -euo pipefail
bash -c \\"$(execpath {}) {}\\"
""".format(tool, " ".join(args))
native.genrule(
name = name,
srcs = srcs,
outs = [name + ".sh"],
executable = True,
tools = [tool],
cmd = """echo "{}" > $@""".format(script),
)
def gdb_server(name, file, chip, log_level = "ERROR", address = "0.0.0.0", port = "3333"):
""" Launch a gdb server using cargo embed
Args:
name: the name of the console target
file: binary to debug
chip: chip setting of cargo embed
log_level: log level of cargo embed
address: IP address of the GDB server
port: Port of the GDB serverV
"""
config = name + "_config"
cargo_embed_config(
name = config,
gdb_enabled = "true",
gdb_connection_string = "{}:{}".format(address, port),
log_level = log_level,
)
cargo_embed(
name = name,
file = file,
chip = chip,
config = config,
)
def gdb_console(name, file, chip, gdb, gdb_args = [], log_level = "ERROR", address = "0.0.0.0", port = "3333"):
""" Launch a gdb console using a custom gdb executable
Args:
name: the name of the console target
file: binary to debug
chip: chip setting of cargo embed
gdb: label to the gdb file binary
gdb_args: list of arguments to gdb
log_level: log level of cargo embed
address: IP address of the GDB server
port: Port of the GDB serverV
"""
config = name + "_config"
server_binary = name + "_gdb_server"
gdb_binary = name + "_gdb_binary"
gdb_default_args = [
"-ex 'file $(execpath {})'".format(file),
"-ex 'target extended-remote {}:{}'".format(address, port),
]
for arg in gdb_default_args:
if arg not in gdb_args:
gdb_args.append(arg)
escape = {"\'": "\\'"}
for arg in gdb_args:
for key in escape:
arg.replace(key, escape.get(key))
script = """
#! /usr/bin/env bash
set -euo pipefail
trap 'killall cargo_bin_cargo_embed' EXIT SIGINT SIGTERM SIGHUP
bash -c \\"$(execpath {})\\" 2> /dev/null &
bash -c \\"$(execpath {}) {}\\"
""".format(server_binary, gdb_binary, " ".join(gdb_args))
gdb_server(
name = server_binary,
file = file,
chip = chip,
address = address,
port = port,
log_level = log_level,
)
native_binary(
name = gdb_binary,
src = gdb,
out = name + "_gdb",
)
native.genrule(
name = name,
srcs = [server_binary, file],
outs = [name + "_gdb_console.sh"],
tools = [gdb_binary],
cmd = """echo "{}" > $@""".format(script),
executable = True,
)