LLDB | LLDB aliases/regexes and Python scripts | Code Inspection library

lldb has three stages of customization for printing values of a given type. The simplest is "type format" which specifies the format to use (hex, chars, etc) to display scalar entities. The second is "type summary" which allows you to print a one-line string summary of the value. The third is "type synthetic" which allows you to present a value as some kind of structured object (e.g. making std::vector look like an vector of values rather than its internal form.)

You want to add a "type summary" for this type that parses the data and prints it as a human-readable string.

Install llvm with debug mode enabled:

By default, lldb treats functions in the std::: namespace the same way as functions without debug information, and auto-steps back out instead of stopping in the function.

For most users, the fact that you have source information for inlined stl functions is more an accident of the implementation than an indication of interest in those functions; and stepping into STL function bodies is disruptive and not helpful.

This behavior is controlled by the lldb setting target.process.thread.step-avoid-regex - if lldb steps into a function that matches this regex, lldb will auto-step out again. The default value is:

The support for Rust in the main-line lldb is incomplete. In particular, the expression parser is just the clang expression parser (which doesn't know about Rust). So it will only work on expressions that also parse as C expressions (and use the same calling conventions). And breakpoint conditions are just expressions evaluated when you stop.

There was an lldb fork with more full Rust support, but it doesn't seem to be actively maintained at present. There's a little more info here:

https://github.com/rust-lang/lldb/wiki

It sounds like there is possibly a bug with the pl_PL locale in NumberFormatter. I recommend reporting the issue to Apple. You can use the Feedback Assistant app on macOS.

You could technically implement workarounds, ie hardcoding a locale or trying to do your own formatting, but it's generally not good practice to force a specific format on all users. And implementing formatting on your own can become a rabbit hole of edges cases and be prone to errors.

The solution matt referenced from the question I linked in my original post turns out to work fine – just not in the simulator. It is:

When do you need to explicitly call std::move and when not in cpp?

In short, and technically precise words: Use std::move when you have an lvalue that you want to be an rvalue. More practically: You would want to do that when there is a copy that you want instead to be a move. Hence the name std::move.

In the example, you return an automatic variable. There is no copy that can be avoided by using std::move because in the special case of returning an automatic variable, there will be a move even from an lvalue.

Here I show the move constructor and the function that I thought would use it. It doesn't.

Just because there is a move in the abstract machine, doesn't necessarily mean that there would be a call to the move constructor. This is a good thing because doing nothing can potentially be faster than calling the move constructor.

This is known as (Named) Return Value Optimization. Or more generally copy elision. Using std::move inhibits this optimization, so not only is it unnecessary in this case, but it is also counter productive.

The issue seems to be the SO_REUSEADDR socket option, which ASIO by default sets. Setting this option itself succeeds, but causes the subsequent bind to fail.

Construct the acceptor with reuse_addr = false, then the binding should succeed: