[WIP] objdump: UTF-8 jump visuzalization

  Hello,

I've just modified the objdump to render the jump visualization using 
UTF-8 characters. I attach the patch and a screenshot of the new output 
with extended color enabled.

I send this message to ask whether this feature has an opportunity to be 
added to the binutils. My patch is not finished – it is required to add 
some other characters to the output to make the output cleaner, also 
autodetection of UTF-8 environment (and enabling the UTF-8 on such 
machines) should be added. Also, fine-tuning the output (such as 
changing arrow shape) for user's needs would be a nice feature.

Thank you.
Jiří Wolker

Output of the objdump, in plain text:

00000000000001ed <print_msg>:
  1ed:	          50                   	push   %rax
  1ee:	          52                   	push   %rdx
  1ef:	          56                   	push   %rsi
  1f0:	   ╭────→ ac                   	lods   %ds:(%rsi),%al
  1f1:	   │      08 c0                	or     %al,%al
  1f3:	   │  ╭─  74 04                	je     1f9 <print_msg+0xc>
  1f5:	   │  │   e6 e9                	out    %al,$0xe9
  1f7:	   ╰──│─  eb f7                	jmp    1f0 <print_msg+0x3>
  1f9:	      ╰─→ 8b 34 24             	mov    (%rsp),%esi
  1fc:	╭───────→ 66 ba fd 03          	mov    $0x3fd,%dx
  200:	│         ec                   	in     (%dx),%al
  201:	│         24 20                	and    $0x20,%al
  203:	├───────  74 f7                	je     1fc <print_msg+0xf>
  205:	│         66 ba f8 03          	mov    $0x3f8,%dx
  209:	│         ac                   	lods   %ds:(%rsi),%al
  20a:	│         08 c0                	or     %al,%al
  20c:	│     ╭─  74 07                	je     215 <print_msg+0x28>
  20e:	│     │   3c 0a                	cmp    $0xa,%al
  210:	│  ╭──│─  74 07                	je     219 <print_msg+0x2c>
  212:	│  │  │   ee                   	out    %al,(%dx)
  213:	├──│──│─  eb e7                	jmp    1fc <print_msg+0xf>
  215:	│  │  ╰─→ 5e                   	pop    %rsi
  216:	│  │      5a                   	pop    %rdx
  217:	│  │      58                   	pop    %rax
  218:	│  │      c3                   	ret
  219:	│  ╰────→ b0 0d                	mov    $0xd,%al
  21b:	│         ee                   	out    %al,(%dx)
  21c:	│     ╭─→ 66 ba fd 03          	mov    $0x3fd,%dx
  220:	│     │   ec                   	in     (%dx),%al
  221:	│     │   24 20                	and    $0x20,%al
  223:	│     ╰─  74 f7                	je     21c <print_msg+0x2f>
  225:	│         66 ba f8 03          	mov    $0x3f8,%dx
  229:	│         b0 0a                	mov    $0xa,%al
  22b:	│         ee                   	out    %al,(%dx)
  22c:	╰───────  eb ce                	jmp    1fc <print_msg+0xf>
  

On 11.06.2024 20:14, Jiří Wolker wrote:
> I've just modified the objdump to render the jump visualization using 
> UTF-8 characters. I attach the patch and a screenshot of the new output 
> with extended color enabled.
> 
> I send this message to ask whether this feature has an opportunity to be 
> added to the binutils.

I see no reason why it shouldn't be acceptable once finished.

> My patch is not finished – it is required to add 
> some other characters to the output to make the output cleaner, also 
> autodetection of UTF-8 environment (and enabling the UTF-8 on such 
> machines) should be added. Also, fine-tuning the output (such as 
> changing arrow shape) for user's needs would be a nice feature.

Right, even the rendering in the browser on the mailing list archive
shows, like at least my email UI, that ...

> Output of the objdump, in plain text:
> 
> 00000000000001ed <print_msg>:
>   1ed:	          50                   	push   %rax
>   1ee:	          52                   	push   %rdx
>   1ef:	          56                   	push   %rsi
>   1f0:	   ╭────→ ac                   	lods   %ds:(%rsi),%al

... arrows aren't quite smooth. Unlike in the picture you had attached.

