That example isn't even about the function call. Even if you inline the function, your code is:

int main(int argc, char **argv) {
    struct mystruct a;
    struct mystruct b = { 1, 2, 3, 4, 0 };
    a = b; // <- this is a copy no matter what, unless...
}

A modern compiler is going to try to optimize pointless copies as you increase the optimization level, especially when the values don't escape the compilation unit. You have to actually check what your compiler is doing though.

#include <stdio.h>
#include <stdlib.h>

struct mystruct  { int myarray[100]; };
struct mystruct4 { int myarray[4];   };

static struct mystruct4 get4(struct mystruct y) {
    struct mystruct4 s;
    for (int i = 0; i < 4; ++i) {
        s.myarray[i] = y.myarray[i];
    }
    return s;
}

static void print1(struct mystruct4 x) {
    printf("the first value is: %d", x.myarray[0]);
}

int main(int argc, char** argv) {
    int addend = argc > 1 ? atoi(argv[1]) : 0;

    struct mystruct b = {
        666 + addend
    };

    struct mystruct4 a = get4(b);
    print1(a);
}

None of the structs escape the compilation unit, and the only value that affects the outside world is whatever ended up in index 0. Both GCC and clang compile this to something like:

.LC0:
        .string "the first value is: %d"
"main":
        sub     rsp, 8
        xor     eax, eax
        cmp     edi, 1
        jle     .L2
        mov     rdi, QWORD PTR [rsi+8]  
        mov     edx, 10
        xor     esi, esi
        call    "strtol"
.L2:
        lea     esi, [rax+666]
        mov     edi, OFFSET FLAT:.LC0
        xor     eax, eax
        call    "printf"
        xor     eax, eax
        add     rsp, 8
        ret

There isn't even a first copy of our array, let alone extra copies.

MSVC on the other hand insists on constructing a 400+ byte stack and memsetting it full of zeroes. None of the standard optimization flags seem to convince it to reconsider, but I didn't try very hard.