Нужна помощь в понимании порядка исполнения из сборки - PullRequest
1 голос
/ 18 февраля 2020

Карта памяти со временем выполнения: Memory Map with execution time.

И вот код сборки, который ему соответствует:

; Listing generated by Microsoft (R) Optimizing Compiler Version 19.16.27027.1 

    TITLE   c:\LearningTree\348LM\CoursePrograms\348L\Chap1\var.c
    .686P
    .XMM
    include listing.inc
    .model  flat

INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES

PUBLIC  _x
_DATA   SEGMENT
COMM    _ret:BYTE
_DATA   ENDS
_DATA   SEGMENT
_x  DD  064H
_DATA   ENDS
PUBLIC  _main
PUBLIC  _test
_BSS    SEGMENT
_si DD  01H DUP (?)
?i@?1??main@@9@9 DD 01H DUP (?)             ; `main'::`2'::i
_BSS    ENDS
_DATA   SEGMENT
_sj DD  017H
?y@?1??main@@9@9 DW 063H                ; `main'::`2'::y
_DATA   ENDS
; Function compile flags: /Odtp
; File c:\learningtree\348lm\courseprograms\348l\chap1\var.c
_TEXT   SEGMENT
_i1$ = -8                       ; size = 4
_c2$ = -2                       ; size = 1
_c1$ = -1                       ; size = 1
_ui$ = 8                        ; size = 4
_i$ = 12                        ; size = 4
_s$ = 16                        ; size = 2
_us$ = 20                       ; size = 2
_c$ = 24                        ; size = 1
_uc$ = 28                       ; size = 1
_l$ = 32                        ; size = 4
_ul$ = 36                       ; size = 4
_x$ = 40                        ; size = 4
_y$ = 44                        ; size = 2
_test   PROC

; 59   : {

  00000 55       push    ebp
  00001 8b ec        mov     ebp, esp
  00003 83 ec 08     sub     esp, 8

; 60   :    char c1;
; 61   :    int i1;
; 62   :    char c2;
; 63   : 
; 64   :    ui = 1;

  00006 c7 45 08 01 00
    00 00        mov     DWORD PTR _ui$[ebp], 1

; 65   :    i = 2;

  0000d c7 45 0c 02 00
    00 00        mov     DWORD PTR _i$[ebp], 2

; 66   :    s = 3;

  00014 b8 03 00 00 00   mov     eax, 3
  00019 66 89 45 10  mov     WORD PTR _s$[ebp], ax

; 67   :    us = 4;

  0001d b9 04 00 00 00   mov     ecx, 4
  00022 66 89 4d 14  mov     WORD PTR _us$[ebp], cx

; 68   :    c = 5;

  00026 c6 45 18 05  mov     BYTE PTR _c$[ebp], 5

; 69   :    uc = 6;

  0002a c6 45 1c 06  mov     BYTE PTR _uc$[ebp], 6

; 70   :    l = 7;

  0002e c7 45 20 07 00
    00 00        mov     DWORD PTR _l$[ebp], 7

; 71   :    ul = 8;

  00035 c7 45 24 08 00
    00 00        mov     DWORD PTR _ul$[ebp], 8

; 72   :    x = 9;

  0003c c7 45 28 09 00
    00 00        mov     DWORD PTR _x$[ebp], 9

; 73   :    y = 10;

  00043 ba 0a 00 00 00   mov     edx, 10            ; 0000000aH
  00048 66 89 55 2c  mov     WORD PTR _y$[ebp], dx

; 74   :    c1 = 11;

  0004c c6 45 ff 0b  mov     BYTE PTR _c1$[ebp], 11 ; 0000000bH

; 75   :    c2 = 12;

  00050 c6 45 fe 0c  mov     BYTE PTR _c2$[ebp], 12 ; 0000000cH

; 76   :    i1 = 13;

  00054 c7 45 f8 0d 00
    00 00        mov     DWORD PTR _i1$[ebp], 13    ; 0000000dH

; 77   :    return ui * 2 + l;

  0005b 8b 45 08     mov     eax, DWORD PTR _ui$[ebp]
  0005e 8b 4d 20     mov     ecx, DWORD PTR _l$[ebp]
  00061 8d 04 41     lea     eax, DWORD PTR [ecx+eax*2]

; 78   : }

  00064 8b e5        mov     esp, ebp
  00066 5d       pop     ebp
  00067 c3       ret     0
_test   ENDP
_TEXT   ENDS
; Function compile flags: /Odtp
; File c:\learningtree\348lm\courseprograms\348l\chap1\var.c
_TEXT   SEGMENT
_l$ = -24                       ; size = 4
_ui$ = -20                      ; size = 4
_ul$ = -16                      ; size = 4
_s$ = -12                       ; size = 2
_us$ = -8                       ; size = 2
_uc$ = -2                       ; size = 1
_c$ = -1                        ; size = 1
_argc$ = 8                      ; size = 4
_argv$ = 12                     ; size = 4
_envp$ = 16                     ; size = 4
_main   PROC

