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
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
|
# Copyright 2018-2024 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
load_lib gdb-python.exp
# Test CLI output styling.
standard_testfile
# Compile the test executable.
if {[build_executable "failed to build" $testfile $srcfile {debug macros}]} {
return -1
}
# The tests in this file are run multiple times with GDB's styles
# disabled one at a time. This variable is the style that is
# currently disabled.
set currently_disabled_style ""
# A wrapper around the 'style' function found in gdb-utils.exp,
# filter out requests for the disabled style.
proc limited_style { str style } {
global currently_disabled_style
if { $style != $currently_disabled_style } {
return [style $str $style]
}
return $str
}
# A wrapper around 'clean_restart' from gdb.exp, this performs the
# normal clean_restart, but then disables the currently disabled
# style.
proc clean_restart_and_disable { prefix args } {
global currently_disabled_style
with_test_prefix "$prefix" {
eval "clean_restart $args"
if { $currently_disabled_style != "" } {
set st $currently_disabled_style
gdb_test_no_output "set style $st background none"
gdb_test_no_output "set style $st foreground none"
gdb_test_no_output "set style $st intensity normal"
}
}
}
# The core of this test script. Run some tests of different aspects
# of GDB's styling.
#
# Within this proc always use LIMITED_STYLE instead of STYLE, and
# CLEAN_RESTART_AND_DISABLE instead of CLEAN_RESTART, this ensures
# that the test operates as expected as styles are disabled.
proc run_style_tests { } {
global testfile srcfile hex binfile
global currently_disabled_style decimal hex
with_ansi_styling_terminal {
# Restart GDB with the correct TERM variable setting, this
# means that GDB will enable styling.
clean_restart_and_disable "restart 1" ${binfile}
set readnow [readnow]
if {![runto_main]} {
return
}
# Check that the source highlighter has not stripped away the
# leading newlines.
set main_line [gdb_get_line_number "break here"]
gdb_test "list $main_line,$main_line" "return.*some_called_function.*"
gdb_test_no_output "set style enabled off"
set argv ""
gdb_test_multiple "frame" "frame without styling" {
-re -wrap "main \\(argc=.*, (argv=$hex.*)\\).*style\\.c:\[0-9\].*" {
set argv $expect_out(1,string)
pass $gdb_test_name
}
}
gdb_test_no_output "set style enabled on"
set main_expr [limited_style main function]
set base_file_expr [limited_style ".*style\\.c" file]
set line_expr [limited_style $decimal line-number]
set file_expr "$base_file_expr:$line_expr"
set arg_expr [limited_style "arg." variable]
# On some embedded targets that don't fully support argc/argv,
# argv may print as "0x0" or as an address with a symbol name
# following, so use a regexp general enough to match that and
# do not make assumptions about how long the address string is.
gdb_test "frame" \
[multi_line \
"#0\\s+$main_expr\\s+\\($arg_expr=$decimal,\\s+$arg_expr=$hex.*\\)\\s+at\\s+$file_expr" \
"$line_expr\\s+.*return.* break here .*"]
gdb_test "info breakpoints" "$main_expr at $file_expr.*"
gdb_test_no_output "set style sources off"
gdb_test "frame" \
"\r\n$line_expr\[^\033\]*break here.*" \
"frame without sources styling"
gdb_test_no_output "set style sources on"
gdb_test "break -q main" "file $base_file_expr.*"
gdb_test "print &main" " = .* [limited_style $hex address] <$main_expr>"
# Regression test for a bug where line-wrapping would occur at
# the wrong spot with styling. There were different bugs at
# different widths, so try two.
foreach width {20 30} {
set argv_len [string length $argv]
if { $argv_len == 0 } {
continue
}
# There was also a bug where the styling could be wrong in
# the line listing; this is why the words from the source
# code are spelled out in the final result line of the
# test.
set re0_styled \
[multi_line \
"#0\\s+$main_expr\\s+\\($arg_expr=$decimal,\\s+$arg_expr=$hex\\)" \
"\\s+at\\s+$file_expr" \
"$line_expr\\s+.*return.* break here .*"]
set re1_styled \
[multi_line \
"#0\\s+$main_expr\\s+\\($arg_expr=$decimal,\\s+" \
"\\s+$arg_expr=$hex.*\\)" \
"\\s+at\\s+$file_expr" \
"$line_expr\\s+.*return.* break here .*"]
set re2_styled \
[multi_line \
"#0\\s+$main_expr\\s+\\($arg_expr=.*" \
"\\s+$arg_expr=$hex.*\\)\\s+at\\s+$file_expr" \
"$line_expr\\s+.*return.* break here .*"]
# The length of the line containing argv containing:
# - 4 leading spaces
# - argv string
# - closing parenthesis
set line_len [expr 4 + $argv_len + 1]
if { $argv == "argv=0x0" && $width >= 27 } {
# Embedded target with no argv support.
# #0 main (argc=0, argv=0x0)
set re_styled $re0_styled
} elseif { $line_len > $width } {
# At on the next line.
set re_styled $re1_styled
} else {
# At on the same line as argv.
set re_styled $re2_styled
}
# Override width for the duration of the command, letting
# GDB reset back to 0. Doing this in the loop rather than
# after, avoids trying to do "set width 30" while width is
# 20, which causes horizontal scrolling in the case that
# the fallback stub-termcap.c is used:
# ^M<et width 30^M
# (gdb) FAIL: gdb.base/style.exp: all styles enabled: set width 30
gdb_test "with width $width -- frame" $re_styled \
"frame when width=$width"
}
set macro_line [gdb_get_line_number "\#define SOME_MACRO"]
gdb_test "info macro SOME_MACRO" \
"Defined at $base_file_expr:$macro_line\r\n#define SOME_MACRO 23"
gdb_test_no_output "set width 0"
# If disassembler styling is being done by the Python pygments
# module, then we can't be sure how the 'some_called_function'
# symbol will be styled. However, if pygments is not being
# used then we can know how the symbol name will be styled.
set main [limited_style main function]
if { $::python_disassembly_styling } {
set func "some_called_function"
} else {
set func [limited_style some_called_function function]
}
# Somewhere should see the call to the function.
gdb_test "disassemble main" \
[concat "Dump of assembler code for function $main:.*" \
"[limited_style $hex address].*$func.*"]
set ifield [limited_style int_field variable]
set sfield [limited_style string_field variable]
set efield [limited_style e_field variable]
set evalue [limited_style VALUE_TWO variable]
set lhs [limited_style "\\\$$decimal" variable]
gdb_test "print struct_value" \
"$lhs = \{$ifield = 23,.*$sfield = .*,.*$efield = $evalue.*"
set ffield [limited_style field variable]
set cstart [string_to_regexp "/* XXX "]
set cend [string_to_regexp " */"]
set p1field [limited_style "$cstart.*$decimal.*-bit.*padding.*$cend" \
highlight]
set p2field [limited_style "$cstart.*$decimal.*-byte.*padding.*$cend" \
highlight]
gdb_test "ptype/o just_bitfield_value" \
[multi_line \
".* type = struct just_bitfield {" \
".* unsigned int $ffield : 3;" \
"$p1field" \
"$p2field" \
"" \
".* total size.*: *$decimal *$cend" \
" *}.*"]
set address_style_expr [limited_style ".*\".*address.*\".*style.*" address]
set color "blue"
if { $currently_disabled_style == "address" } {
set color "none"
}
gdb_test "show style address foreground" \
"The ${address_style_expr} foreground color is: ${color}" \
"style name and style word styled using its own style in show style"
set aliases_expr [limited_style ".*aliases.*" command]
set breakpoints_expr [limited_style ".*breakpoints.*" command]
gdb_test "help" \
[multi_line \
"List of classes of commands:" \
"" \
"${aliases_expr} -- User-defined aliases of other commands\." \
"${breakpoints_expr} -- Making program stop at certain points\." \
".*" \
] \
"help classes of commands styled with command"
set taas_expr [limited_style ".*taas.*" command]
set tfaas_expr [limited_style ".*tfaas.*" command]
set cut_for_thre_expr [limited_style "cut for 'thre" highlight]
gdb_test "apropos -v cut for 'thre" \
[multi_line \
"" \
"${taas_expr}" \
"Apply a command to all .*" \
"Usage:.*" \
"short${cut_for_thre_expr}ad apply.*" \
"" \
"${tfaas_expr}" \
"Apply a command to all .*" \
"Usage:.*" \
"short${cut_for_thre_expr}ad apply.*" \
]
clean_restart_and_disable "restart 2"
set quoted [string_to_regexp $binfile]
set pass_re "Reading symbols from [limited_style $quoted file]\.\.\."
if { $readnow } {
set pass_re \
[multi_line \
$pass_re \
"Expanding full symbols from [limited_style $quoted file]\.\.\."]
}
gdb_test "file $binfile" \
$pass_re \
"filename is styled when loading symbol file"
gdb_test "pwd" "Working directory [limited_style .*? file].*"
gdb_test_no_output "set print repeat 3"
gdb_test "print {0,0,0,0,0,0,0,0}" \
" = \\{0 [limited_style {<repeats.*8.*times>} metadata]\\}"
gdb_test "show logging file" \
"The current logfile is \"[limited_style .*? file]\"\\..*"
# Check warnings are styled by setting a rubbish data
# directory.
gdb_test "set data-directory Makefile" \
"warning: [limited_style .*? file] is not a directory\\..*"
gdb_test "show data-directory" \
"GDB's data directory is \"[limited_style .*? file]\"\\..*"
# Check that deprecation styles command names.
gdb_test_no_output "maintenance deprecate p \"new_p\"" \
"maintenance deprecate p \"new_p\" /1/"
gdb_test "p 5" \
"Warning: '[limited_style p command]', an alias for the command '[limited_style print command]', is deprecated.*Use '[limited_style new_p command]'.*" \
"p deprecated warning, with replacement"
# Check that the version string is styled in the output of 'show
# version', and that this styling can be disabled.
set vers [style "GNU gdb.*" version]
set url [limited_style "http:.*html" file]
gdb_test "show version" "${vers}.*<$url>.*" \
"'show version' is styled"
}
}
# Check that disassembler styling can be disabled. The function that
# we are disassembling has some minimal styling applied even if the
# Python pygments module is not available, so, when we disable
# disassembler styling, we should always see a change in output.
proc test_disable_disassembler_styling { } {
save_vars { env(TERM) env(NO_COLOR) } {
# We need an ANSI-capable terminal to get the output.
setenv TERM ansi
setenv NO_COLOR ""
# Restart GDB with the correct TERM variable setting, this
# means that GDB will enable styling.
clean_restart_and_disable "restart 3" $::binfile
set styled_hex [limited_style $::hex address]
set main [limited_style main function]
foreach_with_prefix libopcodes { on off } {
set command_failed false
gdb_test_multiple "maint set libopcodes-styling enabled ${libopcodes}" "" {
-re "^maint set libopcodes-styling enabled ${libopcodes}\r\n" {
exp_continue
}
-re "Use of libopcodes styling not supported on architecture \[^\r\n\]+\r\n" {
set command_failed true
exp_continue
}
-re "^$::gdb_prompt $" {
gdb_assert { !$command_failed || [string equal $libopcodes "on"] } \
$gdb_test_name
}
}
if { $libopcodes == "on" && $command_failed } {
# We tried to turn on libopcodes disassembler styling,
# but this is not supported on this architecture.
continue
}
foreach_with_prefix disasm_styling { on off } {
gdb_test_no_output "set style disassembler enabled ${disasm_styling}"
if { $libopcodes == "off" && $disasm_styling == "on" \
&& !$::python_disassembly_styling} {
# We have libopcodes based styling off, but
# disassembler styling turned on. We're expecting
# Python Pygments to be used to add styling.
#
# However, if we get here, then we don't have the
# Pygments module, so skip this test.
continue
}
set saw_header_line false
set saw_styled_output_line false
set saw_unstyled_output_line false
gdb_test_multiple "disassemble main" "" {
-re "disassemble main\r\n" {
exp_continue
}
-re "^Dump of assembler code for function $main:" {
set saw_header_line true
exp_continue
}
-re "^\\s+${styled_hex}\\s+<\[^>\]+>:\\s+\[^\r\n\033\]+\r\n" {
set saw_unstyled_output_line true
exp_continue
}
-re "^\\s+${styled_hex}\\s+<\[^>\]+>:\\s+\[^\r\n\]+\033\[^\r\n\]+\r\n" {
set saw_styled_output_line true
exp_continue
}
-re "^End of assembler dump\\.\r\n" {
exp_continue
}
-re "^$::gdb_prompt $" {
gdb_assert { $saw_header_line }
if { $disasm_styling } {
gdb_assert { $saw_styled_output_line }
gdb_assert { !$saw_unstyled_output_line }
} else {
gdb_assert { !$saw_styled_output_line }
gdb_assert { $saw_unstyled_output_line }
}
}
}
}
}
}
}
# Disassemble a single isntruction at the start of main, then strip
# off the address and symbol information, returning just the
# disassembled instruction part.
proc get_single_disassembled_insn {} {
set disasm_line [capture_command_output "x/1i *main" ""]
regexp "^\[^:\]+:\\s*(.*)$" $disasm_line whole_match insn
return $insn
}
# Check that, if the user is using Python Pygments for disassembler
# styling, then the styling correctly switches off when an error is
# detected in the Python code.
proc test_disassembler_error_handling { } {
# This test requires the Python Pygments module to be installed
# and used by GDB.
if { !$::python_disassembly_styling } {
return
}
save_vars { env(TERM) env(NO_COLOR) } {
# We need an ANSI-capable terminal to get the output.
setenv TERM ansi
setenv NO_COLOR ""
# Restart GDB with the correct TERM variable setting, this
# means that GDB will enable styling.
clean_restart_and_disable "restart 4" $::binfile
# Disable use of libopcodes for styling. As this function is
# only called when Python Pygments module is available, we
# should now be using that module to style the disassembler
# output.
gdb_test_no_output "maint set libopcodes-styling enabled off"
# Disassemble a single instruction and ensure that the output
# has styling markers in it.
set insn_before [get_single_disassembled_insn]
gdb_assert { [regexp "\033" $insn_before] } \
"have style markers when Pygments is working fine"
# Now replace the standard function that colorizes the
# disassembler output, with a new function that always returns
# None, this should cause GDB to stop using the Pygments
# module for disassembler styling.
gdb_py_test_silent_cmd \
[multi_line_input \
"python" \
"def replacement_colorize_disasm(content,gdbarch):" \
" return None" \
"gdb.styling.colorize_disasm = replacement_colorize_disasm" \
"end"] \
"setup replacement colorize_disasm function" \
true
set insn_after [get_single_disassembled_insn]
gdb_assert { ![regexp "\033" $insn_after] } \
"have no style markers when Pygments is broken"
}
}
# A separate test from the above as the styled text this checks can't
# currently be disabled (the text is printed too early in GDB's
# startup process).
proc test_startup_version_string { } {
gdb_exit
save_vars { ::INTERNAL_GDBFLAGS } {
set ::INTERNAL_GDBFLAGS [string map {"-q" ""} $::INTERNAL_GDBFLAGS]
gdb_spawn
}
# Deliberate use of base STYLE proc here as the style of the
# startup version string can't (currently) be controlled.
set vers [style "GNU gdb.*" version]
gdb_test "" "${vers}.*" "version is styled at startup"
}
# Check to see if the Python styling of disassembler output is
# expected or not, this styling requires Python support in GDB, and
# the Python pygments module to be available.
clean_restart ${binfile}
if {[allow_python_tests] && [gdb_py_module_available "pygments"]} {
set python_disassembly_styling true
} else {
set python_disassembly_styling false
}
# Run tests with all styles in their default state.
with_test_prefix "all styles enabled" {
run_style_tests
}
# Now, for each style in turn. Disable that style only and run the
# test again. Things in that style should NOT now be styled.
foreach style { command title file function highlight variable \
address metadata } {
set currently_disabled_style $style
with_test_prefix "disable style $style" {
run_style_tests
}
}
# Check that the disassembler styling can be disabled.
test_disable_disassembler_styling
# Check that GDB handles an error in the Python Pygments disassembly
# styling code.
test_disassembler_error_handling
# Finally, check the styling of the version string during startup.
test_startup_version_string
|