Bytes | Swift Library for working with sequences of Bytes

I'm unsure if the problem is my code or if I found a compiler bug.

The problem is your code. In GNU assembler, parentheses are used to dereference like unary * is in C, and you can only dereference a register, not memory. As such, writing 12(%0) in the assembly when %0 might be memory is wrong. It only happens to work in GCC because GCC chooses to use a register for "rm" there, while Clang chooses to use memory. You should use "r" (bytes) instead.

Also, you need to tell the compiler that your assembly is going to modify the array, either with a memory clobber or by adding *(unsigned char (*)[16])bytes as an output. Right now, it's allowed to optimize your printf to just hardcode what the values were at the beginning of the program.

Fixed code:

Remove your agreement vars in MinimalClone.sol, and either have the user input them as args in your init() method or hardcode them into the request like this:

calloc is allocating the amount of memory you asked for on the heap. The pointer is allocated by your compiler either in registers or on the stack. In this case, calloc is actually allocating enough memory for 4 ints on the heap (which on most systems is going to be 16 bytes, but for the arduino uno it would be 8 because the sizeof(int) is 2), then storing the pointer to that allocated memory in your register/stack location.

For the bonus question: Arduino uses C++ instead of C, and that means that it uses C++'s stronger type system. void * and int * are different types, so it's complaining. You should cast the return value of malloc when using C++.

select() can set a timeout for the connection part.

Yes, but only if you put the socket into non-blocking mode before calling connect(), so that connect() exits immediately and then the code can use select() to wait for the socket to report when the connect operation has finished. But the code shown is not doing that.

setsockopt() with timeval can timeout the receiving portion of the code

Yes, though select() can also be used to timeout a read operation, as well. Simply call select() first, and then call recv() only if select() reports that the socket is readable (has pending data to read).

Try something like this:

You shouldn't necessarily have to implement a full custom atomic API, it should actually be safe to simply pull out a pointer to the underlying data from the atomic and pass it to the system.

Since std::atomic does not offer some equivalent of native_handle like other synchronization primitives offer, you're going to be stuck doing some implementation-specific hacks to try to get it to interface with the native API.

For the most part, it's reasonably safe to assume that first member of these types in implementations will be the same as the T type -- at least for integral values ^[1]. This is an assurance that will make it possible to extract out this value.

... and casting std::atomic to u/int* is UB

If the problem did end up being from heap overuse (from strncat), then you could try out this implementation that uses the return from sprintf to append to the string as your building it.

TCP/IP connections are designed to be long-lived streaming connections (built on top of the out-of-order, no-guarantee, packet-based IP protocol).

You could use the split() command in Python to break up your sting into a list. You can then iterate over the elements inside the list. You could do this al follows:

We're looking in to the same issue currently and it seems apple are disabling the old binary interface which push sharp uses.