; 28   : {

  00000 55       push    ebp
  00001 8b ec        mov     ebp, esp
  00003 83 ec 18     sub     esp, 24            ; 00000018H

; 29   :    unsigned char uc;
; 30   :    static short y = 99;
; 31   :    short s;
; 32   :    char c;
; 33   :    unsigned short us;
; 34   :    static int i;
; 35   :    unsigned int ui;
; 36   :    long l;
; 37   :    unsigned long ul;
; 38   : 
; 39   :    if (i < 4) {

  00006 83 3d 00 00 00
    00 04        cmp     DWORD PTR ?i@?1??main@@9@9, 4
  0000d 7d 15        jge     SHORT $LN4@main

; 40   :        ui = us + s - c;

  0000f 0f b7 45 f8  movzx   eax, WORD PTR _us$[ebp]
  00013 0f bf 4d f4  movsx   ecx, WORD PTR _s$[ebp]
  00017 03 c1        add     eax, ecx
  00019 0f be 55 ff  movsx   edx, BYTE PTR _c$[ebp]
  0001d 2b c2        sub     eax, edx
  0001f 89 45 ec     mov     DWORD PTR _ui$[ebp], eax

; 41   :    }

  00022 eb 12        jmp     SHORT $LN2@main
$LN4@main:

; 42   :    else {
; 43   :        ul = si - sj * 2;

  00024 a1 00 00 00 00   mov     eax, DWORD PTR _sj
  00029 d1 e0        shl     eax, 1
  0002b 8b 0d 00 00 00
    00       mov     ecx, DWORD PTR _si
  00031 2b c8        sub     ecx, eax
  00033 89 4d f0     mov     DWORD PTR _ul$[ebp], ecx
$LN2@main:

; 44   :    }
; 45   : 
; 46   :    while (sj > c) {

  00036 0f be 55 ff  movsx   edx, BYTE PTR _c$[ebp]
  0003a 39 15 00 00 00
    00       cmp     DWORD PTR _sj, edx
  00040 7e 1e        jle     SHORT $LN3@main

; 47   :        uc = y - 3;

  00042 0f bf 05 00 00
    00 00        movsx   eax, WORD PTR ?y@?1??main@@9@9
  00049 83 e8 03     sub     eax, 3
  0004c 88 45 fe     mov     BYTE PTR _uc$[ebp], al

; 48   :        sj++;

  0004f 8b 0d 00 00 00
    00       mov     ecx, DWORD PTR _sj
  00055 83 c1 01     add     ecx, 1
  00058 89 0d 00 00 00
    00       mov     DWORD PTR _sj, ecx

; 49   :    }

  0005e eb d6        jmp     SHORT $LN2@main
$LN3@main:

; 50   : 
; 51   :    ret = test(ui, i, s, us, c, uc, l, ul, x,  y);

  00060 0f bf 15 00 00
    00 00        movsx   edx, WORD PTR ?y@?1??main@@9@9
  00067 52       push    edx
  00068 a1 00 00 00 00   mov     eax, DWORD PTR _x
  0006d 50       push    eax
  0006e 8b 4d f0     mov     ecx, DWORD PTR _ul$[ebp]
  00071 51       push    ecx
  00072 8b 55 e8     mov     edx, DWORD PTR _l$[ebp]
  00075 52       push    edx
  00076 0f b6 45 fe  movzx   eax, BYTE PTR _uc$[ebp]
  0007a 50       push    eax
  0007b 0f be 4d ff  movsx   ecx, BYTE PTR _c$[ebp]
  0007f 51       push    ecx
  00080 0f b7 55 f8  movzx   edx, WORD PTR _us$[ebp]
  00084 52       push    edx
  00085 0f bf 45 f4  movsx   eax, WORD PTR _s$[ebp]
  00089 50       push    eax
  0008a 8b 0d 00 00 00
    00       mov     ecx, DWORD PTR ?i@?1??main@@9@9
  00090 51       push    ecx
  00091 8b 55 ec     mov     edx, DWORD PTR _ui$[ebp]
  00094 52       push    edx
  00095 e8 00 00 00 00   call    _test
  0009a 83 c4 28     add     esp, 40            ; 00000028H
  0009d a2 00 00 00 00   mov     BYTE PTR _ret, al

; 52   : 
; 53   :    return 0;

  000a2 33 c0        xor     eax, eax

; 54   : }

  000a4 8b e5        mov     esp, ebp
  000a6 5d       pop     ebp
  000a7 c3       ret     0
_main   ENDP
_TEXT   ENDS
END

Я понимаю распределение переменных и как определить если они принадлежат данные, BSS или текст. Но я не могу понять, как определить, когда кадр начинается или останавливается, порядок и т. Д. c.

Я потерян на:

  1. Порядок в коде сборки
  2. Как узнать, когда начинается и заканчивается кадр.
...