Debugeri i Decompileri

tuj de - ama posle se okaza che ako texturite sa prekaleno golemi - i ne se napravjat njakakwi optimizatzii (swizzling kakto im se wika) - to se gubi mnogo skorost ot cache-missovete - ama tva po-kusno stana...

amche tozi prijatel - edinia sled kato im falira firmata si nameri rabota w druga firma, a drugia ne iska i da chuva za idwane pri nas... ko da praim sja :)...

Opsss.. pak kazah "pri nas" - KAZHETE! HORA KAZHETE! kak da se izrazjawam tochno .... "Izrazjawane for dummies?" uh? njakoi da ima?

tirulirutatuutuu

e, da... ima hora vsiakakvi! i dobre ce ima! :-)

az naprimer ne bih se zahvanal s .mp3 stoto kakvo da go prava?
kato ne go znam kak raboti, a za da og razbera trebav da proceta mngoo teoria s razni mngoo dalgi formuli, integrali stepenni redobe i neznam si kvo...

mislil sam si, ha! eto sa zema d asi napisa edin mnogo optimiziran player na assembler za 386.
dobre de, da kajem ce moga da go napisa, ami koi sa mi kaje algoritema?
obsto vzeto tozi koito znae algoritama i kod moje da si napise! tozi koito moje samo kodove da pise v slucaia nisto ne moje da napravi!

na men mi e interesno, vsickite teia .mp3 plaierceta deto gi ima! kak im pisat koda?
dali nagrabvat(kupuvat) nekav gotov sors i go porazbutat za tehni nujdi, ili seda nekoi matematik-fizik-akustik-infotmatik-injener..... cete mnogo, razbira kak raboti! interpretira go po svoemu i pise kod?

"Графичние оптимизации и словоред для чайников" :)

Щото е голямо и не е на български.


System Doctor Error:
Your girlfriend is pregnant.
(A)bort, (M)arry, (I)gnore?_

mi sorsa na mp3-encodera-decodera e pisan na chisto C (da kazhem) ...
ti go hwashtash i ruchno go optimizarsh za njakakuw si tam specialen procesor, ili go pravish ot floating point da izpolzwa fixed point.. tuj to...

tirulirutatuutuu

Малък, да не си станал днеска с левия крак напред или някоя друга част нагоре? :))

Това го изтъкнах само като примери.
За всичко си прав, освен за три неща.

За това как ти си се учил що е memory manager. Едно време, когато предполагам не си и мислел още да се занимаваш с програмиране (е, може и да се лъжа :) и когато Интернет се олицетворяваше от BBS, нямаше от къде човек да се научи как работи един memory manager с всичките му тънкости, освен да се рови в чужди програми. Например в Cliper 5x имаше велика система за виртуална памет, никъде до сега не съм виждал публикувано нещо подобно по възможности (е, за ДОС)....

Относно декомпилацията на C-кода - няма голямо значение оптимизацията, вервай ми. Мога книга да напиша по въпроса, само маркетинга ме спира :)). И не си прав че C и Pascal се различават само по обвивката. Но както и да е.

И другото е за Ida. Както намекнах, работя легално, имам легална версия и ми върши прекрасна работа. Лично мен ме интересува само "сърцето" на по-новата IDA - IDA.WLL версия над 4.20. Този ми интерес обаче не е достатъчен за да ми я купят, нали?

Поздрави!

Систъм Доктор Ерор:
Йор гърлфренд ис прегнънт.
(А)борт, (М)ери, (И)гноър?_

Na men mi e mnogo interesno kak li prawish obryshtane na asm w c code...Samo teoriq...No ako ne ti e problem postni neshto...Towa shte mi e ot golqma polza ako si go napisha za arma - taka ili inache twoqta versiq nqma da mi swarshi rabota :)
Moje i links kam praweni neshta koito imat istinsko prilojenie a ne samo da mi pishat
void sub_443899 ()
{
asm {
....
}
}
towa i sam moga da si go napisha i bez teoriq :) goworq za realno otkriwane na swtch, for, while, if e lesno i drugi koito sa mnogo chesto izpolzwani, istinsko izpolzwane na localni promenliwi i takiwa koito se podawat

A powqrwai mi 2MB code na arm assembler nikak ne mi e lesno i rozowo da prawq reversing...E az go prawq kato hobi no tam horata ne se opitwat da se zashtitawat (wse oshte) kakto na x86 i shte e dobre za wsichki (nadqwam se), a ako pomognesh lichno az shte ti post-na c codeto na MP3 playera na SL45 i posle kato si naprawish na c towa koeto iskash shte go warna obratno :)))

-------------------------------
Koito go moje - go moje!

