Odwołanie do części struktury przekazywanej w parametrze do funkcji przy użyciu wstawek assemblera

Question

Siema,

Wiecie może jak odwołać się do adresu takiej zmiennej w strukturze (np. zmiennej 'a') mając adres struktury?

Answer 1

Niekoniecznie musisz używać do tego ASMa - język C/C++ również pozwala na taki zabieg.

Zmienne w strukturze (prostej, bez dziedziczenia) ułożone są według kolejności ich deklaracji. Pierwsza zmienna struktury ma adres samej struktury, do każdej kolejnej dostaniesz adres, dodając sumę adresów wszystkich poprzednich zmiennych struktury do adresu bazowego. Tylko tutaj należy się troszeczkę zastanowić, bo jest mała pułapka.

Domyślnie kompilator wyrównuje pola struktur do ilości bajtów, niezbędnej do optymalnego czasu dostępu.

Zobacz na poniższym kodzie (takie brzydkie rzutowania dla brzydkich zastosowań rodem z C):

#include <iostream>
using namespace std;

struct S
{
    int a;
    char b;
    int c;
    bool d;
};

int main()
{
    S foo, *ptr_foo = &foo;

    foo.a = 10;
    foo.b = 'a';
    foo.c = 20;
    foo.d = false;

    cout<< *(int*)     ((int)ptr_foo) << endl; // zmienna a
    cout<< *(char*)    ((int)ptr_foo + sizeof(int)) << endl; // zmienna b
    cout<< *(int*)     ((int)ptr_foo + (sizeof(int) + sizeof(int)) ) << endl; // zmienna c
    cout<< *(bool*)    ((int)ptr_foo + (sizeof(int) + sizeof(int) + sizeof(int)) ) << endl; // zmienna d
    return 0;
}

Każda kolejna zmienna jest oddalona na moim systemie i przy użyciu GCC4.9 od poprzedniej o sizeof(int), czyli 4 bajty.

Jeśli zaś chciałbyś wymusić rozłożenie zmiennych w strukturze zgodnie z ich faktycznym rozmiarem, musisz użyć dyrektywy preprocesora pragma pack(1), która ustawia wyrównanie do 1 bajta.

#include <iostream>
using namespace std;
#pragma pack(1)

struct S
{
    int a;
    char b;
    int c;
    bool d;
};

int main()
{
    S foo, *ptr_foo = &foo;
    foo.a = 10;
    foo.b = 'a';
    foo.c = 20;
    foo.d = false;

    cout<< *(int*)     ((int)ptr_foo) << endl; // zmienna a
    cout<< *(char*)    ((int)ptr_foo + sizeof(int)) << endl; // zmienna b
    cout<< *(int*)     ((int)ptr_foo + (sizeof(int) + sizeof(char)) ) << endl; // zmienna c
    cout<< *(bool*)    ((int)ptr_foo + (sizeof(int) + sizeof(char) + sizeof(int)) ) << endl; // zmienna d
    return 0;
}

 

Comments

Dodam od siebie, że działa to tylko ze zmiennymi w całości umieszczonymi na stacku. Jeśli spróbujesz zrobić takie coś z np. std::string - komputer może zwariować.

---

ogólnie dzięki, całkiem spk. Nie wiedziałem o #pragma pack(1), więc na serio thx. Ogólnie to robiłem drugiego asmloadera (podobnego do tego gynvaela) i sobie pomyślałem, że moje api, które wysyłam nie może być klasą typu void, bo parametry (w sumie pisałem to w nocy xD) i napisałem przy użyciu pointerów na funkcje, które od razu statycznie typowałem i tutaj nawet dobrze, że #pragma pack(1) nie jest ustawiony, ponieważ moja struktura zachowywała się jak tablica, a tego od niej chciałem. :D

---

Nie śledzę działań Gynvaela, więc nie mam pojęcia, o czym mówisz. ;D

Ale widzę, że nie pomogłem tutaj za bardzo, bo jednak chciałeś kod assemblera, prawda?

A o #pragma pack dowiedziałem się, kiedy pisałem dla Ciebie odpowiedź, wcześniej o tym nie słyszałem. :)

---

pomogłeś, bo mi chodziło w jaki sposób ułożone są dane w kontenerze, a ty powiedziałeś, że ułożone są w pamięci po kolei, gdzie pierwszy jest adresem na strukturę i wszystkie są wyrównane do inta (albo słowa procesora, ale nie jestem pewien. Pewnie pisałeś to na 32bit architekturę). Dokładnie o to mi chodziło :D Teraz wiem, że struktury to takie tablice bez pragma pack(1) :D

---

asmloader to taki mini programik, który wczytuje jakieś bajty (no w sensie czystą binarkę [jeszcze nie exe]) i wkłada go w swoją pamięć wirtualną programu i wykonuje bezpośrednio na procku. :D

---

gdzie pierwszy jest adresem na strukturę i wszystkie są wyrównane do inta (albo słowa procesora, ale nie jestem pewien. Pewnie pisałeś to na 32bit architekturę).

Tak, 32-bitowa architektura. :) I owszem, chodzi tu o słowo procesora. :)