demangle | demangle C symbole | Compiler library

The System V psABI for x86-64 requires sufficiently large arrays and variable-length arrays to be aligned to at least 16 bytes so that they are correctly aligned for SSE operations.

As @PeterCordes explains under this answer, there are also further reasons to keep the stack aligned to 16, although that wouldn't matter for the specific function you are giving as an example.

Note however that variable-length arrays are only supported in C++ as compiler-specific extension in the first place. They are not allowed in standard ISO C++, but are supported in C since C99.

For reference you can find links to the ABI specification (draft) here. The requirement is given in section 3.1.2 under the heading "Aggregates and Unions".

After lots of trial and error I found a working solution. It's a bit strange, but I had to enable Flipper. I did not find a way without it.

Thanks to this answer: https://github.com/facebook/react-native/issues/31179#issuecomment-831932941 I found out about fixing Pods.

This is my Podfile now:

UPDATE: This is fixed on XCode 13.3. Please update to that version. If you don't want to update, I will leave my answer below.

I also had the same issue with my app where users reported random crashes on iOS 14 and my crash log looked very similar to yours. The main line that helped me find the solution was __swift_instantiateConcreteTypeFromMangledName (which is on line 6 of your crash report and line 7 on mine).

My crash report from simulator:

I know very little about the ctre library so I've probably used some clumsy constructs below, but it's hopefully good enough to get somewhere. I've commented inline to explain what it's doing.

For one thing, you are not calling __cxa_demangle correctly. Documentation says:

output_buffer
A region of memory, allocated with malloc, of *length bytes, into which the demangled name is stored. If output_buffer is not long enough, it is expanded using realloc. output_buffer may instead be NULL; in that case, the demangled name is placed in a region of memory allocated with malloc.

You are passing a stack buffer instead. Get rid of it (and the pointless memset), and do this instead:

How does startup code can know the maximum depth of call stack?

It doesn't.

In most common implementation, the size of the stack is constant.

If the program exceeds the constant sized stack, that is called a stack overflow. This is why you must avoid creating large objects (which are typically, but not necessarily, arrays) in automatic storage, and why you must avoid recursion with linear depth (such as recursive linked list algorithms).

So exactly how much memory is allocated for call stack?

On most desktop/server systems it's configurable, and defaults to one to few megabytes. It can be much less on embedded systems.

This is exiting with SIGSEGV when index is 900. But surprisingly not when index is 901.

In both cases, the behaviour of the program is undefined.

Is it possible to know the allocated stack size?

Yes. You can read the documentation of the target system. If you intend to write a portable program, then you must assume the minimum of all target systems. For desktop/server, 1 megabyte that I mentioned is reasonable.

There is no standard way to acquire the size within C++.

Does it mean that in general, it is necessary but not sufficient for the producer and the consumer of a library to use the same C++ version (and the > same ABI) ?

Correct. Backwards/forwards compatibility is not defined just by the C++ language version used when compiling source code. Backwards/forwards compatibility is a complicated topic of its own. But I'll just give a simple contrived, example that illustrates some underlying concepts.

Let's simplify what a std::string is. It's basically a pointer, and the number of characters in the string:

Premised that I think that C/C++ macros are distilled evil (and that seems to me that you can substitute Container() using using) you can pass throug a type alias

The reliability of de-mangled names does not seem to be something that is well documented. For this reason, I am going to simply document the few tests that I've done on my x86_64 system allowing me to compare gcc and clang. These tests done through Compiler Explorer verifies that the returned strings for the same types are the same (including whitespace).

Maybe if I start using this in my application, one of the users will find an issue and I can update this question with another answer down the line, but for now, I think it is safe(ish) to trust de-mangling.