How to: debug flat thunk

Traduzione articoli Traduzione articoli
Identificativo articolo: 133722 - Visualizza i prodotti a cui si riferisce l?articolo.
Espandi tutto | Chiudi tutto

In questa pagina

Sommario

Il debug flat thunk generati dal compilatore thunk può essere difficile poiché il meccanismo di thunk è complesso e strumenti di debug in grado di analisi tramite thunk sono difficili da utilizzare. Una strategia globale per il debug di thunk flat, diverse tecniche di debug specifiche e una Guida di risoluzione dei problemi viene spiegato come risolvere molti problemi comuni di thunk presentati.

Informazioni

Limitazioni cosa può fare una DLL di destinazione

Prima di iniziare il debug di thunk, tenere presente che esistono alcune limitazioni che una destinazione DLL procedere all'interno di un thunk. Poiché un'applicazione basata su Win16 chiama una DLL Win32 non è un processo basate su Win32; allo stesso modo, un'applicazione basata su Win32 chiama una DLL Win16 non è un processo di Win16. Limitazioni specifiche comuni includono:

  • Non è possibile creare thread all'interno di un thunk da un'applicazione Win16 a una DLL Win32.
  • Il codice nelle DLL basate su Win32, chiamato dal thunk dovrebbe essere richiesto spazio dello stack poco poiché i processi di Win16 chiamante dispongono di stack molto inferiore rispetto a applicazioni basate su Win32.
  • DLL di Win16 che contengono le routine di servizio di interrupt (ISR) non deve thunk a basate su Win32 DLL durante la gestione degli interrupt.
  • Applicazioni basate su Win32 necessario non passare puntatori a dati situati nello stack come parametri di chiamata DLL Win16 che passare stack o thunk dati.

Perché può essere difficile debug flat thunk

Il debug di thunk flat infatti difficile parzialmente il meccanismo flat thunk fa parte complessa il kernel di Windows. Le radici di complessità dal fatto che è necessario trasformare le chiamate di funzione in codice compilato a 32 bit in chiamate compatibile, in con codice a 16 bit e viceversa. Poiché codice a 32 bit utilizza diversi tipi di dati e della CPU registrare gruppi di codice a 16 bit, il meccanismo di thunk flat necessario tradurre i parametri di funzione, selezionare stack e tradurre i valori restituiti. È ottimizzata per la velocità, ma è necessario consentire preemptive codice Win32 chiamare codice non preemptive di Win16. Il compilatore thunk thunk flat creazione molto più facile creare manualmente, ma non è infallibile.

Il debug thunk flat difficile non è solo perché il meccanismo di se stesso è complesso, ma anche in poiché gli strumenti di debug necessari non sono più difficili da master. Livello di applicazione debugger, ad esempio il debugger di Microsoft Visual c ++ e WinDBG non traccia tramite thunk quanto sono costituiti da codice sia a 32 e 16 bit e impedire al sistema richiedere o rilasciare il Win16Mutex. Per tracciare attraverso un thunk, è necessario utilizzare un debugger a livello di sistema, ad esempio WDEB386.EXE. Gli svantaggi principali per l'utilizzo di WDEB386.EXE sono che è necessario conoscere il linguaggio assembly Intel x 86, conoscere il funzionamento di microprocessori Intel x 86 e ricordare di molti comandi del debugger.

La strategia di procedure da utilizzare

La migliore strategia per il debug di thunk è per dividere e conquistare perché è relativamente semplice ed elimina la maggior parte dei problemi, prima di eseguire l'analisi mediante il linguaggio assembly di codice in un debugger a livello di sistema. Thunk flat sono composti da una DLL Win32 e da una DLL di Win16, pertanto è possibile verificare ciascuna di esse in isolamento prima di verificarne la insieme. Creare un'applicazione basata su Win16 per verificare la DLL di Win16 e creare un'applicazione Win32 per verificare la DLL basate su Win32. In questo modo consente di utilizzare una vasta gamma di strumenti di debug per verificare il corretto funzionamento di ogni lato.

Elenco di controllo preliminare - prima compilazione con il compilatore thunk