As to selection of characters, I'd like to note that in the viewer I'm
using to look at your patch as well as in one of the the two consoles I
tried, I can't properly see two of the characters, apparently due to
limitations of the font used. While use of the feature is optional
anyway, it might be nice if characters chosen were covered by a wide
range of commonly used fonts (including ones specifically aiming at use
for console output, which I've often found to support more limited sets).

As to the new command line option: I think the way you have it would
end up somewhat ambiguous if both it and the original option were used.
Instead I think you want to make this a new sub-option of
--visualize-jumps, i.e. --visualize-jumps=utf8. Further, just to
mention it because you don't say so above, please don't forget to also
adjust doc/binutils.texi.

Jan

>   1f1:	   │      08 c0                	or     %al,%al
>   1f3:	   │  ╭─  74 04                	je     1f9 <print_msg+0xc>
>   1f5:	   │  │   e6 e9                	out    %al,$0xe9
>   1f7:	   ╰──│─  eb f7                	jmp    1f0 <print_msg+0x3>
>   1f9:	      ╰─→ 8b 34 24             	mov    (%rsp),%esi
>   1fc:	╭───────→ 66 ba fd 03          	mov    $0x3fd,%dx
>   200:	│         ec                   	in     (%dx),%al
>   201:	│         24 20                	and    $0x20,%al
>   203:	├───────  74 f7                	je     1fc <print_msg+0xf>
>   205:	│         66 ba f8 03          	mov    $0x3f8,%dx
>   209:	│         ac                   	lods   %ds:(%rsi),%al
>   20a:	│         08 c0                	or     %al,%al
>   20c:	│     ╭─  74 07                	je     215 <print_msg+0x28>
>   20e:	│     │   3c 0a                	cmp    $0xa,%al
>   210:	│  ╭──│─  74 07                	je     219 <print_msg+0x2c>
>   212:	│  │  │   ee                   	out    %al,(%dx)
>   213:	├──│──│─  eb e7                	jmp    1fc <print_msg+0xf>
>   215:	│  │  ╰─→ 5e                   	pop    %rsi
>   216:	│  │      5a                   	pop    %rdx
>   217:	│  │      58                   	pop    %rax
>   218:	│  │      c3                   	ret
>   219:	│  ╰────→ b0 0d                	mov    $0xd,%al
>   21b:	│         ee                   	out    %al,(%dx)
>   21c:	│     ╭─→ 66 ba fd 03          	mov    $0x3fd,%dx
>   220:	│     │   ec                   	in     (%dx),%al
>   221:	│     │   24 20                	and    $0x20,%al
>   223:	│     ╰─  74 f7                	je     21c <print_msg+0x2f>
>   225:	│         66 ba f8 03          	mov    $0x3f8,%dx
>   229:	│         b0 0a                	mov    $0xa,%al
>   22b:	│         ee                   	out    %al,(%dx)
>   22c:	╰───────  eb ce                	jmp    1fc <print_msg+0xf>
>
  

Dne 12. 06. 24 v 9:33 Jan Beulich napsal(a):
> On 11.06.2024 20:14, Jiří Wolker wrote:
>> I've just modified the objdump to render the jump visualization using
>> UTF-8 characters. I attach the patch and a screenshot of the new output
>> with extended color enabled.
>>
>> I send this message to ask whether this feature has an opportunity to be
>> added to the binutils.
> 
> I see no reason why it shouldn't be acceptable once finished.

That's nice. I really like box drawing characters. :)

I'll finish this probably in this week.

A question: Do we want to have UTF-8 characters in binutils
             source code?

> Right, even the rendering in the browser on the mailing list archive
> shows, like at least my email UI, that ...
> 
>> Output of the objdump, in plain text:
>>
>> 00000000000001ed <print_msg>:
>>    1ed:	          50                   	push   %rax
>>    1ee:	          52                   	push   %rdx
>>    1ef:	          56                   	push   %rsi
>>    1f0:	   ╭────→ ac                   	lods   %ds:(%rsi),%al
> 
> ... arrows aren't quite smooth. Unlike in the picture you had attached.
> 
> As to selection of characters, I'd like to note that in the viewer I'm
> using to look at your patch as well as in one of the the two consoles I
> tried, I can't properly see two of the characters, apparently due to
> limitations of the font used. While use of the feature is optional
> anyway, it might be nice if characters chosen were covered by a wide
> range of commonly used fonts (including ones specifically aiming at use
> for console output, which I've often found to support more limited sets).

Of course. I plan to add a way to configure the arrows (probably via 
environment variable) to custom characters. I show the “smooth” and 
connected arrows that have some fonts targeting for terminals such as 
the font Terminus in the screenshot. I will change it to plain ASCII “>” 
or try out “▶” (example: ─▶) for the default value, since many (nearly 
all) fonts have quite illegible arrows or they are misaligned with box 
drawing characters or look broken when rendered in small sizes using 
antialiasing.

Also, I want to extend the jump rendering to allow adding “guiding” 
arrows to the lines when they are long etc.

Rendering T-shaped lines is currently mostly broken. I need to extend 
the rendering logic.

> As to the new command line option: I think the way you have it would
> end up somewhat ambiguous if both it and the original option were used.
> Instead I think you want to make this a new sub-option of
> --visualize-jumps, i.e. --visualize-jumps=utf8. Further, just to
> mention it because you don't say so above, please don't forget to also
> adjust doc/binutils.texi.
I plan to change it into an sub-option (+ environment var), but it needs 
slightly extending the parsing routine to allow combining it with color 
settings.

I would also like to have an environment variable controlling the color 
rendering, just like ‘ls’ has ‘LS_COLORS’. I do not like specifying 
these rather long options all the time and redefining/aliasing objdump 
in shell rc file is useless when objdump is invoked by other tools.

I'll add the environment variable support in a separate patch.

jwo
  

On 12.06.2024 09:48, Jiří Wolker wrote:
> Dne 12. 06. 24 v 9:33 Jan Beulich napsal(a):
>> On 11.06.2024 20:14, Jiří Wolker wrote:
>>> I've just modified the objdump to render the jump visualization using
>>> UTF-8 characters. I attach the patch and a screenshot of the new output
>>> with extended color enabled.
>>>
>>> I send this message to ask whether this feature has an opportunity to be
>>> added to the binutils.
>>
>> I see no reason why it shouldn't be acceptable once finished.
> 
> That's nice. I really like box drawing characters. :)
> 
> I'll finish this probably in this week.
> 
> A question: Do we want to have UTF-8 characters in binutils
>              source code?

I see no reason why not. C99 compilers are, afaict, supposed to be dealing
fine with them.

Jan