Страшно ме затрудняваш да обясня тука как става превръщането . Пък и линкове към такива инструменти няма - гарантирам :((.

Най-приличното което броди по мрежата е "Desquirr" (потърси с google.com, има го и на сорс) - това е плугин за IDA 4.21 и нагоре, но изобщо не е това което искаме всички.

Разбира се че не се получава такъв код, какъвто прилагаш. Ето пример от някакъв стар проект. Ще ти постна нещо за 80x86. Някъде имам и за MIPS, ако те вълнува. Мога да споделя опит ако има интерес.

Коментара в началото и името на функцията съм го писал на ръка. В основата е сорс от IDA. Това вече се компилира, и даже е работело. Могат да се изграждат и структури (втората функция), и обекти. И елементарно се прави на ръка (с малко повече опит). Това е суровата версия. В по-нататъшна версия променливите и функциите са преименовани, разбира се:

    //--------------------------------------//

    //  Convert from UniString to Binary    //

    //--------------------------------------//

int     _603B1B1A_Cvt_UniStr_ToBin (WORD * arg_0, LPBYTE arg_4, UINT arg_8)

{

//var_10          = dword ptr -10h

//var_C           = dword ptr -0Ch

//var_8           = dword ptr -8

//var_4           = dword ptr -4

//arg_0           = dword ptr  8

//arg_4           = dword ptr  0Ch

//arg_8           = dword ptr  10h

    UINT        i_var_4;

    WORD       *i_var_8;

    WORD        w_var_c;

    WORD        w_var_10;



//                push    ebp

//                mov     ebp, esp

//                sub     esp, 10h

//                and     [ebp+var_4], 0

    i_var_4 = 0;

//                mov     eax, [ebp+arg_0]

//                mov     [ebp+var_8], eax

    i_var_8 = arg_0;

//_text_603B1B2A:

//                mov     eax, [ebp+var_8]

//                movzx   eax, word ptr [eax]

//                test    eax, eax

//                jz      _text_603B1CAF

    while (*i_var_8) {

//_text_603B1B38:

//                mov     eax, [ebp+var_8]

//                movzx   eax, word ptr [eax]

//                cmp     eax, 2Dh

//                jnz     short _text_603B1B4D

//                mov     eax, [ebp+var_8]

//                inc     eax

//                inc     eax

//                mov     [ebp+var_8], eax

//                jmp     short _text_603B1B38

        while (*i_var_8 == '-')

            i_var_8++;  // += 2



//_text_603B1B4D:

//                mov     eax, [ebp+var_8]

//                movzx   eax, word ptr [eax]

//                test    eax, eax

//                jnz     short _text_603B1B5C

//                jmp     _text_603B1CAF

        if (!*i_var_8)

            break;



//_text_603B1B5C:

//                mov     eax, [ebp+var_8]

//                mov     ax, [eax]

//                mov     word ptr [ebp+var_10], ax

//                mov     eax, [ebp+var_8]

//                inc     eax

//                inc     eax

//                mov     [ebp+var_8], eax

        w_var_10 = *(i_var_8++);

//                movzx   eax, word ptr [ebp+var_10]

//                cmp     eax, 61h

//                jl      short _text_603B1B80

//                movzx   eax, word ptr [ebp+var_10]

//                cmp     eax, 66h

//                jle     short _text_603B1BAE

//_text_603B1B80:

//                movzx   eax, word ptr [ebp+var_10]

//                cmp     eax, 41h

//                jl      short _text_603B1B92

//                movzx   eax, word ptr [ebp+var_10]

//                cmp     eax, 46h

//                jle     short _text_603B1BAE

//

//_text_603B1B92:

//                movzx   eax, word ptr [ebp+var_10]

//                cmp     eax, 30h

//                jl      short _text_603B1BA4

//                movzx   eax, word ptr [ebp+var_10]

//                cmp     eax, 39h

//                jle     short _text_603B1BAE

//

        if (  !(w_var_10 >= 'a' && w_var_10 <= 'f') &&

              !(w_var_10 >= 'A' && w_var_10 <= 'F') &&

              !(w_var_10 >= '0' && w_var_10 <= '9') )

//_text_603B1BA4:

//                mov     eax, 80004005h

//                jmp     _text_603B1CC0

            return (0x80004005);



//_text_603B1BAE:

//                mov     eax, [ebp+var_8]

//                movzx   eax, word ptr [eax]

//                cmp     eax, 2Dh

//                jnz     short _text_603B1BC3

//                mov     eax, [ebp+var_8]

//                inc     eax

//                inc     eax

//                mov     [ebp+var_8], eax

//                jmp     short _text_603B1BAE

        while (*i_var_8 == '-')

            i_var_8++;  // += 2



//_text_603B1BC3:

//                mov     eax, [ebp+var_8]

//                movzx   eax, word ptr [eax]

//                test    eax, eax

//                jnz     short _text_603B1BD7

        if (!*i_var_8)

//                mov     eax, 80004005h

//                jmp     _text_603B1CC0

            return (0x80004005);



//_text_603B1BD7:

//                mov     eax, [ebp+var_8]

//                mov     ax, [eax]

//                mov     word ptr [ebp+var_C], ax

//                mov     eax, [ebp+var_8]

//                inc     eax

//                inc     eax

//                mov     [ebp+var_8], eax

        w_var_c = *(i_var_8++);

//                movzx   eax, word ptr [ebp+var_C]

//                cmp     eax, 61h

//                jl      short _text_603B1BFB

//                movzx   eax, word ptr [ebp+var_C]

//                cmp     eax, 66h

//                jle     short _text_603B1C29

//

//_text_603B1BFB:

//                movzx   eax, word ptr [ebp+var_C]

//                cmp     eax, 41h

//                jl      short _text_603B1C0D

//                movzx   eax, word ptr [ebp+var_C]

//                cmp     eax, 46h

//                jle     short _text_603B1C29

//

//_text_603B1C0D:

//                movzx   eax, word ptr [ebp+var_C]

//                cmp     eax, 30h

//                jl      short _text_603B1C1F

//                movzx   eax, word ptr [ebp+var_C]

//                cmp     eax, 39h

//                jle     short _text_603B1C29

//

        if (  !(w_var_c >= 'a' && w_var_c <= 'f') &&

              !(w_var_c >= 'A' && w_var_c <= 'F') &&

              !(w_var_c >= '0' && w_var_c <= '9') )

//_text_603B1C1F:

//                mov     eax, 80004005h

//                jmp     _text_603B1CC0

            return (0x80004005);



//_text_603B1C29:

//                push    [ebp+var_10]

//                call    _towupper

//                pop     ecx

//                mov     word ptr [ebp+var_10], ax

        w_var_10 = towupper (w_var_10);

//                push    [ebp+var_C]

//                call    _towupper

//                pop     ecx

//                mov     word ptr [ebp+var_C], ax

        w_var_c = towupper (w_var_c);

//                movzx   eax, word ptr [ebp+var_10]

//                xor     ecx, ecx

//                cmp     eax, 41h

//                setl    cl

//                dec     ecx

//                and     ecx, 7

//                add     ecx, 30h

//                mov     ax, word ptr [ebp+var_10]

//                sub     ax, cx

//                mov     word ptr [ebp+var_10], ax

        w_var_10 -= w_var_10 >= 'A' ? 0x37 : 0x30;

//                movzx   eax, word ptr [ebp+var_C]

//                xor     ecx, ecx

//                cmp     eax, 41h

//                setl    cl

//                dec     ecx

//                and     ecx, 7

//                add     ecx, 30h

//                mov     ax, word ptr [ebp+var_C]

//                sub     ax, cx

//                mov     word ptr [ebp+var_C], ax

        w_var_c -= w_var_c >= 'A' ? 0x37 : 0x30;

//                mov     eax, [ebp+var_4]

//                cmp     eax, [ebp+arg_8]

//                jb      short _text_603B1C8E

        if (i_var_4 >= arg_8)

//                mov     eax, 80004005h

//                jmp     short _text_603B1CC0

            return (0x80004005);



//_text_603B1C8E:

//                movzx   eax, word ptr [ebp+var_10]

//                shl     eax, 4

//                movzx   ecx, word ptr [ebp+var_C]

//                add     eax, ecx

//                mov     ecx, [ebp+arg_4]

//                add     ecx, [ebp+var_4]

//                mov     [ecx], al

//                mov     eax, [ebp+var_4]

//                inc     eax

//                mov     [ebp+var_4], eax

        arg_4 [i_var_4++] = (BYTE)((w_var_10 << 4) | w_var_c);

//                jmp     _text_603B1B2A

    }

//_text_603B1CAF:

//                mov     eax, [ebp+var_4]

//                cmp     eax, [ebp+arg_8]

//                jz      short _text_603B1CBE

    if (i_var_4 != arg_8)

//                mov     eax, 80004005h

//                jmp     short _text_603B1CC0

        return (0x80004005);



//_text_603B1CBE:

//                xor     eax, eax



    return (0);

//_text_603B1CC0:

//                leave

//                retn

//_603B1B1A_Cvt_UniStr_ToBin  endp

}



...............



int     WINAPI  _603B2B75_ExtractVar2From_S28 (S28 * arg_0, int *arg_4)

{

//var_10          = dword ptr -10h

//var_C           = dword ptr -0Ch

//var_8           = dword ptr -8

//var_4           = dword ptr -4

//arg_0           = dword ptr  8

//arg_4           = dword ptr  0Ch

    int         i_var_4;

    S8          var_c;

    int         i_var_10;



//                push    ebp

//                mov     ebp, esp

//                sub     esp, 10h

//                and     [ebp+var_10], 0

//                mov     [ebp+var_4], 1

    i_var_10 = 0;

    i_var_4 = 1;

//                mov     eax, [ebp+arg_0]

//                mov     ecx, [eax+18h]

//                mov     eax, [eax+1Ch]

//                mov     [ebp+var_C], ecx

//                mov     [ebp+var_8], eax

    var_c.i0 = arg_0->x18.i0;

    var_c.i4 = arg_0->x18.i4;

//                mov     eax, [ebp+var_C]

//                and     eax, 0E0000000h

//                mov     ecx, [ebp+var_8]

//                and     ecx, 0E0000000h

//                mov     [ebp+var_C], eax

//                mov     [ebp+var_8], ecx

    var_c.i0 &= 0xE0000000;

    var_c.i4 &= 0xE0000000;

//                mov     eax, [ebp+var_C]

//                cmp     eax, [ebp+var_8]

//                jnz     short _text_603B2BC3

    if (var_c.i0 == var_c.i4) {

//                mov     eax, [ebp+var_C]

//                shr     eax, 1Dh

//                mov     ecx, [ebp+arg_4]

//                mov     [ecx], eax

        *arg_4 = var_c.i0 >> 0x1D;

//                and     [ebp+var_4], 0

        i_var_4 = 0;

    }

//_text_603B2BC3:

//                mov     eax, [ebp+var_4]

    return (i_var_4);

//                leave

//                retn    8

//_603B2B75_ExtractVar2From_S28  endp

}

Е, два мегабайта няма да е лесно :))