Dopo avere verificato il corretto funzionamento di ciascun lato, è tempo per inserire i due per verificare il thunk stesso. Prima di compilare il thunk con il compilatore thunk, apportare un controllo preliminare dei seguenti elementi:
  1. Nello script thunk, assicurarsi che ciascuna funzione disponga il numero corretto e i tipi di parametri. Assicurarsi inoltre che i tipi di parametro sono supportati dal compilatore thunk. Se non si trovano, sarà necessario modificare il parametro in qualche modo per passare i dati con un tipo supportato.
  2. Se si passano le strutture come parametri, assicurarsi di che utilizzare la stessa struttura di trasporto nel basate su Win32 DLL, DLL Win16 e script thunk. È possibile impostare compressione struttura nella riga di comando del compilatore di C/C ++ e nella riga di comando del compilatore di thunk. Si noti che opzione di compressione del compilatore thunk è per il lato a 16 bit, maiuscole e minuscole per il lato a 32 bit.
  3. Assicurarsi che le funzioni che sta thunk per vengono esportate correttamente e utilizzano il PASCAL chiamando convenzione se sono 16 bit o _stdcall se sono a 32 bit. Il compilatore thunk non supporta le convenzioni di chiamata __fastcall _cdecl.
  4. Assicurarsi che la DLL basate su Win32 chiama ThunkConnect32() ogni volta che la funzione di DllMain() viene chiamata. Allo stesso modo, assicurarsi che la DLL di Win16 disponga di una funzione DllEntryPoint() esportata, separata dal relativo LibMain(), che chiama ThunkConnect16() e restituisce TRUE se ThunkConnect16() ha esito positivo.

    Nota : È effettivamente chiamare XXX_ThunkConnect16() e XXX_ThunkConnect32() dove XXX è il simbolo è possibile definire con l'opzione -t del compilatore thunk. Il codice generato dal compilatore thunk utilizza questi simboli per generare tabelle che chiamare ThunkConnect16() e ThunkConnect32.
  5. Assicurarsi che il valore specificato nell'opzione -t della riga di comando del compilatore thunk sia quello di Win32 e la DLL di Win16 thunk. Il valore deve corrispondere inoltre al prefisso delle chiamate ThunkConnect nelle DLL Win16 e Win32 (vedere la nota nel passaggio 4).
  6. Verificare che la DLL di Win16 disponga DLLEntryPoint esportati con la parola chiave RESIDENTNAME nel relativo file di definizione (DEF) del modulo. Senza la parola chiave RESIDENTNAME, la chiamata/ThunkConnect16 ThunkConnect32 non riuscirà e le DLL non verranno caricati.
  7. Verificare che la DLL a 16 bit sia XXX_ThunkData16 esportati con la parola chiave RESIDENTNAME nel relativo file di definizione (DEF) del modulo.
  8. Verificare che il compilatore di risorse è contrassegnare la DLL 4.0 in makefile di DLL Win16. Se è contrassegnato minore 4.0, non viene caricata e il thunk non riuscirà.
  9. Se la funzione di thunk a 16 bit a 32 bit restituisce un puntatore, assicurarsi che che il tipo base è la stessa dimensione su entrambi i lati di 16 bit e a 32 bit del thunk. Se la dimensione del tipo di base è diversa, quindi il compilatore di thunk genera un messaggio di errore che indica, "Impossibile restituire i puntatori a tipi non identici." Uno per risolvere questo problema consiste nel restituire un puntatore a un tipo di dati diversi, ma compatibili. Un thunk non può, ad esempio, restituisca un puntatore a un int poiché int è di due byte sul lato 16 bit, ma a quattro byte sul lato 32 bit. Modificare il tipo restituito del thunk da un puntatore in un int a un puntatore a un tipo long nello script di thunk e il codice di origine delle DLL Win16 e Win32.

    Se si scrive un thunk di 16 bit a 32 bit che restituisce un puntatore, il compilatore di thunk genera un messaggio di errore che indica, "non possono essere restituiti tipi puntatore." Il compilatore thunk non consente il thunk di 16 bit a 32 bit restituire i tipi di puntatore, perché una volta che il thunk ha restituito dalla funzione 32 bit, il puntatore non punterà a dati nello spazio indirizzo di processo corretto basate su Win32. Infatti, gli spazi degli indirizzi di tutti i processi basate su Win32 utilizza gli stessi indirizzi intervallo e vengono preventivamente commutazione di contesto.
  10. Se il linker segnala un errore "non risolto esterno" e il simbolo è un nome di funzione che sia stato digitato in modo coerente in tutto il codice sorgente, file di definizione del modulo e lo script di thunk, assicurarsi che tutte le occorrenze del relativo prototipo sono coerenti. Sul lato Win32, la funzione di thunk necessario possibile dichiarare con il tipo di __stdcall; sul lato Win16, è necessario dichiarare la funzione con il tipo PASCAL in. Nei progetti c ++, accertarsi di dichiarare e definire entrambi i lati della funzione di thunk con l'identificatore di collegamento extern "C" oltre alla __stdcall o il tipo PASCAL.

Guida trouble-Shooting - dopo la compilazione con il compilatore thunk

