Contatore del programma di lettura direttamente

Question

Il contatore del programma su CPU Intel può essere letto direttamente (ovvero senza "trucchi") in modalità kernel o in qualche altra modalità?

Answer 1

No, non è possibile accedere direttamente a EIP/IP, ma in codice dipendente dalla posizione è una costante di tempo di collegamento in modo da poter utilizzare un simbolo vicino (o distante) come immediato.

Per ottenere EIP o IP in codice indipendente dalla posizione:

call _here 
_here: pop eax 
; eax now holds the PC. 

Ma questo sbilancia il predittore stack di chiamate/ritorno, in modo preferiscono chiamare una funzione che in realtà tornare, per evitare mispredicts filiali, il 15 o giù di lì future ret istruzioni nelle funzioni genitore. (A meno che non hai intenzione di tornare, o almeno così di rado che non importa.)

get_retaddr: 
    mov eax, [esp] 
    ret    ; keeps the return-address predictor stack balanced 

---

In modalità x86-64, RIP possono essere letti direttamente tramite un RIP-relativa lea.

default rel   ; NASM directive: use RIP-relative by default 

lea rax, [_here]  ; RIP + 0 
_here: 

MASM: lea rax, [rip]

AT & sintassi T: lea 0(%rip), %rax

Answer 2

Se è necessario l'indirizzo di un'istruzione specifica, di solito qualcosa come questo fa il trucco:

thisone: 
    mov (e)ax,thisone 

(Nota: su alcuni assemblatori ciò potrebbe fare la cosa sbagliata e leggere una parola da [thisone], ma di solito c'è qualche sintassi f o fare in modo che l'assemblatore faccia la cosa giusta.)

Se il codice viene caricato staticamente su un indirizzo specifico, l'assemblatore sa già (se gli hai detto l'indirizzo di partenza corretto) gli indirizzi assoluti di tutte le istruzioni. Il codice caricato dinamicamente, come parte di un'applicazione su qualsiasi sistema operativo moderno, otterrà il giusto indirizzo grazie al riposizionamento degli indirizzi eseguito dal linker dinamico (a condizione che l'assemblatore sia abbastanza intelligente da generare le tabelle di rilocazione, che di solito sono).

Answer 3

Non c'è alcuna istruzione per leggere direttamente il puntatore di istruzioni (EIP) su x86. È possibile ottenere l'indirizzo dell'istruzione corrente in fase di montaggio, con un po 'di assembly inline:

// GCC inline assembler; for MSVC, syntax is different 
uint32_t eip; 
__asm__ __volatile__("movl $., %0", : "=r"(eip)); 

La direttiva . assembler viene sostituito con l'indirizzo dell'istruzione corrente dall'assembler. Si noti che se si avvolge lo snippet sopra riportato in una chiamata di funzione, si otterrà lo stesso indirizzo (all'interno di quella funzione) ogni volta. Se si desidera una funzione C più utilizzabile, è possibile invece utilizzare alcuni di montaggio non in linea:

// In a C header file: 
uint32_t get_eip(void); 

// In a separate assembly (.S) file: 
.globl _get_eip 
_get_eip: 
    mov 0(%esp), %eax 
    ret 

Ciò significa che ogni volta che si desidera ottenere il puntatore all'istruzione, è un po 'meno efficiente in quanto è necessario una chiamata di funzione in più. Si noti che facendo in questo modo non soffiare lo stack di indirizzo di ritorno (RAS). Lo stack di indirizzo di ritorno è uno stack separato di indirizzi di ritorno utilizzati internamente dal processore per facilitare branch target prediction per istruzioni RET.

Ogniqualvolta si dispone di un'istruzione CALL, l'EIP corrente viene inserito nel RAS e ogni volta che si esegue un'istruzione RET, il RAS viene interrotto e il valore superiore viene utilizzato come predizione del target di diramazione per tale istruzione.Se si incasina il RAS (ad esempio non corrispondendo ad ogni CALL con un RET, come in Cody's solution), si otterrà un sacco di errate previsioni di rami inutili, rallentando il programma. Questo metodo non soffiare il RAS, poiché ha una coppia di istruzioni CALL e RET corrispondenti.

Answer 4

Su x86-64 si può fare ad esempio:

lea rax,[rip] (48 8d 05 00 00 00 00) 

Answer 5

Si può anche leggere questo da/proc/stat. Controlla le manpage proc.

Answer 6

Esiste un'architettura modo indipendente (ma gcc dipendente) di accedere al indirizzo che viene eseguito utilizzando etichette come valori:

http://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html

void foo() 
{ 
    void *current_address = $$current_address_label; 
    current_address_label: 
     .... 
}