koda kojto si postnal e kompiliran sus -O0 pod MSVC-to (ili tam podobni kompilatori), wzemi generirania C kod i go prekomppiliraj sus -O2 i wizh razlikite...

Da se vurnem na starata prikazka - che dali e Pascal, ili C njama znachenie - ima znachenie sus kakvi optimizatzii e kompiliran....

Hwani ako iskash tozi kod, prepishi go na Pascal - i wizh go w DEBUG kakvo kompilira - edinstwenata goljama razlika e shte e kak nehstata w steka se pulnjat - dali purwia argument purwi shte se pushne w steka ili ne - sushto i suvsem malki razliki pri prolog i epilog funckiite... Wsushnost poslednata kojato e sus WINAPI - tova ne e li wsushnost skirt __pascal_call (ili tam kakto se wika - ne si spomnjam) - edin wid ne e __cdecl, nali?

tirulirutatuutuu

e, po princip taka moje!
sa zema da optimiziram edin za 8051 :-)

Малък, над 15 години се занимавам с тая работа, няма значение оптимизацията. Само така ти се струва. Просто се появяват регистрови променливи, разместват се оператори, има inline-функции, FASTCALL-аргументи и малко се усложняват циклите. Е, появяват се и цял набор идиоматични конструкции, на които човек трябва да свикне. Например:

