What size is vararguments passed in x64?

The only difference in X64 ABI (Application binary interface) for standard and varargs is that floating point arguments are passed in XMM registers and standard registers, all other characteristics are the same:
1. The first 4 parameters are passed in registers as FASTCALL. Parameters in excess of 4 are passed on the stack.
2. The parameters from 8 up to 64 bits are passed in registers right justified. Means that a char parameter will occupy the lower 8 bits of the register, a widechar the lower 16 bits, an int the lower 32bits and an I64 the whole register. The same system is used for parameters on the stack that has always a dimension of 64bits, menaing that each push or pop is 64bits wide (this is also an HW requirement when the CPU is in x64 mode). Please see MSDN documentation[^]:

Quote:

The first four integer arguments are passed in registers. Integer values are passed (in order left to right) in RCX, RDX, R8, and R9. Arguments five and higher are passed on the stack. All arguments are right-justified in registers. This is done so the callee can ignore the upper bits of the register if need be and can access only the portion of the register necessary.

3. Other size in excess of 64 bits, i.e. __m128, are passed only by reference. The compiler creates an hidden local copy of the variable then pass the pointer to such hidden copy.

All information are available on the MS site here[^]. Reading carefully you'll get all you need.

EDIT to add explanation due to answer upgrade.

The way used by compiler for the right justify are compiler specific, so it could be a simple byte move, a sign extended move to a 16, 32 or 64bits. In your case the first four instructions depends on the cast you applied.

Please refer to the code:

char ch1 = 'A';
//00007FF68CE27265 C6 44 24 30 41       mov         byte ptr [ch1],41h
    wprintf(L"%c %d %ld %lld", ch1, (short)ch1, (__int32)ch1, (__int64)ch1);
    //This is just a conversion because the 5th parameter will be passed on the stack
//00007FF68CE2726A movsx       rax,byte ptr [ch1]    //Cast to 64 bits int (__int64)ch1.

    //Apply casts for values to pass in registers RCX RDX R8 R9
//00007FF68CE27270 movsx       ecx,byte ptr [ch1]    //Cast to 32 bits int (__int32)ch1
//00007FF68CE27275 movsx       edx,byte ptr [ch1]    //Byte extended to 32bits
//00007FF68CE2727A movsx       r8d,byte ptr [ch1]    //Cast to short extended to 32bits (short)ch1

    //This code have been generated with optimizations off this clearly exposed on
    //the next line where a copy of converted value is saved in local variable @ [rsp+34h]
//00007FF68CE27280 44 89 44 24 34       mov         dword ptr [rsp+34h],r8d

    //Push the 5th parameter on the stack. P.s. The stack is 64bits wide.
//00007FF68CE27285 48 89 44 24 20       mov         qword ptr [rsp+20h],rax

    //Now loads the registers RCX RDX R8 R9 as required by x64 ABI
    //RCX = format string
    //RDX = ch1
    //R8  = (short)ch1
    //R9  = (__int32)ch1
//00007FF68CE2728A 44 8B C9             mov         r9d,ecx
//00007FF68CE2728D 44 8B C2             mov         r8d,edx
//00007FF68CE27290 8B 44 24 34          mov         eax,dword ptr [rsp+34h]  //Get the value and...
//00007FF68CE27294 8B D0                mov         edx,eax  /store it in the low 32 bits of RDX
//00007FF68CE27296 48 8D 0D 7B 68 2B 00 lea         rcx,[byValue+298h (07FF68D0DDB18h)]  //format string

    //Call wprintf()
//00007FF68CE2729D FF 15 C5 C9 3C 00    call        qword ptr [__imp_wprintf (07FF68D1F3C68h)]