Dopo avere controllato la preliminaries, generare la DLL thunk e provare a eseguirli. Se vengono eseguite, continuare con l'ulteriore di test per assicurarsi che sta rock a tinta unita. Se non eseguiti, utilizzare la Guida di risoluzione dei problemi seguente per individuare e correggere la causa del problema.

Ha esito negativo ThunkConnect16() nella Win16 o ThunkConnect32() sul lato di Win32:

  1. Eseguire le versioni debug di DLL di sistema. Le versioni di debug di Kernel32.dll e KRNL386.exe contengono molti messaggi di diagnostici per indicare il motivo per cui non è stato inizializzato il thunk. Per eseguire le versioni di debug di DLL di sistema, utilizzare l'icona di "Passa a DLLs debug" nel menu di avvio in strumenti Win32 di SDK. Utilizzare il "passa alla DLL di debug non" per tornare alla versione finale.
  2. Verificare che la DLL di Win16 ha una chiamata a ThunkConnect16() e la DLL basate su Win32 ha una chiamata corrispondente a ThunkConnect32(). Se uno di questi è manca, quindi l'altro avrà esito negativo e il thunk dll non verrà caricato.
  3. Inserire punti di interruzione in DllMain() della DLL di Win32 e la DLL di Win16 DllEntryPoint() e LibMain() funzioni per vedere le DLL non caricati.
Se le chiamate a ThunkConnect16() e ThunkConnect32() funzionino correttamente, ma non è ancora il thunk, è tempo per semplificare il thunk. È possibile attaccare effettivamente questo in due modi. Avviare rimozione di parametri dal thunk uno alla volta e ricompilando. O, in secondo luogo, creare un semplice thunk che funziona e generarlo fino a quando non riesce, attenendosi alla procedura seguente:
  1. Creare un semplice thunk ed eseguirlo solo per assicurarsi di che avere impostato correttamente il meccanismo di thunk. Una buona scelta per un thunk semplice è una funzione con nessun valore restituito e non parametri. Se anche il thunk semplice non funziona, eseguire tramite l'elenco preliminare di controllo per assicurarsi di che avere operazioni impostate correttamente. Procedere con il passaggio 2.
  2. Verificare che la DLL di destinazione e tutte le DLL si basa su possono essere trovate e caricate. Se manca uno o possibile trovare il caricatore, il thunk non funziona.
  3. Assicurarsi che la DLL non è in qualcosa che ciò non è possibile nel contesto di un thunk di destinazione.
Una volta che si dispone di un thunk semplificato che funziona, ma il thunk reale continua a non funzionare, attenersi alla seguente procedura:
  1. Per aggiungere parametri al thunk semplice uno alla volta per determinare se l'errore è causato da un parametro. Se, assicurarsi che il parametro è il tipo corretto, che la funzione viene dichiarata e definita con lo stesso numero e tipi di parametri in entrambe le DLL e il compilatore thunk, e che la funzione viene dichiarata come PASCAL o _stdcall.
  2. Se la DLL di destinazione è una DLL Win16 e non è possibile accedere i dati globali o statici, verificare che esportato correttamente la funzione. Se si utilizza l'opzione /Gd con Visual c ++, è necessario dichiarare e definire la funzione con la parola chiave __export nel codice sorgente della DLL di Win16. Elenco solo il nome della funzione nel file di definizione (DEF) di DLL del modulo non è sufficiente perché il compilatore non elabora il file DEF, è che non venga generato il prologo e richiedono codice di epilogo che funzioni esportate.
  3. Se le chiamate a LocalAlloc() negli errori di protezione generale (GP) di destinazione DLL Win16 causa, assicurarsi che la funzione viene esportata come descritto nel passaggio 2.
  4. Se viene visualizzato un errore di protezione generale in Kernel32 subito dopo la funzione Win16 restituisce di destinazione, assicurarsi che la funzione di destinazione è dichiarata e definita come PASCAL. Non è possibile utilizzare la convenzione di chiamata C. Sebbene raro che nel codice C o c ++, ma più probabile che in linguaggio assembly, assicurarsi che la funzione di destinazione non modifica i registri DS, II, BP, SI o DI.
  5. Se viene visualizzato un errore di protezione generale nel thunk 32-bit DLL o Kernel32 immediatamente dopo la funzione restituisce destinazione basate su Win32, assicurarsi che la funzione di destinazione è dichiarata come _stdcall e che non modifica i registri DS, ES, FI, II, EBP, EBX, ESI o EDI. Codice C o c ++ non dovrebbe causare i registri da modificare, ma il codice in linguaggio assembly è necessario controllare con attenzione.
  6. Se il Win16 funzione di destinazione restituisce in una posizione non valida, assicurarsi che è dichiarato e definito come FAR. Si tratta di particolarmente importante per le DLL modello di piccole dimensioni, funzioni di DLL modello medie e grandi dimensioni sono FAR per impostazione predefinita.
  7. Se si verifica un errore di criteri di gruppo in una funzione di Win16 quando si accede più di 64 KB di dati da un puntatore passato come un parametro (ovvero un puntatore thunked), è necessario allocare una matrice di selettori affiancate, come descritto nel seguente articolo della Microsoft Knowledge Base riportato di seguito:
    132005DOCERR: Documentazione di AllocSelector & FreeSelector incompleto
    Sul lato Win16, puntatori thunked sempre costituito un selettore singolo con un limite di 64 KB, significa che è Impossibile utilizzare come puntatori di grandi dimensioni. L'intero intervallo originale di dati che risolve il puntatore è accessibile a destinazione Win16 DLL - ma solo se crea una matrice di selettori affiancati per farvi riferimento e se utilizza le variabili di puntatore enorme per accedere ai dati.
  8. Assicurarsi di che utilizzare solo un puntatore thunked nel contesto del thunk. Selettori allocati dal compilatore thunk per l'utilizzo da Win16 destinazioni vengono liberati non appena il thunk restituisce.
  9. Inserire punti di interruzione all'inizio delle funzioni di destinazione per assicurarsi che si sta ottenere al loro interno. Se si ed è il lato di destinazione in modo indipendente del thunk esegue il debug e l'errore è causato all'interno della destinazione, probabilità sono utili che la destinazione è in qualcosa che non può essere eseguita in un thunk o riferimento a memoria che non esiste. Vedere i passaggi 7 e 8.