mov eax, [data]
cmp eax, 1
sbb eax, eax
and eax, 5
add eax, 2

е еквивалентно на изразът: "eax = data != 0 ? 2 : 7"
При Watcom се изяждат и крайщата на функциите, щото се обединяват от глобалната оптимизация. Понякога, не винаги, при конструкции от рода на IF с последващ цикъл след него малко се замотават преходите... Принципът е абсолютно един и същ. Това го постнах за да се види логиката. Имаше едно време добре оптимизиращи компилатори, сега е само shit

Е, това дето ти казвам е по-вярно за C. При C++ и истински обекти в резултат на оптимизацията се появяват и доста странни конструкции, с нееднозначен смисъл :((. А ако се ползуват и темплейти - доста проблематична става работата. Пък и при обектите има силна зависимост на вътрешното представяне на обекта от марката на компилатора - човек трябва да покопае с различни компилатори, за да усети конструкциите.

Колкото до C и Pascal - проблема не е толкова прост. Проблема е в смисъла, защото Pascal разбива една повикването на функция например на няколко повиквания, с допълнителни междинни променливи. Например ако функцията има като аргумент обекти, това е практика. И за да изкараш човешка програма се налага нещо като прилагане на допълнителен макропроцесор отгоре (в обратна посока :). Да не говорим за някои от системните функции, чиято представа в машинен код явно е трърдо забита в компилатора, така че ако не си се сблъсквал директно с такава конструкция, никога няма да се сетиш какво е. Но пък благото е че няма АБСОЛЮТНО НИКАКВА оптимизация на кода, всичко минава като по учебник :)) (поне за всички версии на Делфи досега).

Иначе за другото си прав - така е .
Ако искаш оптимизирай трийсетина реда на C (не ти, компилатора!) и ми ги прати, да ти покажа какво става.

Mislia che Atmel imat 8051 specialno za MP3 plaer-i;)