Zespół ramion - Funkcja wywoływania z więcej niż 4 argumentami

Question

Wiem, że wywołanie funkcji w złożeniu r0 zawiera pierwszy argument, aż r3 będzie czwartym. Wiem, że gdy przekracza on cztery, użyto wskaźnika stosu, ale nie jestem zbyt pewny co do szczegółów. Czy r0-r3 nadal trzyma pierwsze cztery, a reszta idzie na stos? Patrzę na następujący fragment zespołu próbujący zrozumieć, co robi wywołanie mach_msg (funkcja z siedmioma argumentami). Na wejściu do tego kodu, R0 i R1 zawiera dwa argumenty

var_38   = -0x38 
var_34   = -0x34 
var_30   = -0x30 
var_2C   = -0x2C 
var_24   = -0x24 
var_20   = -0x20 
var_18   = -0x18 
var_14   = -0x14 
var_10   = -0x10 
var_C   = -0xC 
00001220 
00001220     PUSH   {R7,LR} 
00001222     MOV    R7, SP 
00001224     SUB    SP, SP, #0x30 
00001226     MOV    R2, (_NDR_record_ptr - 0x1232) ; _NDR_record_ptr 
0000122E     ADD    R2, PC ; _NDR_record_ptr 
000LDR    R2, [R2] ; _NDR_record 
000LDR    R3, [R2] 
000LDR    R2, [R2,#4] 
000STR    R2, [SP,#0x38+var_10] 
000MOVS   R2, #0x24 ; '$' 
0000123A     STR    R3, [SP,#0x38+var_14] 
0000123C     MOVS   R3, #0 
0000123E     STRB.W   R1, [SP,#0x38+var_C] 
00001242     MOVS   R1, #0x13 
00001244     STR    R1, [SP,#0x38+var_2C] 
00001246     MOVS   R1, #1 
00001248     STR    R0, [SP,#0x38+var_24] 
0000124A     MOV    R0, 0x1E84EA 
00001252     STR    R3, [SP,#0x38+var_20] 
00001254     STR    R3, [SP,#0x38+var_38] 
00001256     STR    R3, [SP,#0x38+var_34] 
00001258     STR    R0, [SP,#0x38+var_18] 
0000125A     STR    R3, [SP,#0x38+var_30] 
0000125C     ADD    R0, SP, #0x38+var_2C 
0000125E     BLX    _mach_msg 
00001262     ADD    SP, SP, #0x30 
00001264     POP    {R7,PC} 

Oto definicje dla rzeczy miano i używane:

typedef struct { 
    unsigned char  mig_vers; 
    unsigned char  if_vers; 
    unsigned char  reserved1; 
    unsigned char  mig_encoding; 
    unsigned char  int_rep; 
    unsigned char  char_rep; 
    unsigned char  float_rep; 
    unsigned char  reserved2; 
} NDR_record_t; 
extern NDR_record_t NDR_record; 
extern mach_msg_return_t mach_msg(
       mach_msg_header_t *msg, 
       mach_msg_option_t option, 
       mach_msg_size_t send_size, 
       mach_msg_size_t rcv_size, 
       mach_port_name_t rcv_name, 
       mach_msg_timeout_t timeout, 
       mach_port_name_t notify); 

Z tego co rozumiem, wskaźnik stosu jest odwrócony 48 bajtów dla zmiennych. Czy to 48 bajtów dla dodatkowych 3 argumentów lub dla wszystkich z nich?

Answer 1

Z 48 bajtów, 12 dotyczy dodatkowych 3 parametrów, a pozostałe są dla zmiennych lokalnych. Możesz to zobaczyć w kodzie, w którym funkcja przechodzi cztery parametry od r0 do r3, inna w [SP, # 0x38 + var_38] (co jeśli matematyka zostanie rozwiązana po prostu [sp]), inna w [sp, # 4 ], a ostatni w [sp, # 8].

Answer 2

Pamiętam, że tyle, ile można przekazać przez rejestry (r0-r3 lub 4 słowa) są przekazywane za pośrednictwem rejestrów. a reszta przechodzi przez stos.

Answer 3

unsigned int fun 
(
    unsigned int a, 
    unsigned int b, 
    unsigned int c, 
    unsigned int d, 
    unsigned int e, 
    unsigned int f 
) 
{ 
    a+=1; 
    a|=b+2; 
    a&=c+4; 
    a^=d+5; 
    a-=e+6; 
    a|=~f; 
    return(a); 
} 


00000000 <fun>: 
    0: e2800001 add r0, r0, #1 
    4: e2811002 add r1, r1, #2 
    8: e181c000 orr ip, r1, r0 
    c: e2822004 add r2, r2, #4 
    10: e002100c and r1, r2, ip 
    14: e59d0000 ldr r0, [sp] 
    18: e2833005 add r3, r3, #5 
    1c: e023c001 eor ip, r3, r1 
    20: e59d1004 ldr r1, [sp, #4] 
    24: e060200c rsb r2, r0, ip 
    28: e2420006 sub r0, r2, #6 
    2c: e1e03001 mvn r3, r1 
    30: e1800003 orr r0, r0, r3 
    34: e12fff1e bx lr 

Pierwsze cztery są R0 = A, R1 = B, R2 = C-R3 - D, w kolejności, a następnie reszta jest popychany w odwrotnej kolejności, dzięki czemu SP + 0 to E i SP + 4 jest f.

Jeśli masz powiedzieć 64 bitową liczbę całkowitą wtedy, że zajmie dwa rejestry, więc przydałby się r0-R3 z czterech wskazówki lub dwie wskazówki i długo długo, albo dwóch długich tęskni itp