Proprietà

Identificativo articolo: 133722 - Ultima modifica: lunedì 11 luglio 2005 - Revisione: 2.3
Le informazioni in questo articolo si applicano a:
  • Microsoft Platform Software Development Kit-edizione gennaio 2000 alle seguenti piattaforme
    • Microsoft Windows 95
    • Microsoft Windows 98 Standard Edition
    • Microsoft Windows Millennium Edition
Chiavi: 
kbmt kbhowto kbkernbase kbprogramming KB133722 KbMtit
Traduzione automatica articoli
Il presente articolo è stato tradotto tramite il software di traduzione automatica di Microsoft e non da una persona. Microsoft offre sia articoli tradotti da persone fisiche sia articoli tradotti automaticamente da un software, in modo da rendere disponibili tutti gli articoli presenti nella nostra Knowledge Base nella lingua madre dell?utente. Tuttavia, un articolo tradotto in modo automatico non è sempre perfetto. Potrebbe contenere errori di sintassi, di grammatica o di utilizzo dei vocaboli, più o meno allo stesso modo di come una persona straniera potrebbe commettere degli errori parlando una lingua che non è la sua. Microsoft non è responsabile di alcuna imprecisione, errore o danno cagionato da qualsiasi traduzione non corretta dei contenuti o dell?utilizzo degli stessi fatto dai propri clienti. Microsoft, inoltre, aggiorna frequentemente il software di traduzione automatica.
Clicca qui per visualizzare la versione originale in inglese dell?articolo: 133722
LE INFORMAZIONI CONTENUTE NELLA MICROSOFT KNOWLEDGE BASE SONO FORNITE SENZA GARANZIA DI ALCUN TIPO, IMPLICITA OD ESPLICITA, COMPRESA QUELLA RIGUARDO ALLA COMMERCIALIZZAZIONE E/O COMPATIBILITA' IN IMPIEGHI PARTICOLARI. L'UTENTE SI ASSUME L'INTERA RESPONSABILITA' PER L'UTILIZZO DI QUESTE INFORMAZIONI. IN NESSUN CASO MICROSOFT CORPORATION E I SUOI FORNITORI SI RENDONO RESPONSABILI PER DANNI DIRETTI, INDIRETTI O ACCIDENTALI CHE POSSANO PROVOCARE PERDITA DI DENARO O DI DATI, ANCHE SE MICROSOFT O I SUOI FORNITORI FOSSERO STATI AVVISATI. IL DOCUMENTO PUO' ESSERE COPIATO E DISTRIBUITO ALLE SEGUENTI CONDIZIONI: 1) IL TESTO DEVE ESSERE COPIATO INTEGRALMENTE E TUTTE LE PAGINE DEVONO ESSERE INCLUSE. 2) I PROGRAMMI SE PRESENTI, DEVONO ESSERE COPIATI SENZA MODIFICHE, 3) IL DOCUMENTO DEVE ESSERE DISTRIBUITO INTERAMENTE IN OGNI SUA PARTE. 4) IL DOCUMENTO NON PUO' ESSERE DISTRIBUITO A SCOPO DI LUCRO.

Invia suggerimenti

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com